• 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.5.  */
00002 
00003 /* Bison implementation for Yacc-like parsers in C
00004    
00005       Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
00006    
00007    This program is free software: you can redistribute it and/or modify
00008    it under the terms of the GNU General Public License as published by
00009    the Free Software Foundation, either version 3 of the License, or
00010    (at your option) any later version.
00011    
00012    This program is distributed in the hope that it will be useful,
00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015    GNU General Public License for more details.
00016    
00017    You should have received a copy of the GNU General Public License
00018    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00019 
00020 /* As a special exception, you may create a larger work that contains
00021    part or all of the Bison parser skeleton and distribute that work
00022    under terms of your choice, so long as that work isn't itself a
00023    parser generator using the skeleton or a modified version thereof
00024    as a parser skeleton.  Alternatively, if you modify or redistribute
00025    the parser skeleton itself, you may (at your option) remove this
00026    special exception, which will cause the skeleton and the resulting
00027    Bison output files to be licensed under the GNU General Public
00028    License without this special exception.
00029    
00030    This special exception was added by the Free Software Foundation in
00031    version 2.2 of Bison.  */
00032 
00033 /* C LALR(1) parser skeleton written by Richard Stallman, by
00034    simplifying the original so-called "semantic" parser.  */
00035 
00036 /* All symbols defined below should begin with yy or YY, to avoid
00037    infringing on user name space.  This should be done even for local
00038    variables, as they might otherwise be expanded by user macros.
00039    There are some unavoidable exceptions within include files to
00040    define necessary library symbols; they are noted "INFRINGES ON
00041    USER NAME SPACE" below.  */
00042 
00043 /* Identify Bison output.  */
00044 #define YYBISON 1
00045 
00046 /* Bison version.  */
00047 #define YYBISON_VERSION "2.5"
00048 
00049 /* Skeleton name.  */
00050 #define YYSKELETON_NAME "yacc.c"
00051 
00052 /* Pure parsers.  */
00053 #define YYPURE 1
00054 
00055 /* Push parsers.  */
00056 #define YYPUSH 0
00057 
00058 /* Pull parsers.  */
00059 #define YYPULL 1
00060 
00061 /* Using locations.  */
00062 #define YYLSP_NEEDED 0
00063 
00064 
00065 
00066 /* Copy the first part of user declarations.  */
00067 
00068 /* Line 268 of yacc.c  */
00069 #line 12 "ripper.y"
00070 
00071 
00072 #define YYDEBUG 1
00073 #define YYERROR_VERBOSE 1
00074 #define YYSTACK_USE_ALLOCA 0
00075 
00076 #include "ruby/ruby.h"
00077 #include "ruby/st.h"
00078 #include "ruby/encoding.h"
00079 #include "node.h"
00080 #include "parse.h"
00081 #include "id.h"
00082 #include "regenc.h"
00083 #include <stdio.h>
00084 #include <errno.h>
00085 #include <ctype.h>
00086 
00087 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
00088 
00089 #define YYMALLOC(size)          rb_parser_malloc(parser, size)
00090 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, ptr, size)
00091 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, nelem, size)
00092 #define YYFREE(ptr)             rb_parser_free(parser, ptr)
00093 #define malloc  YYMALLOC
00094 #define realloc YYREALLOC
00095 #define calloc  YYCALLOC
00096 #define free    YYFREE
00097 
00098 #ifndef RIPPER
00099 static ID register_symid(ID, const char *, long, rb_encoding *);
00100 #define REGISTER_SYMID(id, name) register_symid(id, name, strlen(name), enc)
00101 #include "id.c"
00102 #endif
00103 
00104 #define is_notop_id(id) ((id)>tLAST_TOKEN)
00105 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00106 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00107 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00108 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00109 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00110 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00111 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00112 
00113 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00114         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00115          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00116          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00117 
00118 enum lex_state_e {
00119     EXPR_BEG,                   /* ignore newline, +/- is a sign. */
00120     EXPR_END,                   /* newline significant, +/- is an operator. */
00121     EXPR_ENDARG,                /* ditto, and unbound braces. */
00122     EXPR_ENDFN,                 /* ditto, and unbound braces. */
00123     EXPR_ARG,                   /* newline significant, +/- is an operator. */
00124     EXPR_CMDARG,                /* newline significant, +/- is an operator. */
00125     EXPR_MID,                   /* newline significant, +/- is an operator. */
00126     EXPR_FNAME,                 /* ignore newline, no reserved words. */
00127     EXPR_DOT,                   /* right after `.' or `::', no reserved words. */
00128     EXPR_CLASS,                 /* immediate after `class', no here document. */
00129     EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
00130     EXPR_MAX_STATE
00131 };
00132 
00133 typedef VALUE stack_type;
00134 
00135 # define BITSTACK_PUSH(stack, n)        (stack = (stack<<1)|((n)&1))
00136 # define BITSTACK_POP(stack)    (stack = stack >> 1)
00137 # define BITSTACK_LEXPOP(stack) (stack = (stack >> 1) | (stack & 1))
00138 # define BITSTACK_SET_P(stack)  (stack&1)
00139 
00140 #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, n)
00141 #define COND_POP()      BITSTACK_POP(cond_stack)
00142 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
00143 #define COND_P()        BITSTACK_SET_P(cond_stack)
00144 
00145 #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, n)
00146 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
00147 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
00148 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
00149 
00150 struct vtable {
00151     ID *tbl;
00152     int pos;
00153     int capa;
00154     struct vtable *prev;
00155 };
00156 
00157 struct local_vars {
00158     struct vtable *args;
00159     struct vtable *vars;
00160     struct local_vars *prev;
00161 };
00162 
00163 #define DVARS_INHERIT ((void*)1)
00164 #define DVARS_TOPSCOPE NULL
00165 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
00166 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
00167 
00168 static int
00169 vtable_size(const struct vtable *tbl)
00170 {
00171     if (POINTER_P(tbl)) {
00172         return tbl->pos;
00173     }
00174     else {
00175         return 0;
00176     }
00177 }
00178 
00179 #define VTBL_DEBUG 0
00180 
00181 static struct vtable *
00182 vtable_alloc(struct vtable *prev)
00183 {
00184     struct vtable *tbl = ALLOC(struct vtable);
00185     tbl->pos = 0;
00186     tbl->capa = 8;
00187     tbl->tbl = ALLOC_N(ID, tbl->capa);
00188     tbl->prev = prev;
00189     if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
00190     return tbl;
00191 }
00192 
00193 static void
00194 vtable_free(struct vtable *tbl)
00195 {
00196     if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
00197     if (POINTER_P(tbl)) {
00198         if (tbl->tbl) {
00199             xfree(tbl->tbl);
00200         }
00201         xfree(tbl);
00202     }
00203 }
00204 
00205 static void
00206 vtable_add(struct vtable *tbl, ID id)
00207 {
00208     if (!POINTER_P(tbl)) {
00209         rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
00210     }
00211     if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
00212 
00213     if (tbl->pos == tbl->capa) {
00214         tbl->capa = tbl->capa * 2;
00215         REALLOC_N(tbl->tbl, ID, tbl->capa);
00216     }
00217     tbl->tbl[tbl->pos++] = id;
00218 }
00219 
00220 static int
00221 vtable_included(const struct vtable * tbl, ID id)
00222 {
00223     int i;
00224 
00225     if (POINTER_P(tbl)) {
00226         for (i = 0; i < tbl->pos; i++) {
00227             if (tbl->tbl[i] == id) {
00228                 return 1;
00229             }
00230         }
00231     }
00232     return 0;
00233 }
00234 
00235 
00236 #ifndef RIPPER
00237 typedef struct token_info {
00238     const char *token;
00239     int linenum;
00240     int column;
00241     int nonspc;
00242     struct token_info *next;
00243 } token_info;
00244 #endif
00245 
00246 /*
00247     Structure of Lexer Buffer:
00248 
00249  lex_pbeg      tokp         lex_p        lex_pend
00250     |           |              |            |
00251     |-----------+--------------+------------|
00252                 |<------------>|
00253                      token
00254 */
00255 struct parser_params {
00256     int is_ripper;
00257     NODE *heap;
00258 
00259     YYSTYPE *parser_yylval;
00260     VALUE eofp;
00261 
00262     NODE *parser_lex_strterm;
00263     enum lex_state_e parser_lex_state;
00264     stack_type parser_cond_stack;
00265     stack_type parser_cmdarg_stack;
00266     int parser_class_nest;
00267     int parser_paren_nest;
00268     int parser_lpar_beg;
00269     int parser_in_single;
00270     int parser_in_def;
00271     int parser_compile_for_eval;
00272     VALUE parser_cur_mid;
00273     int parser_in_defined;
00274     char *parser_tokenbuf;
00275     int parser_tokidx;
00276     int parser_toksiz;
00277     VALUE parser_lex_input;
00278     VALUE parser_lex_lastline;
00279     VALUE parser_lex_nextline;
00280     const char *parser_lex_pbeg;
00281     const char *parser_lex_p;
00282     const char *parser_lex_pend;
00283     int parser_heredoc_end;
00284     int parser_command_start;
00285     NODE *parser_deferred_nodes;
00286     long parser_lex_gets_ptr;
00287     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00288     struct local_vars *parser_lvtbl;
00289     int parser_ruby__end__seen;
00290     int line_count;
00291     int has_shebang;
00292     char *parser_ruby_sourcefile; /* current source file */
00293     int parser_ruby_sourceline; /* current line no. */
00294     rb_encoding *enc;
00295     rb_encoding *utf8;
00296 
00297     int parser_yydebug;
00298 
00299 #ifndef RIPPER
00300     /* Ruby core only */
00301     NODE *parser_eval_tree_begin;
00302     NODE *parser_eval_tree;
00303     VALUE debug_lines;
00304     VALUE coverage;
00305     int nerr;
00306 
00307     token_info *parser_token_info;
00308 #else
00309     /* Ripper only */
00310     VALUE parser_ruby_sourcefile_string;
00311     const char *tokp;
00312     VALUE delayed;
00313     int delayed_line;
00314     int delayed_col;
00315 
00316     VALUE value;
00317     VALUE result;
00318     VALUE parsing_thread;
00319     int toplevel_p;
00320 #endif
00321 };
00322 
00323 #define UTF8_ENC() (parser->utf8 ? parser->utf8 : \
00324                     (parser->utf8 = rb_utf8_encoding()))
00325 #define STR_NEW(p,n) rb_enc_str_new((p),(n),parser->enc)
00326 #define STR_NEW0() rb_enc_str_new(0,0,parser->enc)
00327 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),parser->enc)
00328 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),parser->enc)
00329 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
00330 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), parser->enc)
00331 
00332 #ifdef YYMALLOC
00333 void *rb_parser_malloc(struct parser_params *, size_t);
00334 void *rb_parser_realloc(struct parser_params *, void *, size_t);
00335 void *rb_parser_calloc(struct parser_params *, size_t, size_t);
00336 void rb_parser_free(struct parser_params *, void *);
00337 #endif
00338 
00339 static int parser_yyerror(struct parser_params*, const char*);
00340 #define yyerror(msg) parser_yyerror(parser, msg)
00341 
00342 #define YYLEX_PARAM parser
00343 
00344 #define lex_strterm             (parser->parser_lex_strterm)
00345 #define lex_state               (parser->parser_lex_state)
00346 #define cond_stack              (parser->parser_cond_stack)
00347 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00348 #define class_nest              (parser->parser_class_nest)
00349 #define paren_nest              (parser->parser_paren_nest)
00350 #define lpar_beg                (parser->parser_lpar_beg)
00351 #define in_single               (parser->parser_in_single)
00352 #define in_def                  (parser->parser_in_def)
00353 #define compile_for_eval        (parser->parser_compile_for_eval)
00354 #define cur_mid                 (parser->parser_cur_mid)
00355 #define in_defined              (parser->parser_in_defined)
00356 #define tokenbuf                (parser->parser_tokenbuf)
00357 #define tokidx                  (parser->parser_tokidx)
00358 #define toksiz                  (parser->parser_toksiz)
00359 #define lex_input               (parser->parser_lex_input)
00360 #define lex_lastline            (parser->parser_lex_lastline)
00361 #define lex_nextline            (parser->parser_lex_nextline)
00362 #define lex_pbeg                (parser->parser_lex_pbeg)
00363 #define lex_p                   (parser->parser_lex_p)
00364 #define lex_pend                (parser->parser_lex_pend)
00365 #define heredoc_end             (parser->parser_heredoc_end)
00366 #define command_start           (parser->parser_command_start)
00367 #define deferred_nodes          (parser->parser_deferred_nodes)
00368 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00369 #define lex_gets                (parser->parser_lex_gets)
00370 #define lvtbl                   (parser->parser_lvtbl)
00371 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00372 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00373 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00374 #define yydebug                 (parser->parser_yydebug)
00375 #ifdef RIPPER
00376 #else
00377 #define ruby_eval_tree          (parser->parser_eval_tree)
00378 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00379 #define ruby_debug_lines        (parser->debug_lines)
00380 #define ruby_coverage           (parser->coverage)
00381 #endif
00382 
00383 static int yylex(void*, void*);
00384 
00385 #ifndef RIPPER
00386 #define yyparse ruby_yyparse
00387 
00388 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00389 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, type, a1, a2, a3)
00390 
00391 static NODE *cond_gen(struct parser_params*,NODE*);
00392 #define cond(node) cond_gen(parser, node)
00393 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00394 #define logop(type,node1,node2) logop_gen(parser, type, node1, node2)
00395 
00396 static NODE *newline_node(NODE*);
00397 static void fixpos(NODE*,NODE*);
00398 
00399 static int value_expr_gen(struct parser_params*,NODE*);
00400 static void void_expr_gen(struct parser_params*,NODE*);
00401 static NODE *remove_begin(NODE*);
00402 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00403 #define void_expr0(node) void_expr_gen(parser, (node))
00404 #define void_expr(node) void_expr0((node) = remove_begin(node))
00405 static void void_stmts_gen(struct parser_params*,NODE*);
00406 #define void_stmts(node) void_stmts_gen(parser, node)
00407 static void reduce_nodes_gen(struct parser_params*,NODE**);
00408 #define reduce_nodes(n) reduce_nodes_gen(parser,n)
00409 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00410 #define block_dup_check(n1,n2) block_dup_check_gen(parser,n1,n2)
00411 
00412 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00413 #define block_append(h,t) block_append_gen(parser,h,t)
00414 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00415 #define list_append(l,i) list_append_gen(parser,l,i)
00416 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00417 #define list_concat(h,t) list_concat_gen(parser,h,t)
00418 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00419 #define arg_append(h,t) arg_append_gen(parser,h,t)
00420 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00421 #define arg_concat(h,t) arg_concat_gen(parser,h,t)
00422 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00423 #define literal_concat(h,t) literal_concat_gen(parser,h,t)
00424 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00425 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00426 #define new_evstr(n) new_evstr_gen(parser,n)
00427 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00428 #define evstr2dstr(n) evstr2dstr_gen(parser,n)
00429 static NODE *splat_array(NODE*);
00430 
00431 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00432 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, recv,id,arg1)
00433 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00434 #define call_uni_op(recv,id) call_uni_op_gen(parser, recv,id)
00435 
00436 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
00437 #define new_args(f,o,r,p,b) new_args_gen(parser, f,o,r,p,b)
00438 
00439 static NODE *negate_lit(NODE*);
00440 static NODE *ret_args_gen(struct parser_params*,NODE*);
00441 #define ret_args(node) ret_args_gen(parser, node)
00442 static NODE *arg_blk_pass(NODE*,NODE*);
00443 static NODE *new_yield_gen(struct parser_params*,NODE*);
00444 #define new_yield(node) new_yield_gen(parser, node)
00445 
00446 static NODE *gettable_gen(struct parser_params*,ID);
00447 #define gettable(id) gettable_gen(parser,id)
00448 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00449 #define assignable(id,node) assignable_gen(parser, id, node)
00450 
00451 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00452 #define aryset(node1,node2) aryset_gen(parser, node1, node2)
00453 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00454 #define attrset(node,id) attrset_gen(parser, node, id)
00455 
00456 static void rb_backref_error_gen(struct parser_params*,NODE*);
00457 #define rb_backref_error(n) rb_backref_error_gen(parser,n)
00458 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00459 #define node_assign(node1, node2) node_assign_gen(parser, node1, node2)
00460 
00461 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00462 #define match_op(node1,node2) match_op_gen(parser, node1, node2)
00463 
00464 static ID  *local_tbl_gen(struct parser_params*);
00465 #define local_tbl() local_tbl_gen(parser)
00466 
00467 static void fixup_nodes(NODE **);
00468 
00469 extern int rb_dvar_defined(ID);
00470 extern int rb_local_defined(ID);
00471 extern int rb_parse_in_eval(void);
00472 extern int rb_parse_in_main(void);
00473 
00474 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00475 #define reg_compile(str,options) reg_compile_gen(parser, str, options)
00476 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00477 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, str, options)
00478 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00479 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, str, options)
00480 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00481 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,regexp,match)
00482 
00483 #define get_id(id) (id)
00484 #define get_value(val) (val)
00485 #else
00486 #define remove_begin(node) (node)
00487 #define rb_dvar_defined(id) 0
00488 #define rb_local_defined(id) 0
00489 static ID ripper_get_id(VALUE);
00490 #define get_id(id) ripper_get_id(id)
00491 static VALUE ripper_get_value(VALUE);
00492 #define get_value(val) ripper_get_value(val)
00493 static VALUE assignable_gen(struct parser_params*,VALUE);
00494 #define assignable(lhs,node) assignable_gen(parser, lhs)
00495 #endif /* !RIPPER */
00496 
00497 static ID formal_argument_gen(struct parser_params*, ID);
00498 #define formal_argument(id) formal_argument_gen(parser, id)
00499 static ID shadowing_lvar_gen(struct parser_params*,ID);
00500 #define shadowing_lvar(name) shadowing_lvar_gen(parser, name)
00501 static void new_bv_gen(struct parser_params*,ID);
00502 #define new_bv(id) new_bv_gen(parser, id)
00503 
00504 static void local_push_gen(struct parser_params*,int);
00505 #define local_push(top) local_push_gen(parser,top)
00506 static void local_pop_gen(struct parser_params*);
00507 #define local_pop() local_pop_gen(parser)
00508 static int local_var_gen(struct parser_params*, ID);
00509 #define local_var(id) local_var_gen(parser, id);
00510 static int arg_var_gen(struct parser_params*, ID);
00511 #define arg_var(id) arg_var_gen(parser, id)
00512 static int  local_id_gen(struct parser_params*, ID);
00513 #define local_id(id) local_id_gen(parser, id)
00514 static ID   internal_id_gen(struct parser_params*);
00515 #define internal_id() internal_id_gen(parser)
00516 
00517 static const struct vtable *dyna_push_gen(struct parser_params *);
00518 #define dyna_push() dyna_push_gen(parser)
00519 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00520 #define dyna_pop(node) dyna_pop_gen(parser, node)
00521 static int dyna_in_block_gen(struct parser_params*);
00522 #define dyna_in_block() dyna_in_block_gen(parser)
00523 #define dyna_var(id) local_var(id)
00524 static int dvar_defined_gen(struct parser_params*,ID);
00525 #define dvar_defined(id) dvar_defined_gen(parser, id)
00526 static int dvar_curr_gen(struct parser_params*,ID);
00527 #define dvar_curr(id) dvar_curr_gen(parser, id)
00528 
00529 static int lvar_defined_gen(struct parser_params*, ID);
00530 #define lvar_defined(id) lvar_defined_gen(parser, id)
00531 
00532 #define RE_OPTION_ONCE (1<<16)
00533 #define RE_OPTION_ENCODING_SHIFT 8
00534 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00535 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00536 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00537 #define RE_OPTION_MASK  0xff
00538 #define RE_OPTION_ARG_ENCODING_NONE 32
00539 
00540 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00541 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00542 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00543 #define nd_func u1.id
00544 #if SIZEOF_SHORT == 2
00545 #define nd_term(node) ((signed short)(node)->u2.id)
00546 #else
00547 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00548 #endif
00549 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00550 #define nd_nest u3.cnt
00551 
00552 /****** Ripper *******/
00553 
00554 #ifdef RIPPER
00555 #define RIPPER_VERSION "0.1.0"
00556 
00557 #include "eventids1.c"
00558 #include "eventids2.c"
00559 static ID ripper_id_gets;
00560 
00561 static VALUE ripper_dispatch0(struct parser_params*,ID);
00562 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00563 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00564 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00565 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00566 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00567 
00568 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00569 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), a)
00570 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), a, b)
00571 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), a, b, c)
00572 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), a, b, c, d)
00573 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), a, b, c, d, e)
00574 
00575 #define yyparse ripper_yyparse
00576 
00577 #define ripper_intern(s) ID2SYM(rb_intern(s))
00578 static VALUE ripper_id2sym(ID);
00579 #ifdef __GNUC__
00580 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00581                            ID2SYM(id) : ripper_id2sym(id))
00582 #endif
00583 
00584 #define arg_new() dispatch0(args_new)
00585 #define arg_add(l,a) dispatch2(args_add, l, a)
00586 #define arg_add_star(l,a) dispatch2(args_add_star, l, a)
00587 #define arg_add_block(l,b) dispatch2(args_add_block, l, b)
00588 #define arg_add_optblock(l,b) ((b)==Qundef? l : dispatch2(args_add_block, l, b))
00589 #define bare_assoc(v) dispatch1(bare_assoc_hash, v)
00590 #define arg_add_assocs(l,b) arg_add(l, bare_assoc(b))
00591 
00592 #define args2mrhs(a) dispatch1(mrhs_new_from_args, a)
00593 #define mrhs_new() dispatch0(mrhs_new)
00594 #define mrhs_add(l,a) dispatch2(mrhs_add, l, a)
00595 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, l, a)
00596 
00597 #define mlhs_new() dispatch0(mlhs_new)
00598 #define mlhs_add(l,a) dispatch2(mlhs_add, l, a)
00599 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, l, a)
00600 
00601 #define params_new(pars, opts, rest, pars2, blk) \
00602         dispatch5(params, pars, opts, rest, pars2, blk)
00603 
00604 #define blockvar_new(p,v) dispatch2(block_var, p, v)
00605 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, l, a)
00606 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, l, a)
00607 
00608 #define method_optarg(m,a) ((a)==Qundef ? m : dispatch2(method_add_arg,m,a))
00609 #define method_arg(m,a) dispatch2(method_add_arg,m,a)
00610 #define method_add_block(m,b) dispatch2(method_add_block, m, b)
00611 
00612 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00613 
00614 #define FIXME 0
00615 
00616 #endif /* RIPPER */
00617 
00618 #ifndef RIPPER
00619 # define ifndef_ripper(x) x
00620 #else
00621 # define ifndef_ripper(x)
00622 #endif
00623 
00624 #ifndef RIPPER
00625 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, fmt)
00626 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, fmt, a)
00627 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, fmt, a)
00628 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, fmt)
00629 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, fmt, a)
00630 #else
00631 # define rb_warn0(fmt)    ripper_warn0(parser, fmt)
00632 # define rb_warnI(fmt,a)  ripper_warnI(parser, fmt, a)
00633 # define rb_warnS(fmt,a)  ripper_warnS(parser, fmt, a)
00634 # define rb_warning0(fmt) ripper_warning0(parser, fmt)
00635 # define rb_warningS(fmt,a) ripper_warningS(parser, fmt, a)
00636 static void ripper_warn0(struct parser_params*, const char*);
00637 static void ripper_warnI(struct parser_params*, const char*, int);
00638 #if 0
00639 static void ripper_warnS(struct parser_params*, const char*, const char*);
00640 #endif
00641 static void ripper_warning0(struct parser_params*, const char*);
00642 static void ripper_warningS(struct parser_params*, const char*, const char*);
00643 #endif
00644 
00645 #ifdef RIPPER
00646 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00647 # define rb_compile_error ripper_compile_error
00648 # define compile_error ripper_compile_error
00649 # define PARSER_ARG parser,
00650 #else
00651 # define compile_error parser->nerr++,rb_compile_error
00652 # define PARSER_ARG ruby_sourcefile, ruby_sourceline,
00653 #endif
00654 
00655 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00656    for instance).  This is too low for Ruby to parse some files, such as
00657    date/format.rb, therefore bump the value up to at least Bison's default. */
00658 #ifdef OLD_YACC
00659 #ifndef YYMAXDEPTH
00660 #define YYMAXDEPTH 10000
00661 #endif
00662 #endif
00663 
00664 #ifndef RIPPER
00665 static void token_info_push(struct parser_params*, const char *token);
00666 static void token_info_pop(struct parser_params*, const char *token);
00667 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, token) : (void)0)
00668 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, token) : (void)0)
00669 #else
00670 #define token_info_push(token) /* nothing */
00671 #define token_info_pop(token) /* nothing */
00672 #endif
00673 
00674 
00675 /* Line 268 of yacc.c  */
00676 #line 677 "parse.c"
00677 
00678 /* Enabling traces.  */
00679 #ifndef YYDEBUG
00680 # define YYDEBUG 1
00681 #endif
00682 
00683 /* Enabling verbose error messages.  */
00684 #ifdef YYERROR_VERBOSE
00685 # undef YYERROR_VERBOSE
00686 # define YYERROR_VERBOSE 1
00687 #else
00688 # define YYERROR_VERBOSE 0
00689 #endif
00690 
00691 /* Enabling the token table.  */
00692 #ifndef YYTOKEN_TABLE
00693 # define YYTOKEN_TABLE 0
00694 #endif
00695 
00696 
00697 /* Tokens.  */
00698 #ifndef YYTOKENTYPE
00699 # define YYTOKENTYPE
00700    /* Put the tokens into the symbol table, so that GDB and other debuggers
00701       know about them.  */
00702    enum yytokentype {
00703      keyword_class = 258,
00704      keyword_module = 259,
00705      keyword_def = 260,
00706      keyword_undef = 261,
00707      keyword_begin = 262,
00708      keyword_rescue = 263,
00709      keyword_ensure = 264,
00710      keyword_end = 265,
00711      keyword_if = 266,
00712      keyword_unless = 267,
00713      keyword_then = 268,
00714      keyword_elsif = 269,
00715      keyword_else = 270,
00716      keyword_case = 271,
00717      keyword_when = 272,
00718      keyword_while = 273,
00719      keyword_until = 274,
00720      keyword_for = 275,
00721      keyword_break = 276,
00722      keyword_next = 277,
00723      keyword_redo = 278,
00724      keyword_retry = 279,
00725      keyword_in = 280,
00726      keyword_do = 281,
00727      keyword_do_cond = 282,
00728      keyword_do_block = 283,
00729      keyword_do_LAMBDA = 284,
00730      keyword_return = 285,
00731      keyword_yield = 286,
00732      keyword_super = 287,
00733      keyword_self = 288,
00734      keyword_nil = 289,
00735      keyword_true = 290,
00736      keyword_false = 291,
00737      keyword_and = 292,
00738      keyword_or = 293,
00739      keyword_not = 294,
00740      modifier_if = 295,
00741      modifier_unless = 296,
00742      modifier_while = 297,
00743      modifier_until = 298,
00744      modifier_rescue = 299,
00745      keyword_alias = 300,
00746      keyword_defined = 301,
00747      keyword_BEGIN = 302,
00748      keyword_END = 303,
00749      keyword__LINE__ = 304,
00750      keyword__FILE__ = 305,
00751      keyword__ENCODING__ = 306,
00752      tIDENTIFIER = 307,
00753      tFID = 308,
00754      tGVAR = 309,
00755      tIVAR = 310,
00756      tCONSTANT = 311,
00757      tCVAR = 312,
00758      tLABEL = 313,
00759      tINTEGER = 314,
00760      tFLOAT = 315,
00761      tSTRING_CONTENT = 316,
00762      tCHAR = 317,
00763      tNTH_REF = 318,
00764      tBACK_REF = 319,
00765      tREGEXP_END = 320,
00766      tUPLUS = 321,
00767      tUMINUS = 322,
00768      tPOW = 323,
00769      tCMP = 324,
00770      tEQ = 325,
00771      tEQQ = 326,
00772      tNEQ = 327,
00773      tGEQ = 328,
00774      tLEQ = 329,
00775      tANDOP = 330,
00776      tOROP = 331,
00777      tMATCH = 332,
00778      tNMATCH = 333,
00779      tDOT2 = 334,
00780      tDOT3 = 335,
00781      tAREF = 336,
00782      tASET = 337,
00783      tLSHFT = 338,
00784      tRSHFT = 339,
00785      tCOLON2 = 340,
00786      tCOLON3 = 341,
00787      tOP_ASGN = 342,
00788      tASSOC = 343,
00789      tLPAREN = 344,
00790      tLPAREN_ARG = 345,
00791      tRPAREN = 346,
00792      tLBRACK = 347,
00793      tLBRACE = 348,
00794      tLBRACE_ARG = 349,
00795      tSTAR = 350,
00796      tAMPER = 351,
00797      tLAMBDA = 352,
00798      tSYMBEG = 353,
00799      tSTRING_BEG = 354,
00800      tXSTRING_BEG = 355,
00801      tREGEXP_BEG = 356,
00802      tWORDS_BEG = 357,
00803      tQWORDS_BEG = 358,
00804      tSTRING_DBEG = 359,
00805      tSTRING_DVAR = 360,
00806      tSTRING_END = 361,
00807      tLAMBEG = 362,
00808      tLOWEST = 363,
00809      tUMINUS_NUM = 364,
00810      idNULL = 365,
00811      idRespond_to = 366,
00812      idIFUNC = 367,
00813      idCFUNC = 368,
00814      id_core_set_method_alias = 369,
00815      id_core_set_variable_alias = 370,
00816      id_core_undef_method = 371,
00817      id_core_define_method = 372,
00818      id_core_define_singleton_method = 373,
00819      id_core_set_postexe = 374,
00820      tLAST_TOKEN = 375
00821    };
00822 #endif
00823 
00824 
00825 
00826 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00827 typedef union YYSTYPE
00828 {
00829 
00830 /* Line 293 of yacc.c  */
00831 #line 620 "ripper.y"
00832 
00833     VALUE val;
00834     NODE *node;
00835     ID id;
00836     int num;
00837     const struct vtable *vars;
00838 
00839 
00840 
00841 /* Line 293 of yacc.c  */
00842 #line 843 "parse.c"
00843 } YYSTYPE;
00844 # define YYSTYPE_IS_TRIVIAL 1
00845 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00846 # define YYSTYPE_IS_DECLARED 1
00847 #endif
00848 
00849 
00850 /* Copy the second part of user declarations.  */
00851 
00852 
00853 /* Line 343 of yacc.c  */
00854 #line 855 "parse.c"
00855 
00856 #ifdef short
00857 # undef short
00858 #endif
00859 
00860 #ifdef YYTYPE_UINT8
00861 typedef YYTYPE_UINT8 yytype_uint8;
00862 #else
00863 typedef unsigned char yytype_uint8;
00864 #endif
00865 
00866 #ifdef YYTYPE_INT8
00867 typedef YYTYPE_INT8 yytype_int8;
00868 #elif (defined __STDC__ || defined __C99__FUNC__ \
00869      || defined __cplusplus || defined _MSC_VER)
00870 typedef signed char yytype_int8;
00871 #else
00872 typedef short int yytype_int8;
00873 #endif
00874 
00875 #ifdef YYTYPE_UINT16
00876 typedef YYTYPE_UINT16 yytype_uint16;
00877 #else
00878 typedef unsigned short int yytype_uint16;
00879 #endif
00880 
00881 #ifdef YYTYPE_INT16
00882 typedef YYTYPE_INT16 yytype_int16;
00883 #else
00884 typedef short int yytype_int16;
00885 #endif
00886 
00887 #ifndef YYSIZE_T
00888 # ifdef __SIZE_TYPE__
00889 #  define YYSIZE_T __SIZE_TYPE__
00890 # elif defined size_t
00891 #  define YYSIZE_T size_t
00892 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00893      || defined __cplusplus || defined _MSC_VER)
00894 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00895 #  define YYSIZE_T size_t
00896 # else
00897 #  define YYSIZE_T unsigned int
00898 # endif
00899 #endif
00900 
00901 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00902 
00903 #ifndef YY_
00904 # if defined YYENABLE_NLS && YYENABLE_NLS
00905 #  if ENABLE_NLS
00906 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00907 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00908 #  endif
00909 # endif
00910 # ifndef YY_
00911 #  define YY_(msgid) msgid
00912 # endif
00913 #endif
00914 
00915 /* Suppress unused-variable warnings by "using" E.  */
00916 #if ! defined lint || defined __GNUC__
00917 # define YYUSE(e) ((void) (e))
00918 #else
00919 # define YYUSE(e) /* empty */
00920 #endif
00921 
00922 /* Identity function, used to suppress warnings about constant conditions.  */
00923 #ifndef lint
00924 # define YYID(n) (n)
00925 #else
00926 #if (defined __STDC__ || defined __C99__FUNC__ \
00927      || defined __cplusplus || defined _MSC_VER)
00928 static int
00929 YYID (int yyi)
00930 #else
00931 static int
00932 YYID (yyi)
00933     int yyi;
00934 #endif
00935 {
00936   return yyi;
00937 }
00938 #endif
00939 
00940 #if ! defined yyoverflow || YYERROR_VERBOSE
00941 
00942 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00943 
00944 # ifdef YYSTACK_USE_ALLOCA
00945 #  if YYSTACK_USE_ALLOCA
00946 #   ifdef __GNUC__
00947 #    define YYSTACK_ALLOC __builtin_alloca
00948 #   elif defined __BUILTIN_VA_ARG_INCR
00949 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00950 #   elif defined _AIX
00951 #    define YYSTACK_ALLOC __alloca
00952 #   elif defined _MSC_VER
00953 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00954 #    define alloca _alloca
00955 #   else
00956 #    define YYSTACK_ALLOC alloca
00957 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00958      || defined __cplusplus || defined _MSC_VER)
00959 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00960 #     ifndef EXIT_SUCCESS
00961 #      define EXIT_SUCCESS 0
00962 #     endif
00963 #    endif
00964 #   endif
00965 #  endif
00966 # endif
00967 
00968 # ifdef YYSTACK_ALLOC
00969    /* Pacify GCC's `empty if-body' warning.  */
00970 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00971 #  ifndef YYSTACK_ALLOC_MAXIMUM
00972     /* The OS might guarantee only one guard page at the bottom of the stack,
00973        and a page size can be as small as 4096 bytes.  So we cannot safely
00974        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00975        to allow for a few compiler-allocated temporary stack slots.  */
00976 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00977 #  endif
00978 # else
00979 #  define YYSTACK_ALLOC YYMALLOC
00980 #  define YYSTACK_FREE YYFREE
00981 #  ifndef YYSTACK_ALLOC_MAXIMUM
00982 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00983 #  endif
00984 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
00985        && ! ((defined YYMALLOC || defined malloc) \
00986              && (defined YYFREE || defined free)))
00987 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00988 #   ifndef EXIT_SUCCESS
00989 #    define EXIT_SUCCESS 0
00990 #   endif
00991 #  endif
00992 #  ifndef YYMALLOC
00993 #   define YYMALLOC malloc
00994 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00995      || defined __cplusplus || defined _MSC_VER)
00996 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00997 #   endif
00998 #  endif
00999 #  ifndef YYFREE
01000 #   define YYFREE free
01001 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
01002      || defined __cplusplus || defined _MSC_VER)
01003 void free (void *); /* INFRINGES ON USER NAME SPACE */
01004 #   endif
01005 #  endif
01006 # endif
01007 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01008 
01009 
01010 #if (! defined yyoverflow \
01011      && (! defined __cplusplus \
01012          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01013 
01014 /* A type that is properly aligned for any stack member.  */
01015 union yyalloc
01016 {
01017   yytype_int16 yyss_alloc;
01018   YYSTYPE yyvs_alloc;
01019 };
01020 
01021 /* The size of the maximum gap between one aligned stack and the next.  */
01022 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01023 
01024 /* The size of an array large to enough to hold all stacks, each with
01025    N elements.  */
01026 # define YYSTACK_BYTES(N) \
01027      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01028       + YYSTACK_GAP_MAXIMUM)
01029 
01030 # define YYCOPY_NEEDED 1
01031 
01032 /* Relocate STACK from its old location to the new one.  The
01033    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01034    elements in the stack, and YYPTR gives the new location of the
01035    stack.  Advance YYPTR to a properly aligned location for the next
01036    stack.  */
01037 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
01038     do                                                                  \
01039       {                                                                 \
01040         YYSIZE_T yynewbytes;                                            \
01041         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
01042         Stack = &yyptr->Stack_alloc;                                    \
01043         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01044         yyptr += yynewbytes / sizeof (*yyptr);                          \
01045       }                                                                 \
01046     while (YYID (0))
01047 
01048 #endif
01049 
01050 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
01051 /* Copy COUNT objects from FROM to TO.  The source and destination do
01052    not overlap.  */
01053 # ifndef YYCOPY
01054 #  if defined __GNUC__ && 1 < __GNUC__
01055 #   define YYCOPY(To, From, Count) \
01056       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01057 #  else
01058 #   define YYCOPY(To, From, Count)              \
01059       do                                        \
01060         {                                       \
01061           YYSIZE_T yyi;                         \
01062           for (yyi = 0; yyi < (Count); yyi++)   \
01063             (To)[yyi] = (From)[yyi];            \
01064         }                                       \
01065       while (YYID (0))
01066 #  endif
01067 # endif
01068 #endif /* !YYCOPY_NEEDED */
01069 
01070 /* YYFINAL -- State number of the termination state.  */
01071 #define YYFINAL  3
01072 /* YYLAST -- Last index in YYTABLE.  */
01073 #define YYLAST   10410
01074 
01075 /* YYNTOKENS -- Number of terminals.  */
01076 #define YYNTOKENS  148
01077 /* YYNNTS -- Number of nonterminals.  */
01078 #define YYNNTS  172
01079 /* YYNRULES -- Number of rules.  */
01080 #define YYNRULES  565
01081 /* YYNRULES -- Number of states.  */
01082 #define YYNSTATES  975
01083 
01084 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01085 #define YYUNDEFTOK  2
01086 #define YYMAXUTOK   375
01087 
01088 #define YYTRANSLATE(YYX)                                                \
01089   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01090 
01091 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01092 static const yytype_uint8 yytranslate[] =
01093 {
01094        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01095      147,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01096        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01097        2,     2,   146,   123,     2,     2,     2,   121,   116,     2,
01098      142,   143,   119,   117,   140,   118,   139,   120,     2,     2,
01099        2,     2,     2,     2,     2,     2,     2,     2,   111,   145,
01100      113,   109,   112,   110,     2,     2,     2,     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,   138,     2,   144,   115,     2,   141,     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,   136,   114,   137,   124,     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,     2,     2,     2,     2,
01117        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01118        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01119        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01120        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01121       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01122       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01123       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01124       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01125       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01126       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
01127       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
01128       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
01129       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
01130      105,   106,   107,   108,   122,   125,   126,   127,   128,   129,
01131      130,   131,   132,   133,   134,   135
01132 };
01133 
01134 #if YYDEBUG
01135 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01136    YYRHS.  */
01137 static const yytype_uint16 yyprhs[] =
01138 {
01139        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01140       23,    24,    30,    35,    38,    40,    42,    46,    49,    50,
01141       55,    59,    63,    67,    70,    74,    78,    82,    86,    90,
01142       95,    99,   103,   107,   114,   120,   126,   132,   138,   142,
01143      146,   150,   154,   156,   158,   162,   166,   170,   173,   175,
01144      177,   179,   181,   183,   188,   193,   194,   200,   203,   207,
01145      212,   218,   223,   229,   232,   235,   238,   241,   244,   246,
01146      250,   252,   256,   258,   261,   265,   271,   274,   279,   282,
01147      287,   289,   293,   295,   299,   302,   306,   308,   312,   314,
01148      319,   323,   327,   331,   335,   338,   340,   342,   347,   351,
01149      355,   359,   363,   366,   368,   370,   372,   375,   377,   381,
01150      383,   385,   387,   389,   391,   393,   395,   397,   399,   401,
01151      402,   407,   409,   411,   413,   415,   417,   419,   421,   423,
01152      425,   427,   429,   431,   433,   435,   437,   439,   441,   443,
01153      445,   447,   449,   451,   453,   455,   457,   459,   461,   463,
01154      465,   467,   469,   471,   473,   475,   477,   479,   481,   483,
01155      485,   487,   489,   491,   493,   495,   497,   499,   501,   503,
01156      505,   507,   509,   511,   513,   515,   517,   519,   521,   523,
01157      525,   527,   529,   531,   533,   535,   537,   539,   541,   543,
01158      545,   547,   551,   557,   561,   567,   574,   580,   586,   592,
01159      598,   603,   607,   611,   615,   619,   623,   627,   631,   635,
01160      639,   644,   649,   652,   655,   659,   663,   667,   671,   675,
01161      679,   683,   687,   691,   695,   699,   703,   707,   710,   713,
01162      717,   721,   725,   729,   730,   735,   742,   744,   746,   748,
01163      751,   756,   759,   763,   765,   767,   769,   771,   773,   776,
01164      779,   784,   786,   787,   790,   793,   796,   798,   800,   802,
01165      805,   809,   814,   818,   823,   826,   828,   830,   832,   834,
01166      836,   838,   840,   842,   844,   845,   850,   851,   856,   860,
01167      864,   867,   871,   875,   877,   882,   886,   888,   889,   896,
01168      901,   905,   908,   910,   913,   916,   923,   930,   931,   932,
01169      940,   941,   942,   950,   956,   961,   962,   963,   973,   974,
01170      981,   982,   983,   992,   993,   999,  1000,  1007,  1008,  1009,
01171     1019,  1021,  1023,  1025,  1027,  1029,  1031,  1033,  1035,  1037,
01172     1039,  1041,  1043,  1045,  1047,  1049,  1051,  1053,  1055,  1058,
01173     1060,  1062,  1064,  1070,  1072,  1075,  1077,  1079,  1081,  1085,
01174     1087,  1091,  1093,  1098,  1105,  1109,  1115,  1118,  1123,  1125,
01175     1129,  1136,  1145,  1150,  1157,  1162,  1165,  1172,  1175,  1180,
01176     1187,  1190,  1195,  1198,  1203,  1205,  1207,  1209,  1213,  1215,
01177     1220,  1222,  1225,  1227,  1231,  1233,  1235,  1236,  1237,  1242,
01178     1247,  1249,  1253,  1257,  1258,  1264,  1267,  1272,  1277,  1280,
01179     1285,  1290,  1294,  1298,  1302,  1305,  1307,  1312,  1313,  1319,
01180     1320,  1326,  1332,  1334,  1336,  1343,  1345,  1347,  1349,  1351,
01181     1354,  1356,  1359,  1361,  1363,  1365,  1367,  1369,  1371,  1373,
01182     1376,  1380,  1384,  1388,  1392,  1396,  1397,  1401,  1403,  1406,
01183     1410,  1414,  1415,  1419,  1420,  1423,  1424,  1427,  1428,  1431,
01184     1433,  1434,  1438,  1439,  1440,  1446,  1448,  1450,  1452,  1454,
01185     1457,  1459,  1461,  1463,  1465,  1469,  1471,  1473,  1476,  1479,
01186     1481,  1483,  1485,  1487,  1489,  1491,  1493,  1495,  1497,  1499,
01187     1501,  1503,  1505,  1507,  1509,  1511,  1513,  1514,  1519,  1522,
01188     1526,  1529,  1536,  1545,  1550,  1557,  1562,  1569,  1572,  1577,
01189     1584,  1587,  1592,  1595,  1600,  1602,  1603,  1605,  1607,  1609,
01190     1611,  1613,  1615,  1617,  1621,  1623,  1627,  1631,  1635,  1637,
01191     1641,  1643,  1647,  1649,  1651,  1654,  1656,  1658,  1660,  1663,
01192     1666,  1668,  1670,  1671,  1676,  1678,  1681,  1683,  1687,  1691,
01193     1694,  1696,  1698,  1700,  1702,  1704,  1706,  1708,  1710,  1712,
01194     1714,  1716,  1718,  1719,  1721,  1722,  1724,  1727,  1730,  1731,
01195     1733,  1735,  1737,  1739,  1741,  1744
01196 };
01197 
01198 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01199 static const yytype_int16 yyrhs[] =
01200 {
01201      149,     0,    -1,    -1,   150,   151,    -1,   152,   312,    -1,
01202      319,    -1,   153,    -1,   152,   318,   153,    -1,     1,   153,
01203       -1,   158,    -1,    -1,    47,   154,   136,   151,   137,    -1,
01204      156,   255,   230,   258,    -1,   157,   312,    -1,   319,    -1,
01205      158,    -1,   157,   318,   158,    -1,     1,   158,    -1,    -1,
01206       45,   179,   159,   179,    -1,    45,    54,    54,    -1,    45,
01207       54,    64,    -1,    45,    54,    63,    -1,     6,   180,    -1,
01208      158,    40,   161,    -1,   158,    41,   161,    -1,   158,    42,
01209      161,    -1,   158,    43,   161,    -1,   158,    44,   158,    -1,
01210       48,   136,   156,   137,    -1,   174,   109,   162,    -1,   167,
01211      109,   162,    -1,   284,    87,   162,    -1,   215,   138,   190,
01212      315,    87,   162,    -1,   215,   139,    52,    87,   162,    -1,
01213      215,   139,    56,    87,   162,    -1,   215,    85,    56,    87,
01214      162,    -1,   215,    85,    52,    87,   162,    -1,   285,    87,
01215      162,    -1,   174,   109,   197,    -1,   167,   109,   186,    -1,
01216      167,   109,   197,    -1,   160,    -1,   162,    -1,   160,    37,
01217      160,    -1,   160,    38,   160,    -1,    39,   313,   160,    -1,
01218      123,   162,    -1,   184,    -1,   160,    -1,   166,    -1,   163,
01219       -1,   248,    -1,   248,   139,   309,   192,    -1,   248,    85,
01220      309,   192,    -1,    -1,    94,   165,   236,   156,   137,    -1,
01221      308,   192,    -1,   308,   192,   164,    -1,   215,   139,   309,
01222      192,    -1,   215,   139,   309,   192,   164,    -1,   215,    85,
01223      309,   192,    -1,   215,    85,   309,   192,   164,    -1,    32,
01224      192,    -1,    31,   192,    -1,    30,   191,    -1,    21,   191,
01225       -1,    22,   191,    -1,   169,    -1,    89,   168,   314,    -1,
01226      169,    -1,    89,   168,   314,    -1,   171,    -1,   171,   170,
01227       -1,   171,    95,   173,    -1,   171,    95,   173,   140,   172,
01228       -1,   171,    95,    -1,   171,    95,   140,   172,    -1,    95,
01229      173,    -1,    95,   173,   140,   172,    -1,    95,    -1,    95,
01230      140,   172,    -1,   173,    -1,    89,   168,   314,    -1,   170,
01231      140,    -1,   171,   170,   140,    -1,   170,    -1,   172,   140,
01232      170,    -1,   282,    -1,   215,   138,   190,   315,    -1,   215,
01233      139,    52,    -1,   215,    85,    52,    -1,   215,   139,    56,
01234       -1,   215,    85,    56,    -1,    86,    56,    -1,   285,    -1,
01235      282,    -1,   215,   138,   190,   315,    -1,   215,   139,    52,
01236       -1,   215,    85,    52,    -1,   215,   139,    56,    -1,   215,
01237       85,    56,    -1,    86,    56,    -1,   285,    -1,    52,    -1,
01238       56,    -1,    86,   175,    -1,   175,    -1,   215,    85,   175,
01239       -1,    52,    -1,    56,    -1,    53,    -1,   182,    -1,   183,
01240       -1,   177,    -1,   278,    -1,   178,    -1,   280,    -1,   179,
01241       -1,    -1,   180,   140,   181,   179,    -1,   114,    -1,   115,
01242       -1,   116,    -1,    69,    -1,    70,    -1,    71,    -1,    77,
01243       -1,    78,    -1,   112,    -1,    73,    -1,   113,    -1,    74,
01244       -1,    72,    -1,    83,    -1,    84,    -1,   117,    -1,   118,
01245       -1,   119,    -1,    95,    -1,   120,    -1,   121,    -1,    68,
01246       -1,   123,    -1,   124,    -1,    66,    -1,    67,    -1,    81,
01247       -1,    82,    -1,   141,    -1,    49,    -1,    50,    -1,    51,
01248       -1,    47,    -1,    48,    -1,    45,    -1,    37,    -1,     7,
01249       -1,    21,    -1,    16,    -1,     3,    -1,     5,    -1,    46,
01250       -1,    26,    -1,    15,    -1,    14,    -1,    10,    -1,     9,
01251       -1,    36,    -1,    20,    -1,    25,    -1,     4,    -1,    22,
01252       -1,    34,    -1,    39,    -1,    38,    -1,    23,    -1,     8,
01253       -1,    24,    -1,    30,    -1,    33,    -1,    32,    -1,    13,
01254       -1,    35,    -1,     6,    -1,    17,    -1,    31,    -1,    11,
01255       -1,    12,    -1,    18,    -1,    19,    -1,   174,   109,   184,
01256       -1,   174,   109,   184,    44,   184,    -1,   284,    87,   184,
01257       -1,   284,    87,   184,    44,   184,    -1,   215,   138,   190,
01258      315,    87,   184,    -1,   215,   139,    52,    87,   184,    -1,
01259      215,   139,    56,    87,   184,    -1,   215,    85,    52,    87,
01260      184,    -1,   215,    85,    56,    87,   184,    -1,    86,    56,
01261       87,   184,    -1,   285,    87,   184,    -1,   184,    79,   184,
01262       -1,   184,    80,   184,    -1,   184,   117,   184,    -1,   184,
01263      118,   184,    -1,   184,   119,   184,    -1,   184,   120,   184,
01264       -1,   184,   121,   184,    -1,   184,    68,   184,    -1,   122,
01265       59,    68,   184,    -1,   122,    60,    68,   184,    -1,    66,
01266      184,    -1,    67,   184,    -1,   184,   114,   184,    -1,   184,
01267      115,   184,    -1,   184,   116,   184,    -1,   184,    69,   184,
01268       -1,   184,   112,   184,    -1,   184,    73,   184,    -1,   184,
01269      113,   184,    -1,   184,    74,   184,    -1,   184,    70,   184,
01270       -1,   184,    71,   184,    -1,   184,    72,   184,    -1,   184,
01271       77,   184,    -1,   184,    78,   184,    -1,   123,   184,    -1,
01272      124,   184,    -1,   184,    83,   184,    -1,   184,    84,   184,
01273       -1,   184,    75,   184,    -1,   184,    76,   184,    -1,    -1,
01274       46,   313,   185,   184,    -1,   184,   110,   184,   313,   111,
01275      184,    -1,   198,    -1,   184,    -1,   319,    -1,   196,   316,
01276       -1,   196,   140,   306,   316,    -1,   306,   316,    -1,   142,
01277      190,   314,    -1,   319,    -1,   188,    -1,   319,    -1,   191,
01278       -1,   166,    -1,   196,   195,    -1,   306,   195,    -1,   196,
01279      140,   306,   195,    -1,   194,    -1,    -1,   193,   191,    -1,
01280       96,   186,    -1,   140,   194,    -1,   140,    -1,   319,    -1,
01281      186,    -1,    95,   186,    -1,   196,   140,   186,    -1,   196,
01282      140,    95,   186,    -1,   196,   140,   186,    -1,   196,   140,
01283       95,   186,    -1,    95,   186,    -1,   259,    -1,   260,    -1,
01284      263,    -1,   264,    -1,   265,    -1,   268,    -1,   283,    -1,
01285      285,    -1,    53,    -1,    -1,   216,   199,   155,   226,    -1,
01286       -1,    90,   160,   200,   314,    -1,    89,   156,   143,    -1,
01287      215,    85,    56,    -1,    86,    56,    -1,    92,   187,   144,
01288       -1,    93,   305,   137,    -1,    30,    -1,    31,   142,   191,
01289      314,    -1,    31,   142,   314,    -1,    31,    -1,    -1,    46,
01290      313,   142,   201,   160,   314,    -1,    39,   142,   160,   314,
01291       -1,    39,   142,   314,    -1,   308,   250,    -1,   249,    -1,
01292      249,   250,    -1,    97,   241,    -1,   217,   161,   227,   156,
01293      229,   226,    -1,   218,   161,   227,   156,   230,   226,    -1,
01294       -1,    -1,   219,   202,   161,   228,   203,   156,   226,    -1,
01295       -1,    -1,   220,   204,   161,   228,   205,   156,   226,    -1,
01296      221,   161,   312,   253,   226,    -1,   221,   312,   253,   226,
01297       -1,    -1,    -1,   222,   231,    25,   206,   161,   228,   207,
01298      156,   226,    -1,    -1,   223,   176,   286,   208,   155,   226,
01299       -1,    -1,    -1,   223,    83,   160,   209,   317,   210,   155,
01300      226,    -1,    -1,   224,   176,   211,   155,   226,    -1,    -1,
01301      225,   177,   212,   288,   155,   226,    -1,    -1,    -1,   225,
01302      303,   311,   213,   177,   214,   288,   155,   226,    -1,    21,
01303       -1,    22,    -1,    23,    -1,    24,    -1,   198,    -1,     7,
01304       -1,    11,    -1,    12,    -1,    18,    -1,    19,    -1,    16,
01305       -1,    20,    -1,     3,    -1,     4,    -1,     5,    -1,    10,
01306       -1,   317,    -1,    13,    -1,   317,    13,    -1,   317,    -1,
01307       27,    -1,   230,    -1,    14,   161,   227,   156,   229,    -1,
01308      319,    -1,    15,   156,    -1,   174,    -1,   167,    -1,   291,
01309       -1,    89,   234,   314,    -1,   232,    -1,   233,   140,   232,
01310       -1,   233,    -1,   233,   140,    95,   291,    -1,   233,   140,
01311       95,   291,   140,   233,    -1,   233,   140,    95,    -1,   233,
01312      140,    95,   140,   233,    -1,    95,   291,    -1,    95,   291,
01313      140,   233,    -1,    95,    -1,    95,   140,   233,    -1,   293,
01314      140,   296,   140,   299,   302,    -1,   293,   140,   296,   140,
01315      299,   140,   293,   302,    -1,   293,   140,   296,   302,    -1,
01316      293,   140,   296,   140,   293,   302,    -1,   293,   140,   299,
01317      302,    -1,   293,   140,    -1,   293,   140,   299,   140,   293,
01318      302,    -1,   293,   302,    -1,   296,   140,   299,   302,    -1,
01319      296,   140,   299,   140,   293,   302,    -1,   296,   302,    -1,
01320      296,   140,   293,   302,    -1,   299,   302,    -1,   299,   140,
01321      293,   302,    -1,   301,    -1,   319,    -1,   237,    -1,   114,
01322      238,   114,    -1,    76,    -1,   114,   235,   238,   114,    -1,
01323      319,    -1,   145,   239,    -1,   240,    -1,   239,   140,   240,
01324       -1,    52,    -1,   290,    -1,    -1,    -1,   242,   243,   244,
01325      245,    -1,   142,   289,   238,   314,    -1,   289,    -1,   107,
01326      156,   137,    -1,    29,   156,    10,    -1,    -1,    28,   247,
01327      236,   156,    10,    -1,   166,   246,    -1,   248,   139,   309,
01328      189,    -1,   248,    85,   309,   189,    -1,   308,   188,    -1,
01329      215,   139,   309,   189,    -1,   215,    85,   309,   188,    -1,
01330      215,    85,   310,    -1,   215,   139,   188,    -1,   215,    85,
01331      188,    -1,    32,   188,    -1,    32,    -1,   215,   138,   190,
01332      315,    -1,    -1,   136,   251,   236,   156,   137,    -1,    -1,
01333       26,   252,   236,   156,    10,    -1,    17,   196,   227,   156,
01334      254,    -1,   230,    -1,   253,    -1,     8,   256,   257,   227,
01335      156,   255,    -1,   319,    -1,   186,    -1,   197,    -1,   319,
01336       -1,    88,   174,    -1,   319,    -1,     9,   156,    -1,   319,
01337       -1,   281,    -1,   278,    -1,   280,    -1,   261,    -1,    62,
01338       -1,   262,    -1,   261,   262,    -1,    99,   270,   106,    -1,
01339      100,   271,   106,    -1,   101,   272,    65,    -1,   102,   146,
01340      106,    -1,   102,   266,   106,    -1,    -1,   266,   267,   146,
01341       -1,   273,    -1,   267,   273,    -1,   103,   146,   106,    -1,
01342      103,   269,   106,    -1,    -1,   269,    61,   146,    -1,    -1,
01343      270,   273,    -1,    -1,   271,   273,    -1,    -1,   272,   273,
01344       -1,    61,    -1,    -1,   105,   274,   277,    -1,    -1,    -1,
01345      104,   275,   276,   156,   137,    -1,    54,    -1,    55,    -1,
01346       57,    -1,   285,    -1,    98,   279,    -1,   177,    -1,    55,
01347       -1,    54,    -1,    57,    -1,    98,   271,   106,    -1,    59,
01348       -1,    60,    -1,   122,    59,    -1,   122,    60,    -1,    52,
01349       -1,    55,    -1,    54,    -1,    56,    -1,    57,    -1,    34,
01350       -1,    33,    -1,    35,    -1,    36,    -1,    50,    -1,    49,
01351       -1,    51,    -1,   282,    -1,   282,    -1,    63,    -1,    64,
01352       -1,   317,    -1,    -1,   113,   287,   161,   317,    -1,     1,
01353      317,    -1,   142,   289,   314,    -1,   289,   317,    -1,   293,
01354      140,   297,   140,   299,   302,    -1,   293,   140,   297,   140,
01355      299,   140,   293,   302,    -1,   293,   140,   297,   302,    -1,
01356      293,   140,   297,   140,   293,   302,    -1,   293,   140,   299,
01357      302,    -1,   293,   140,   299,   140,   293,   302,    -1,   293,
01358      302,    -1,   297,   140,   299,   302,    -1,   297,   140,   299,
01359      140,   293,   302,    -1,   297,   302,    -1,   297,   140,   293,
01360      302,    -1,   299,   302,    -1,   299,   140,   293,   302,    -1,
01361      301,    -1,    -1,    56,    -1,    55,    -1,    54,    -1,    57,
01362       -1,   290,    -1,    52,    -1,   291,    -1,    89,   234,   314,
01363       -1,   292,    -1,   293,   140,   292,    -1,    52,   109,   186,
01364       -1,    52,   109,   215,    -1,   295,    -1,   296,   140,   295,
01365       -1,   294,    -1,   297,   140,   294,    -1,   119,    -1,    95,
01366       -1,   298,    52,    -1,   298,    -1,   116,    -1,    96,    -1,
01367      300,    52,    -1,   140,   301,    -1,   319,    -1,   283,    -1,
01368       -1,   142,   304,   160,   314,    -1,   319,    -1,   306,   316,
01369       -1,   307,    -1,   306,   140,   307,    -1,   186,    88,   186,
01370       -1,    58,   186,    -1,    52,    -1,    56,    -1,    53,    -1,
01371       52,    -1,    56,    -1,    53,    -1,   182,    -1,    52,    -1,
01372       53,    -1,   182,    -1,   139,    -1,    85,    -1,    -1,   318,
01373       -1,    -1,   147,    -1,   313,   143,    -1,   313,   144,    -1,
01374       -1,   147,    -1,   140,    -1,   145,    -1,   147,    -1,   317,
01375       -1,   318,   145,    -1,    -1
01376 };
01377 
01378 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01379 static const yytype_uint16 yyrline[] =
01380 {
01381        0,   786,   786,   786,   817,   828,   837,   845,   853,   859,
01382      861,   860,   884,   917,   928,   937,   945,   953,   959,   959,
01383      967,   975,   986,   996,  1004,  1013,  1022,  1035,  1048,  1057,
01384     1069,  1078,  1088,  1117,  1138,  1155,  1172,  1183,  1200,  1210,
01385     1219,  1228,  1237,  1240,  1241,  1249,  1257,  1265,  1273,  1276,
01386     1288,  1289,  1292,  1293,  1302,  1314,  1313,  1335,  1344,  1356,
01387     1365,  1377,  1386,  1398,  1407,  1416,  1424,  1432,  1442,  1443,
01388     1453,  1454,  1464,  1472,  1480,  1488,  1497,  1505,  1514,  1522,
01389     1531,  1539,  1550,  1551,  1561,  1569,  1579,  1587,  1597,  1601,
01390     1609,  1617,  1625,  1633,  1645,  1655,  1667,  1676,  1684,  1692,
01391     1700,  1708,  1721,  1734,  1745,  1753,  1756,  1764,  1772,  1782,
01392     1783,  1784,  1785,  1790,  1801,  1802,  1805,  1813,  1816,  1824,
01393     1824,  1834,  1835,  1836,  1837,  1838,  1839,  1840,  1841,  1842,
01394     1843,  1844,  1845,  1846,  1847,  1848,  1849,  1850,  1851,  1852,
01395     1853,  1854,  1855,  1856,  1857,  1858,  1859,  1860,  1861,  1862,
01396     1865,  1865,  1865,  1866,  1866,  1867,  1867,  1867,  1868,  1868,
01397     1868,  1868,  1869,  1869,  1869,  1869,  1870,  1870,  1870,  1871,
01398     1871,  1871,  1871,  1872,  1872,  1872,  1872,  1873,  1873,  1873,
01399     1873,  1874,  1874,  1874,  1874,  1875,  1875,  1875,  1875,  1876,
01400     1876,  1879,  1888,  1898,  1927,  1958,  1984,  2001,  2018,  2035,
01401     2046,  2057,  2068,  2082,  2096,  2104,  2112,  2120,  2128,  2136,
01402     2144,  2153,  2162,  2170,  2178,  2186,  2194,  2202,  2210,  2218,
01403     2226,  2234,  2242,  2250,  2258,  2266,  2277,  2285,  2293,  2301,
01404     2309,  2317,  2325,  2333,  2333,  2343,  2353,  2359,  2371,  2372,
01405     2376,  2384,  2394,  2404,  2405,  2408,  2409,  2412,  2421,  2429,
01406     2439,  2448,  2457,  2457,  2469,  2479,  2483,  2487,  2493,  2501,
01407     2509,  2523,  2539,  2553,  2568,  2578,  2579,  2580,  2581,  2582,
01408     2583,  2584,  2585,  2586,  2595,  2594,  2619,  2619,  2628,  2636,
01409     2644,  2652,  2665,  2673,  2681,  2689,  2697,  2705,  2705,  2715,
01410     2723,  2731,  2742,  2743,  2754,  2758,  2770,  2782,  2782,  2782,
01411     2793,  2793,  2793,  2804,  2815,  2824,  2826,  2823,  2890,  2889,
01412     2911,  2916,  2910,  2935,  2934,  2956,  2955,  2978,  2979,  2978,
01413     2999,  3007,  3015,  3023,  3033,  3045,  3051,  3057,  3063,  3069,
01414     3075,  3081,  3087,  3093,  3099,  3109,  3115,  3120,  3121,  3128,
01415     3133,  3136,  3137,  3150,  3151,  3161,  3162,  3165,  3173,  3183,
01416     3191,  3201,  3209,  3218,  3227,  3235,  3243,  3252,  3264,  3272,
01417     3282,  3290,  3298,  3306,  3314,  3322,  3331,  3339,  3347,  3355,
01418     3363,  3371,  3379,  3387,  3395,  3405,  3406,  3412,  3421,  3430,
01419     3441,  3442,  3452,  3459,  3468,  3476,  3482,  3485,  3482,  3503,
01420     3511,  3521,  3525,  3532,  3531,  3552,  3568,  3577,  3588,  3597,
01421     3607,  3617,  3625,  3636,  3647,  3655,  3663,  3678,  3677,  3697,
01422     3696,  3717,  3729,  3730,  3733,  3752,  3755,  3763,  3771,  3774,
01423     3778,  3781,  3789,  3792,  3793,  3801,  3804,  3821,  3822,  3823,
01424     3833,  3843,  3870,  3935,  3944,  3955,  3962,  3972,  3980,  3990,
01425     3999,  4010,  4017,  4028,  4035,  4046,  4053,  4064,  4071,  4100,
01426     4102,  4101,  4118,  4124,  4117,  4143,  4151,  4159,  4167,  4170,
01427     4181,  4182,  4183,  4184,  4187,  4217,  4218,  4219,  4227,  4237,
01428     4238,  4239,  4240,  4241,  4242,  4243,  4244,  4245,  4246,  4247,
01429     4248,  4251,  4261,  4271,  4272,  4275,  4284,  4283,  4291,  4303,
01430     4313,  4319,  4327,  4335,  4343,  4351,  4359,  4367,  4375,  4383,
01431     4391,  4399,  4407,  4415,  4423,  4432,  4441,  4450,  4459,  4468,
01432     4479,  4480,  4487,  4496,  4515,  4522,  4535,  4547,  4559,  4567,
01433     4583,  4591,  4607,  4608,  4611,  4624,  4635,  4636,  4639,  4656,
01434     4660,  4670,  4680,  4680,  4709,  4710,  4720,  4727,  4737,  4745,
01435     4755,  4756,  4757,  4760,  4761,  4762,  4763,  4766,  4767,  4768,
01436     4771,  4776,  4783,  4784,  4787,  4788,  4791,  4794,  4797,  4798,
01437     4799,  4802,  4803,  4806,  4807,  4811
01438 };
01439 #endif
01440 
01441 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
01442 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01443    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01444 static const char *const yytname[] =
01445 {
01446   "$end", "error", "$undefined", "keyword_class", "keyword_module",
01447   "keyword_def", "keyword_undef", "keyword_begin", "keyword_rescue",
01448   "keyword_ensure", "keyword_end", "keyword_if", "keyword_unless",
01449   "keyword_then", "keyword_elsif", "keyword_else", "keyword_case",
01450   "keyword_when", "keyword_while", "keyword_until", "keyword_for",
01451   "keyword_break", "keyword_next", "keyword_redo", "keyword_retry",
01452   "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block",
01453   "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super",
01454   "keyword_self", "keyword_nil", "keyword_true", "keyword_false",
01455   "keyword_and", "keyword_or", "keyword_not", "modifier_if",
01456   "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue",
01457   "keyword_alias", "keyword_defined", "keyword_BEGIN", "keyword_END",
01458   "keyword__LINE__", "keyword__FILE__", "keyword__ENCODING__",
01459   "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", "tCONSTANT", "tCVAR", "tLABEL",
01460   "tINTEGER", "tFLOAT", "tSTRING_CONTENT", "tCHAR", "tNTH_REF",
01461   "tBACK_REF", "tREGEXP_END", "tUPLUS", "tUMINUS", "tPOW", "tCMP", "tEQ",
01462   "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP", "tMATCH", "tNMATCH",
01463   "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT", "tRSHFT", "tCOLON2",
01464   "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN", "tLPAREN_ARG", "tRPAREN",
01465   "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR", "tAMPER", "tLAMBDA",
01466   "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG", "tWORDS_BEG",
01467   "tQWORDS_BEG", "tSTRING_DBEG", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
01468   "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
01469   "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "idNULL",
01470   "idRespond_to", "idIFUNC", "idCFUNC", "id_core_set_method_alias",
01471   "id_core_set_variable_alias", "id_core_undef_method",
01472   "id_core_define_method", "id_core_define_singleton_method",
01473   "id_core_set_postexe", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','",
01474   "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program",
01475   "$@1", "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt",
01476   "compstmt", "stmts", "stmt", "$@3", "expr", "expr_value", "command_call",
01477   "block_command", "cmd_brace_block", "@4", "command", "mlhs",
01478   "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head", "mlhs_post",
01479   "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", "fitem",
01480   "undef_list", "$@5", "op", "reswords", "arg", "$@6", "arg_value",
01481   "aref_args", "paren_args", "opt_paren_args", "opt_call_args",
01482   "call_args", "command_args", "@7", "block_arg", "opt_block_arg", "args",
01483   "mrhs", "primary", "@8", "$@9", "$@10", "$@11", "$@12", "$@13", "$@14",
01484   "$@15", "$@16", "@17", "@18", "@19", "@20", "@21", "$@22", "$@23",
01485   "primary_value", "k_begin", "k_if", "k_unless", "k_while", "k_until",
01486   "k_case", "k_for", "k_class", "k_module", "k_def", "k_end", "then", "do",
01487   "if_tail", "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs",
01488   "block_param", "opt_block_param", "block_param_def", "opt_bv_decl",
01489   "bv_decls", "bvar", "lambda", "@24", "@25", "f_larglist", "lambda_body",
01490   "do_block", "@26", "block_call", "method_call", "brace_block", "@27",
01491   "@28", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
01492   "opt_ensure", "literal", "strings", "string", "string1", "xstring",
01493   "regexp", "words", "word_list", "word", "qwords", "qword_list",
01494   "string_contents", "xstring_contents", "regexp_contents",
01495   "string_content", "@29", "@30", "@31", "string_dvar", "symbol", "sym",
01496   "dsym", "numeric", "variable", "var_ref", "var_lhs", "backref",
01497   "superclass", "$@32", "f_arglist", "f_args", "f_bad_arg", "f_norm_arg",
01498   "f_arg_item", "f_arg", "f_opt", "f_block_opt", "f_block_optarg",
01499   "f_optarg", "restarg_mark", "f_rest_arg", "blkarg_mark", "f_block_arg",
01500   "opt_f_block_arg", "singleton", "$@33", "assoc_list", "assocs", "assoc",
01501   "operation", "operation2", "operation3", "dot_or_colon", "opt_terms",
01502   "opt_nl", "rparen", "rbracket", "trailer", "term", "terms", "none", 0
01503 };
01504 #endif
01505 
01506 # ifdef YYPRINT
01507 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01508    token YYLEX-NUM.  */
01509 static const yytype_uint16 yytoknum[] =
01510 {
01511        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01512      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01513      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01514      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01515      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01516      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01517      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
01518      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
01519      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
01520      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
01521      355,   356,   357,   358,   359,   360,   361,   362,   363,    61,
01522       63,    58,    62,    60,   124,    94,    38,    43,    45,    42,
01523       47,    37,   364,    33,   126,   365,   366,   367,   368,   369,
01524      370,   371,   372,   373,   374,   375,   123,   125,    91,    46,
01525       44,    96,    40,    41,    93,    59,    32,    10
01526 };
01527 # endif
01528 
01529 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01530 static const yytype_uint16 yyr1[] =
01531 {
01532        0,   148,   150,   149,   151,   152,   152,   152,   152,   153,
01533      154,   153,   155,   156,   157,   157,   157,   157,   159,   158,
01534      158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
01535      158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
01536      158,   158,   158,   160,   160,   160,   160,   160,   160,   161,
01537      162,   162,   163,   163,   163,   165,   164,   166,   166,   166,
01538      166,   166,   166,   166,   166,   166,   166,   166,   167,   167,
01539      168,   168,   169,   169,   169,   169,   169,   169,   169,   169,
01540      169,   169,   170,   170,   171,   171,   172,   172,   173,   173,
01541      173,   173,   173,   173,   173,   173,   174,   174,   174,   174,
01542      174,   174,   174,   174,   175,   175,   176,   176,   176,   177,
01543      177,   177,   177,   177,   178,   178,   179,   179,   180,   181,
01544      180,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01545      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01546      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01547      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01548      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01549      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01550      183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
01551      183,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01552      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01553      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01554      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
01555      184,   184,   184,   185,   184,   184,   184,   186,   187,   187,
01556      187,   187,   188,   189,   189,   190,   190,   191,   191,   191,
01557      191,   191,   193,   192,   194,   195,   195,   195,   196,   196,
01558      196,   196,   197,   197,   197,   198,   198,   198,   198,   198,
01559      198,   198,   198,   198,   199,   198,   200,   198,   198,   198,
01560      198,   198,   198,   198,   198,   198,   198,   201,   198,   198,
01561      198,   198,   198,   198,   198,   198,   198,   202,   203,   198,
01562      204,   205,   198,   198,   198,   206,   207,   198,   208,   198,
01563      209,   210,   198,   211,   198,   212,   198,   213,   214,   198,
01564      198,   198,   198,   198,   215,   216,   217,   218,   219,   220,
01565      221,   222,   223,   224,   225,   226,   227,   227,   227,   228,
01566      228,   229,   229,   230,   230,   231,   231,   232,   232,   233,
01567      233,   234,   234,   234,   234,   234,   234,   234,   234,   234,
01568      235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
01569      235,   235,   235,   235,   235,   236,   236,   237,   237,   237,
01570      238,   238,   239,   239,   240,   240,   242,   243,   241,   244,
01571      244,   245,   245,   247,   246,   248,   248,   248,   249,   249,
01572      249,   249,   249,   249,   249,   249,   249,   251,   250,   252,
01573      250,   253,   254,   254,   255,   255,   256,   256,   256,   257,
01574      257,   258,   258,   259,   259,   259,   260,   261,   261,   261,
01575      262,   263,   264,   265,   265,   266,   266,   267,   267,   268,
01576      268,   269,   269,   270,   270,   271,   271,   272,   272,   273,
01577      274,   273,   275,   276,   273,   277,   277,   277,   277,   278,
01578      279,   279,   279,   279,   280,   281,   281,   281,   281,   282,
01579      282,   282,   282,   282,   282,   282,   282,   282,   282,   282,
01580      282,   283,   284,   285,   285,   286,   287,   286,   286,   288,
01581      288,   289,   289,   289,   289,   289,   289,   289,   289,   289,
01582      289,   289,   289,   289,   289,   289,   290,   290,   290,   290,
01583      291,   291,   292,   292,   293,   293,   294,   295,   296,   296,
01584      297,   297,   298,   298,   299,   299,   300,   300,   301,   302,
01585      302,   303,   304,   303,   305,   305,   306,   306,   307,   307,
01586      308,   308,   308,   309,   309,   309,   309,   310,   310,   310,
01587      311,   311,   312,   312,   313,   313,   314,   315,   316,   316,
01588      316,   317,   317,   318,   318,   319
01589 };
01590 
01591 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01592 static const yytype_uint8 yyr2[] =
01593 {
01594        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01595        0,     5,     4,     2,     1,     1,     3,     2,     0,     4,
01596        3,     3,     3,     2,     3,     3,     3,     3,     3,     4,
01597        3,     3,     3,     6,     5,     5,     5,     5,     3,     3,
01598        3,     3,     1,     1,     3,     3,     3,     2,     1,     1,
01599        1,     1,     1,     4,     4,     0,     5,     2,     3,     4,
01600        5,     4,     5,     2,     2,     2,     2,     2,     1,     3,
01601        1,     3,     1,     2,     3,     5,     2,     4,     2,     4,
01602        1,     3,     1,     3,     2,     3,     1,     3,     1,     4,
01603        3,     3,     3,     3,     2,     1,     1,     4,     3,     3,
01604        3,     3,     2,     1,     1,     1,     2,     1,     3,     1,
01605        1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
01606        4,     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,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01611        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01612        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01613        1,     3,     5,     3,     5,     6,     5,     5,     5,     5,
01614        4,     3,     3,     3,     3,     3,     3,     3,     3,     3,
01615        4,     4,     2,     2,     3,     3,     3,     3,     3,     3,
01616        3,     3,     3,     3,     3,     3,     3,     2,     2,     3,
01617        3,     3,     3,     0,     4,     6,     1,     1,     1,     2,
01618        4,     2,     3,     1,     1,     1,     1,     1,     2,     2,
01619        4,     1,     0,     2,     2,     2,     1,     1,     1,     2,
01620        3,     4,     3,     4,     2,     1,     1,     1,     1,     1,
01621        1,     1,     1,     1,     0,     4,     0,     4,     3,     3,
01622        2,     3,     3,     1,     4,     3,     1,     0,     6,     4,
01623        3,     2,     1,     2,     2,     6,     6,     0,     0,     7,
01624        0,     0,     7,     5,     4,     0,     0,     9,     0,     6,
01625        0,     0,     8,     0,     5,     0,     6,     0,     0,     9,
01626        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01627        1,     1,     1,     1,     1,     1,     1,     1,     2,     1,
01628        1,     1,     5,     1,     2,     1,     1,     1,     3,     1,
01629        3,     1,     4,     6,     3,     5,     2,     4,     1,     3,
01630        6,     8,     4,     6,     4,     2,     6,     2,     4,     6,
01631        2,     4,     2,     4,     1,     1,     1,     3,     1,     4,
01632        1,     2,     1,     3,     1,     1,     0,     0,     4,     4,
01633        1,     3,     3,     0,     5,     2,     4,     4,     2,     4,
01634        4,     3,     3,     3,     2,     1,     4,     0,     5,     0,
01635        5,     5,     1,     1,     6,     1,     1,     1,     1,     2,
01636        1,     2,     1,     1,     1,     1,     1,     1,     1,     2,
01637        3,     3,     3,     3,     3,     0,     3,     1,     2,     3,
01638        3,     0,     3,     0,     2,     0,     2,     0,     2,     1,
01639        0,     3,     0,     0,     5,     1,     1,     1,     1,     2,
01640        1,     1,     1,     1,     3,     1,     1,     2,     2,     1,
01641        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01642        1,     1,     1,     1,     1,     1,     0,     4,     2,     3,
01643        2,     6,     8,     4,     6,     4,     6,     2,     4,     6,
01644        2,     4,     2,     4,     1,     0,     1,     1,     1,     1,
01645        1,     1,     1,     3,     1,     3,     3,     3,     1,     3,
01646        1,     3,     1,     1,     2,     1,     1,     1,     2,     2,
01647        1,     1,     0,     4,     1,     2,     1,     3,     3,     2,
01648        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01649        1,     1,     0,     1,     0,     1,     2,     2,     0,     1,
01650        1,     1,     1,     1,     2,     0
01651 };
01652 
01653 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
01654    Performed when YYTABLE doesn't specify something else to do.  Zero
01655    means the default is an error.  */
01656 static const yytype_uint16 yydefact[] =
01657 {
01658        2,     0,     0,     1,     0,   332,   333,   334,     0,   325,
01659      326,   327,   330,   328,   329,   331,   320,   321,   322,   323,
01660      283,   252,   252,   475,   474,   476,   477,   554,     0,   554,
01661       10,     0,   479,   478,   480,   469,   542,   471,   470,   472,
01662      473,   465,   466,   427,   483,   484,     0,     0,     0,     0,
01663        0,   565,   565,    80,   386,   445,   443,   445,   447,   435,
01664      441,     0,     0,     0,     3,   552,     6,     9,    42,    43,
01665       51,    50,     0,    68,     0,    72,    82,     0,    48,   236,
01666        0,   274,     0,     0,   297,   300,   552,     0,     0,     0,
01667        0,    52,   292,   265,   266,   426,   428,   267,   268,   269,
01668      270,   424,   425,   423,   481,   271,     0,   272,   252,     5,
01669        8,   160,   171,   161,   184,   157,   177,   167,   166,   187,
01670      188,   182,   165,   164,   159,   185,   189,   190,   169,   158,
01671      172,   176,   178,   170,   163,   179,   186,   181,   180,   173,
01672      183,   168,   156,   175,   174,   155,   162,   153,   154,   150,
01673      151,   152,   109,   111,   110,   145,   146,   142,   124,   125,
01674      126,   133,   130,   132,   127,   128,   147,   148,   134,   135,
01675      139,   129,   131,   121,   122,   123,   136,   137,   138,   140,
01676      141,   143,   144,   149,   114,   116,   118,    23,   112,   113,
01677      115,   117,     0,     0,     0,     0,     0,     0,     0,   247,
01678        0,   237,   258,    66,   251,   565,     0,   481,     0,   272,
01679      565,   536,    67,    65,   554,    64,     0,   565,   404,    63,
01680      554,   555,     0,     0,    18,   233,     0,     0,   320,   321,
01681      283,   286,   405,   212,     0,     0,   213,   280,     0,     0,
01682        0,   552,    15,   554,    70,    14,   276,     0,   558,   558,
01683      238,     0,     0,   558,   534,   554,     0,     0,     0,    78,
01684      324,     0,    88,    95,   294,   387,   462,   461,   463,   460,
01685        0,   459,     0,     0,     0,     0,     0,     0,     0,   467,
01686      468,    47,   227,   228,   561,   562,     4,   563,   553,     0,
01687        0,     0,     0,     0,     0,     0,   393,   395,     0,    84,
01688        0,    76,    73,     0,     0,     0,     0,     0,     0,     0,
01689        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01690        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01691        0,   565,     0,     0,    49,     0,     0,     0,     0,   552,
01692        0,   553,     0,   346,   345,     0,     0,   481,   272,   104,
01693      105,     0,     0,   107,     0,     0,   481,   272,   313,   180,
01694      173,   183,   168,   150,   151,   152,   109,   110,   532,   315,
01695      531,     0,     0,     0,   409,   407,   293,   429,     0,     0,
01696      398,    57,   291,   119,   539,   280,   259,   254,     0,     0,
01697      256,   248,   257,     0,   565,     0,     0,     0,   256,   249,
01698      554,     0,   285,   253,   554,   246,   245,   554,   290,    46,
01699       20,    22,    21,     0,   287,     0,     0,     0,     0,     0,
01700        0,    17,   554,   278,    13,   553,    69,   554,   281,   560,
01701      559,   239,   560,   241,   282,   535,     0,    94,   467,   468,
01702       86,    81,     0,     0,   565,     0,   505,   449,   452,   450,
01703      464,   446,   430,   444,   431,   432,   448,   433,   434,     0,
01704      437,   439,     0,   440,     0,     0,   564,     7,    24,    25,
01705       26,    27,    28,    44,    45,   565,     0,    31,    40,     0,
01706       41,   554,     0,    74,    85,    30,   191,   258,    39,   209,
01707      217,   222,   223,   224,   219,   221,   231,   232,   225,   226,
01708      202,   203,   229,   230,   554,   218,   220,   214,   215,   216,
01709      204,   205,   206,   207,   208,   543,   548,   544,   549,   403,
01710      252,   401,   554,   543,   545,   544,   546,   402,   252,     0,
01711      565,   337,     0,   336,     0,     0,     0,     0,     0,     0,
01712      280,     0,   565,     0,   305,   310,   104,   105,   106,     0,
01713      486,   308,   485,     0,   565,     0,     0,     0,   505,   551,
01714      550,   317,   543,   544,   252,   252,   565,   565,    32,   193,
01715       38,   201,    55,    58,     0,   191,   538,     0,   260,   255,
01716      565,   547,   544,   554,   543,   544,   537,   284,   556,   242,
01717      289,    19,     0,   234,     0,    29,     0,   565,   200,    71,
01718       16,   277,   558,     0,    79,    91,    93,   554,   543,   544,
01719      511,   508,   507,   506,   509,     0,   523,   527,   526,   522,
01720      505,     0,   390,   510,   512,   514,   565,   520,   565,   525,
01721      565,     0,   504,   453,     0,   436,   438,   442,   210,   211,
01722      378,   565,     0,   376,   375,   264,     0,    83,    77,     0,
01723        0,     0,     0,     0,   400,    61,     0,   406,     0,     0,
01724      244,   399,    59,   243,   335,   275,   565,   565,   415,   565,
01725      338,   565,   340,   298,   339,   301,     0,     0,   304,   547,
01726      279,   554,   543,   544,     0,     0,   488,     0,     0,   104,
01727      105,   108,   554,     0,   554,   505,     0,     0,     0,   397,
01728       54,   396,    53,     0,     0,     0,   565,   120,   261,   250,
01729        0,     0,   406,     0,     0,   554,    11,   240,    87,    89,
01730        0,   511,     0,   358,   349,   351,   554,   347,   565,     0,
01731        0,   388,     0,   497,   530,     0,   500,   524,     0,   502,
01732      528,     0,   455,   456,   457,   451,   458,   511,     0,   565,
01733        0,   565,   518,   565,   565,   374,   380,     0,     0,   262,
01734       75,   192,     0,    37,   198,    36,   199,    62,   557,     0,
01735       34,   196,    35,   197,    60,   416,   417,   565,   418,     0,
01736      565,   343,     0,     0,   341,     0,     0,     0,   303,     0,
01737        0,   406,     0,   311,     0,     0,   406,   314,   533,   554,
01738        0,   490,   318,     0,     0,   194,     0,     0,   288,   516,
01739      554,     0,   356,     0,   513,   554,     0,     0,   515,   565,
01740      565,   529,   565,   521,   565,   565,     0,     0,   384,   381,
01741      382,   385,     0,   377,   365,   367,     0,   370,     0,   372,
01742      394,   263,   235,    33,   195,     0,     0,   420,   344,     0,
01743       12,   422,     0,   295,   296,     0,     0,   260,   565,   306,
01744        0,   487,   309,   489,   316,   505,   410,   408,     0,   348,
01745      359,     0,   354,   350,   389,   392,   391,     0,   493,     0,
01746      495,     0,   501,     0,   498,   503,   454,     0,   517,     0,
01747      379,   565,   565,   565,   519,   565,   565,     0,   419,     0,
01748       96,   103,     0,   421,     0,   299,   302,   412,   413,   411,
01749        0,     0,     0,    56,     0,   357,     0,   352,   565,   565,
01750      565,   565,   280,     0,   383,     0,   362,     0,   364,   371,
01751        0,   368,   373,   102,     0,   565,     0,   565,   565,     0,
01752      312,     0,   355,     0,   494,     0,   491,   496,   499,   547,
01753      279,   565,   565,   565,   565,   547,   101,   554,   543,   544,
01754      414,   342,   307,   319,   353,   565,   363,     0,   360,   366,
01755      369,   406,   492,   565,   361
01756 };
01757 
01758 /* YYDEFGOTO[NTERM-NUM].  */
01759 static const yytype_int16 yydefgoto[] =
01760 {
01761       -1,     1,     2,    64,    65,    66,   226,   529,   530,   241,
01762      242,   413,    68,   335,    69,    70,   573,   706,    71,    72,
01763      243,    73,    74,    75,   441,    76,   200,   353,   354,   184,
01764      185,   186,   187,   574,   526,   189,    78,   415,   202,   247,
01765      519,   661,   404,   405,   215,   216,   204,   391,   205,   480,
01766       79,   333,   427,   592,   337,   786,   338,   787,   684,   910,
01767      688,   685,   860,   556,   558,   698,   865,   234,    81,    82,
01768       83,    84,    85,    86,    87,    88,    89,    90,   665,   532,
01769      673,   783,   784,   346,   724,   725,   726,   749,   642,   643,
01770      750,   829,   830,   264,   265,   446,   621,   731,   297,   475,
01771       91,    92,   382,   567,   566,   539,   909,   667,   777,   846,
01772      850,    93,    94,    95,    96,    97,    98,    99,   276,   459,
01773      100,   278,   272,   270,   274,   451,   634,   633,   741,   745,
01774      101,   271,   102,   103,   207,   105,   208,   209,   551,   687,
01775      696,   697,   623,   624,   625,   626,   627,   752,   753,   628,
01776      629,   630,   631,   821,   733,   371,   557,   252,   210,   211,
01777      108,   596,   521,   561,   286,   401,   402,   657,   431,   533,
01778      341,   245
01779 };
01780 
01781 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01782    STATE-NUM.  */
01783 #define YYPACT_NINF -778
01784 static const yytype_int16 yypact[] =
01785 {
01786     -778,   133,  2394,  -778,  7010,  -778,  -778,  -778,  6523,  -778,
01787     -778,  -778,  -778,  -778,  -778,  -778,  7228,  7228,  -778,  -778,
01788     7228,  3145,  2722,  -778,  -778,  -778,  -778,   164,  6384,   -11,
01789     -778,    69,  -778,  -778,  -778,  5623,  2863,  -778,  -778,  5750,
01790     -778,  -778,  -778,  -778,  -778,  -778,  8427,  8427,    96,  4342,
01791     8536,  7446,  7773,  6786,  -778,  6245,  -778,  -778,  -778,    74,
01792       93,   122,  8645,  8427,  -778,   187,  -778,   698,   288,  -778,
01793     -778,   230,   167,  -778,   180,  8754,  -778,   234,  2846,   273,
01794      310,  -778,  8536,  8536,  -778,  -778,  4986,  8859,  8964,  9069,
01795     5496,    16,    60,  -778,  -778,   174,  -778,  -778,  -778,  -778,
01796     -778,  -778,  -778,  -778,   201,  -778,   258,   282,   206,  -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,  -778,  -778,  -778,
01802     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01803     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01804     -778,  -778,  -778,  -778,  -778,  -778,  -778,   212,  -778,  -778,
01805     -778,  -778,   215,  8427,   303,  4472,  8427,  8427,  8427,  -778,
01806      257,  2846,   285,  -778,  -778,   281,   343,    38,   337,   263,
01807      290,  -778,  -778,  -778,  4877,  -778,  7228,  7228,  -778,  -778,
01808     5116,  -778,  8536,   599,  -778,   296,   315,  4602,  -778,  -778,
01809     -778,   311,   328,  -778,   347,   206,   396,   446,  7119,  4342,
01810      329,   187,   698,   -11,   370,  -778,   288,   339,   -30,    30,
01811     -778,   285,   356,    30,  -778,   -11,   442,   375,  9174,   390,
01812     -778,   351,   373,   383,  -778,  -778,  -778,  -778,  -778,  -778,
01813      515,  -778,   552,   587,   620,   397,   607,   407,    34,   473,
01814      474,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  5225,  8536,
01815     8536,  8536,  8536,  7119,  8536,  8536,  -778,  -778,  7882,  -778,
01816     4342,  6898,   413,  7882,  8427,  8427,  8427,  8427,  8427,  8427,
01817     8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,
01818     8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,  8427,
01819     1712,  7228,  2060,  3517,   288,    80,    80,  8536,  8536,   187,
01820      534,   416,   516,  -778,  -778,   386,   568,    50,    72,   301,
01821      321,  8536,   363,  -778,    66,   393,  -778,  -778,  -778,    36,
01822       41,   103,   224,   259,   266,   322,   348,   369,  -778,  -778,
01823     -778,   377, 10211, 10211,  -778,  -778,  -778,  -778,  8645,  8645,
01824     -778,   483,  -778,  -778,  -778,   268,  -778,  -778,  8427,  8427,
01825     7337,  -778,  -778,  2216,  7228,  9441,  8427,  8427,  7555,  -778,
01826      -11,   454,  -778,  -778,   -11,  -778,  -778,    70,  -778,  -778,
01827     -778,  -778,  -778,  6523,  -778,  8427,  3937,   463,  2216,  9441,
01828     8427,   698,   -11,  -778,  -778,  5353,   462,   -11,  -778,  7664,
01829     -778,  -778,  7773,  -778,  -778,  -778,   296,   411,  -778,  -778,
01830     -778,   467,  9174,  9518,  7228,  9595,  1033,  -778,  -778,  -778,
01831     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,    39,
01832     -778,  -778,   472,  -778,  8427,  8427,  -778,  -778,  -778,  -778,
01833     -778,  -778,  -778,  -778,  -778,    28,  8427,  -778,   468,   487,
01834     -778,   -11,  9174,   496,  -778,  -778,  1576,  -778,  -778,   396,
01835     1512,  1512,  1512,  1512,  1223,  1223,  1879,  2079,  1512,  1512,
01836     2146,  2146,   582,   582,  2705,  1223,  1223,  1098,  1098,   790,
01837      514,   514,   396,   396,   396,  3286,  5991,  3372,  6105,  -778,
01838      328,  -778,   -11,   448,  -778,   451,  -778,  -778,  3004,   639,
01839      644,  -778,  3662,   646,  4082,    42,    42,   534,  7991,   639,
01840      109,  9672,  7228,  9749,  -778,   288,  -778,   411,  -778,   187,
01841     -778,  -778,  -778,  9826,  7228,  9903,  3517,  8536,  1115,  -778,
01842     -778,  -778,  -778,  -778,  1235,  1235,    28,    28,  -778, 10270,
01843     -778,  2846,  -778,  -778,  6523, 10289,  -778,  8427,   285,  -778,
01844      290,  5877,  2581,   -11,   410,   529,  -778,  -778,  -778,  -778,
01845     -778,  -778,  8536,  2846,   535,  -778,   328,   328,  2846,    20,
01846      698,  -778,    30,  9174,   467,   338,   271,   -11,   228,   261,
01847      557,  -778,  -778,  -778,  -778,   666,  -778,  -778,  -778,  -778,
01848      923,    43,  -778,  -778,  -778,  -778,   543,  -778,   544,   623,
01849      547,   642,  -778,  -778,   722,  -778,  -778,  -778,   396,   396,
01850     -778,   904,  4747,  -778,  -778,   555,  8100,  -778,   467,  9174,
01851     8427,   598,  8645,  8645,  -778,   483,   570,   538,  8645,  8645,
01852     -778,  -778,   483,  -778,  -778,  -778,  8209,   701,  -778,   441,
01853     -778,   701,  -778,  -778,  -778,  -778,   639,    31,  -778,   110,
01854      132,   -11,   126,   144,  8536,   187,  -778,  8536,  3517,   338,
01855      271,  -778,   -11,   639,    70,   923,  3517,   187,  6662,  -778,
01856     -778,  -778,  -778,  4747,  4602,  8427,    28,  -778,  -778,  -778,
01857     8427,  8427,   536,  8427,  8427,    70,  -778,  -778,  -778,   251,
01858     8427,  -778,   666,   450,  -778,   579,   -11,  -778,   583,  4747,
01859     4602,  -778,   923,  -778,  -778,   923,  -778,  -778,   779,  -778,
01860     -778,  4602,  -778,  -778,  -778,  -778,  -778,   625,   809,   583,
01861      615,   595,  -778,   604,   605,  -778,  -778,   740,  8427,   619,
01862      467,  2846,  8427,  -778,  2846,  -778,  2846,  -778,  -778,  8645,
01863     -778,  2846,  -778,  2846,  -778,   468,  -778,   675,  -778,  4212,
01864      757,  -778,  8536,   639,  -778,   639,  4747,  4747,  -778,  8318,
01865     3807,   147,    42,  -778,   187,   639,  -778,  -778,  -778,   -11,
01866      639,  -778,  -778,   759,   630,  2846,  4602,  8427,  -778,  -778,
01867      -11,   845,   632,   826,  -778,   -11,   760,   637,  -778,   640,
01868      643,  -778,   647,  -778,   651,   647,   656,  9279,  -778,   657,
01869     -778,  -778,   682,  -778,  1199,  -778,  1199,  -778,   779,  -778,
01870     -778,   658,  2846,  -778,  2846,  9384,    80,  -778,  -778,  4747,
01871     -778,  -778,    80,  -778,  -778,   639,   639,  -778,   115,  -778,
01872     3517,  -778,  -778,  -778,  -778,  1115,  -778,  -778,   664,  -778,
01873      662,   845,   491,  -778,  -778,  -778,  -778,   923,  -778,   779,
01874     -778,   779,  -778,   779,  -778,  -778,  -778,   751,   429,   809,
01875     -778,   672,   673,   647,  -778,   679,   647,   765,  -778,   432,
01876      373,   383,  3517,  -778,  3662,  -778,  -778,  -778,  -778,  -778,
01877     4747,   639,  3517,  -778,   845,   662,   845,   685,   647,   686,
01878      647,   647,  -778,  9980,  -778,  1199,  -778,   779,  -778,  -778,
01879      779,  -778,  -778,   411, 10057,  7228, 10134,   644,   441,   639,
01880     -778,   639,   662,   845,  -778,   779,  -778,  -778,  -778,   688,
01881      690,   647,   687,   647,   647,    81,   271,   -11,    86,   118,
01882     -778,  -778,  -778,  -778,   662,   647,  -778,   779,  -778,  -778,
01883     -778,   124,  -778,   647,  -778
01884 };
01885 
01886 /* YYPGOTO[NTERM-NUM].  */
01887 static const yytype_int16 yypgoto[] =
01888 {
01889     -778,  -778,  -778,   399,  -778,    33,  -778,  -530,   -33,  -778,
01890      159,  -778,    23,   -55,    21,  -778,  -462,  -778,   -15,   741,
01891     -136,    -1,   -66,  -778,  -403,   -26,  1181,  -306,   750,   -52,
01892     -778,   -20,  -778,  -778,    32,  -778,   748,  -778,   540,  -778,
01893       46,   -98,  -298,    54,    76,  -778,  -278,  -196,   -44,  -283,
01894       27,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01895     -778,  -778,  -778,  -778,  -778,  -778,  -778,     2,  -778,  -778,
01896     -778,  -778,  -778,  -778,  -778,  -778,  -778,  -778,   298,  -323,
01897     -512,   -97,  -610,  -778,  -755,  -748,   120,  -778,  -485,  -778,
01898     -636,  -778,   -49,  -778,  -778,  -778,  -778,  -778,  -778,  -778,
01899     -778,  -778,   752,  -778,  -778,  -520,  -778,   -92,  -778,  -778,
01900     -778,  -778,  -778,  -778,   753,  -778,  -778,  -778,  -778,  -778,
01901     -778,  -778,  -778,   792,  -778,  -229,  -778,  -778,  -778,  -778,
01902        7,  -778,    13,  -778,  1031,   762,  1198,  1109,  -778,  -778,
01903      -12,  -416,  -706,  -549,  -667,  -121,  -679,  -777,    25,   128,
01904     -778,  -579,  -778,  -434,   531,  -778,  -778,  -778,   -41,  -287,
01905     1927,  -254,  -778,  -778,   -32,    -4,    88,  -554,  -217,    63,
01906      -31,    -2
01907 };
01908 
01909 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
01910    positive, shift that token.  If negative, reduce the rule which
01911    number is the opposite.  If YYTABLE_NINF, syntax error.  */
01912 #define YYTABLE_NINF -566
01913 static const yytype_int16 yytable[] =
01914 {
01915      109,   199,   199,   269,    80,   199,    80,   248,   224,   302,
01916      249,   253,   632,   534,   399,   190,   240,   676,   206,   206,
01917      488,   191,   206,   222,   675,   225,   693,   259,   336,   712,
01918      622,   339,   433,   522,   288,   190,   435,   110,   369,   604,
01919      188,   191,   831,   453,   531,   456,   548,   460,   244,   250,
01920      254,    80,   206,   719,   340,   261,   823,   780,   873,   894,
01921      188,   785,   754,   870,   206,   818,   727,   549,   218,   672,
01922      203,   212,   729,   246,   213,   -96,   520,   261,   528,   648,
01923      260,   703,   704,   281,   206,   206,   374,   188,   206,   345,
01924      355,   355,   815,   531,   -99,   462,   583,  -103,   219,   -98,
01925      447,   372,   260,   422,   640,   334,   334,   294,   295,   334,
01926      429,   586,   579,   832,   260,   260,   260,   430,   564,   565,
01927      579,  -475,   188,   915,   632,  -482,  -474,   791,   287,   -69,
01928      779,  -100,   538,     3,  -102,   -99,   221,   -97,   796,   520,
01929      463,   528,   641,   448,   449,   586,   607,   -96,   894,   287,
01930      730,   -98,   237,   820,   380,   373,   824,  -101,   795,   873,
01931      -83,    67,   240,    67,   481,   597,   800,   818,   942,  -100,
01932      432,   789,   -97,   727,   812,  -475,   284,   430,   285,   550,
01933     -474,   279,   280,   831,   381,   635,   632,   284,  -476,   285,
01934      -88,   597,   440,   767,   417,   964,   375,    80,   823,   199,
01935      774,   199,   199,   392,   728,   227,   240,   755,   392,   424,
01936      425,   284,   -95,   285,   818,   406,   206,   221,   206,   206,
01937      275,   806,   206,  -543,   206,   284,   -99,   285,   -99,    80,
01938      636,   -98,   374,   -98,   468,   469,   470,   471,   244,   277,
01939       80,    80,  -476,   407,   681,   409,   760,   691,   907,   -94,
01940      -91,   436,  -543,   -90,   479,   892,   692,   895,   296,   479,
01941      261,   632,   727,  -100,   727,  -100,   -90,   240,   400,   -97,
01942      403,   -97,   -93,    56,  -544,   483,   298,  -406,   218,   799,
01943      859,   380,   535,   536,   -92,   260,   -92,   -89,  -482,   597,
01944       80,   206,   206,   206,   206,    80,   206,   206,   919,   244,
01945      206,   597,    80,   261,   287,   206,   220,   537,   408,  -477,
01946      -96,   221,   334,   334,   334,   334,   199,   473,   474,   477,
01947      299,   467,   727,   917,   485,   294,   295,  -540,   260,   406,
01948      911,   426,   284,   206,   285,    80,  -406,   -90,   908,   206,
01949      206,   -88,   375,   303,  -479,   378,   952,  -541,   217,   580,
01950      397,  -478,   383,   206,   790,   420,  -279,   220,  -324,   385,
01951      334,   334,   518,  -477,  -547,   727,   388,   727,   -90,   379,
01952      -92,   -90,  -103,   389,   545,   -90,   440,  -102,   527,   199,
01953      206,   206,   941,   776,   709,   717,  -469,  -406,   602,  -406,
01954     -406,  -103,   406,   591,   727,   330,   206,   421,  -479,   568,
01955      570,   -92,   287,   971,   -92,  -478,  -472,  -480,   -92,  -279,
01956     -279,  -324,  -324,  -544,   109,   546,   440,   552,    80,   547,
01957      190,   390,   -95,  -547,   396,   518,   191,    80,   393,   199,
01958      398,   632,   418,  -469,   438,   439,   443,  -540,   414,  -469,
01959     -469,   527,   406,  -540,   261,   188,   206,    67,   331,   332,
01960      518,   416,   472,   214,  -472,   782,   779,  -541,  -481,  -472,
01961     -472,  -480,   559,  -541,   304,   527,   699,   701,  -272,   260,
01962      217,   541,   423,   644,  -547,   518,  -547,  -547,   553,   -68,
01963     -543,   394,   395,   428,   261,   394,   419,  -469,   587,   444,
01964      445,   527,   589,   434,   677,   590,  -280,   713,   437,   669,
01965      651,   671,   721,   457,   611,   612,   613,   614,  -472,   260,
01966      599,  -481,  -481,   461,   923,   601,   560,   934,   656,   -98,
01967      751,  -272,  -272,   902,   542,   543,   663,   199,   668,   904,
01968      442,   554,   555,   420,    80,   658,    80,   718,   659,   199,
01969      406,   464,   465,   721,   206,   611,   612,   613,   614,  -280,
01970     -280,   538,   406,   484,   707,  -102,   206,   -98,    80,   206,
01971     -100,   466,   663,   663,   644,   644,   654,   554,   555,   647,
01972      935,   936,   540,   518,   660,    67,   447,   572,   392,   656,
01973      694,   190,   304,   440,   600,   518,   -94,   191,   -90,   527,
01974      811,   -92,   251,   544,   206,   663,   655,   588,   674,   674,
01975      595,   527,   -83,   656,   662,   261,   188,   603,  -258,   757,
01976      660,   660,   686,   447,   822,   715,   714,   825,   637,   448,
01977      449,   450,   479,   807,   734,   769,   734,   646,   734,   792,
01978      260,   916,   794,   327,   328,   329,   649,   957,  -100,   756,
01979      700,   702,   654,   660,    80,   -97,   802,   -97,   447,   664,
01980      304,   261,   666,   410,   206,   206,   448,   449,   452,   670,
01981      206,   206,   411,   412,   778,   781,   720,   781,   447,   781,
01982      803,   804,   716,   763,   765,   737,   260,   656,   -89,   770,
01983      772,   447,   597,   732,   735,   455,   206,   738,   656,   206,
01984       80,   448,   449,   454,   740,  -259,   816,   817,    80,   325,
01985      326,   327,   328,   329,   644,    80,    80,   334,   826,   762,
01986      334,   448,   449,   458,   768,   893,   779,   896,   721,   813,
01987      611,   612,   613,   614,   448,   449,   756,   852,   748,   833,
01988      188,    80,    80,   384,   827,   834,   386,   387,   289,   290,
01989      291,   292,   293,    80,   836,   838,   848,   756,   793,   734,
01990      840,   734,   734,   855,   856,   722,   918,   858,   920,  -260,
01991      801,   723,   921,   845,   201,   201,   849,   867,   201,   866,
01992      875,   206,   871,   868,   876,   847,   742,   743,   851,   744,
01993      877,    80,   798,   879,   206,    44,    45,   881,    80,    80,
01994      843,   883,    80,   886,   233,   236,   890,   889,  -261,   201,
01995      201,   913,   914,   808,   951,   334,   953,   922,    80,   954,
01996      282,   283,   925,   927,   814,   594,   903,   734,   734,   930,
01997      734,   933,   734,   734,   965,   943,   945,   967,   343,   888,
01998     -543,   721,  -544,   611,   612,   613,   614,   678,   478,   358,
01999      924,   961,   810,   487,   376,   960,   973,   899,   377,   273,
02000        0,    80,   370,   912,   260,   674,   781,   861,   304,   891,
02001      819,   828,    80,   611,   612,   613,   614,     0,   615,   937,
02002        0,   938,   260,   317,   318,   617,     0,   939,   721,     0,
02003      611,   612,   613,   614,     0,     0,     0,   863,     0,   734,
02004      734,   734,     0,   734,   734,   618,     0,   721,   869,   611,
02005      612,   613,   614,   874,    80,     0,    80,   325,   326,   327,
02006      328,   329,    80,     0,    80,   722,   734,   734,   734,   734,
02007      199,   872,     0,     0,     0,     0,     0,     0,     0,   576,
02008      578,     0,     0,   406,   722,   668,   781,   206,   251,     0,
02009        0,   201,     0,     0,   201,   201,   282,     0,     0,   734,
02010      734,   734,   734,   656,     0,   518,   747,     0,   611,   612,
02011      613,   614,   201,   734,   201,   201,   518,     0,     0,   578,
02012        0,   734,   251,     0,   788,   610,     0,   611,   612,   613,
02013      614,     0,   527,     0,     0,     0,     0,     0,     0,     0,
02014        0,   797,     0,   615,     0,     0,     0,     0,     0,   616,
02015      617,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02016        0,     0,   615,     0,     0,     0,   645,     0,   616,   617,
02017      618,     0,     0,   619,     0,     0,     0,     0,     0,     0,
02018        0,     0,     0,   104,     0,   104,     0,     0,     0,   618,
02019        0,     0,   619,     0,     0,     0,   201,     0,     0,   748,
02020        0,   486,   489,   490,   491,   492,   493,   494,   495,   496,
02021      497,   498,   499,   500,   501,   502,   503,   504,   505,   506,
02022      507,   508,   509,   510,   511,   512,   513,   514,   487,   201,
02023      104,   853,     0,   854,   262,   610,     0,   611,   612,   613,
02024      614,     0,     0,   862,     0,     0,     0,     0,   864,     0,
02025        0,     0,     0,     0,     0,     0,   262,     0,     0,     0,
02026        0,   107,     0,   107,     0,     0,     0,   708,   347,   356,
02027      356,   356,   615,     0,     0,     0,   569,   571,   616,   617,
02028        0,     0,     0,     0,     0,     0,   575,   201,   201,     0,
02029        0,     0,   201,     0,   569,   571,   201,     0,     0,   618,
02030        0,     0,   619,   905,   906,     0,     0,     0,   107,   736,
02031        0,   739,   263,   593,     0,     0,   304,   610,   598,   611,
02032      612,   613,   614,     0,     0,   620,     0,   201,     0,     0,
02033      201,   317,   318,    77,   263,    77,   759,     0,     0,     0,
02034        0,     0,   201,     0,     0,     0,   348,   357,   357,     0,
02035      106,     0,   106,     0,   615,     0,   775,     0,     0,   940,
02036      616,   617,   638,   639,   324,   325,   326,   327,   328,   329,
02037        0,     0,     0,     0,   201,     0,   104,     0,     0,     0,
02038       77,   618,     0,     0,   619,  -565,     0,   962,     0,   963,
02039        0,     0,     0,  -565,  -565,  -565,     0,   106,  -565,  -565,
02040     -565,   747,  -565,   611,   612,   613,   614,   695,   104,     0,
02041      809,     0,  -565,     0,     0,     0,     0,     0,   344,   104,
02042      104,     0,  -565,  -565,     0,  -565,  -565,  -565,  -565,  -565,
02043        0,     0,   835,     0,   837,   839,   201,     0,   615,   262,
02044      201,   304,     0,     0,   616,   617,     0,     0,   841,     0,
02045        0,     0,   201,     0,   107,     0,   317,   318,     0,     0,
02046        0,     0,     0,     0,     0,   618,     0,     0,   619,   104,
02047     -565,     0,     0,     0,   104,   201,     0,     0,     0,   857,
02048        0,   104,   262,     0,     0,     0,   107,   322,   323,   324,
02049      325,   326,   327,   328,   329,     0,     0,   107,   107,     0,
02050      878,   880,     0,   882,     0,   884,   885,     0,     0,     0,
02051        0,     0,     0,     0,   104,     0,     0,   263,     0,     0,
02052        0,     0,  -565,     0,  -565,     0,    77,   217,  -565,     0,
02053     -565,     0,  -565,     0,     0,     0,     0,     0,     0,     0,
02054        0,     0,     0,   106,   201,     0,     0,   107,   761,     0,
02055      764,   766,   107,     0,     0,     0,   771,   773,    77,   107,
02056      263,     0,     0,     0,   201,     0,     0,     0,     0,    77,
02057       77,     0,   926,   928,   929,   106,   931,   932,     0,     0,
02058        0,     0,     0,     0,     0,     0,   106,   106,     0,     0,
02059        0,     0,   107,     0,     0,     0,     0,   104,     0,   944,
02060      946,   947,   948,   805,     0,     0,   104,     0,   764,   766,
02061        0,   771,   773,     0,     0,     0,     0,     0,   201,    77,
02062        0,     0,     0,   262,    77,     0,     0,     0,     0,     0,
02063        0,    77,   966,   968,   969,   970,   106,     0,     0,     0,
02064        0,   106,     0,     0,     0,     0,   972,     0,   106,     0,
02065        0,     0,     0,     0,   974,     0,   201,     0,     0,     0,
02066      842,     0,     0,   262,    77,     0,     0,   844,     0,     0,
02067        0,     0,     0,     0,     0,   107,     0,     0,     0,     0,
02068        0,   106,     0,     0,   107,     0,     0,   201,     0,     0,
02069        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02070        0,   263,     0,     0,     0,   844,     0,     0,     0,     0,
02071        0,     0,     0,   104,     0,   104,     0,     0,     0,     0,
02072        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02073      304,  -566,  -566,  -566,  -566,   309,   310,   104,     0,  -566,
02074     -566,   263,     0,     0,     0,   317,   318,    77,     0,     0,
02075        0,     0,     0,     0,     0,     0,    77,     0,     0,     0,
02076        0,     0,     0,     0,   106,     0,     0,     0,     0,     0,
02077      650,     0,     0,   106,   320,   321,   322,   323,   324,   325,
02078      326,   327,   328,   329,   262,     0,     0,     0,     0,     0,
02079        0,   107,     0,   107,   304,   305,   306,   307,   308,   309,
02080      310,   311,   312,   313,   314,   315,   316,     0,     0,   317,
02081      318,     0,     0,     0,     0,   107,     0,     0,     0,     0,
02082        0,     0,     0,   104,     0,     0,     0,     0,     0,     0,
02083      262,     0,     0,   201,     0,     0,   319,     0,   320,   321,
02084      322,   323,   324,   325,   326,   327,   328,   329,     0,     0,
02085        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02086        0,     0,   263,    77,     0,    77,  -237,     0,     0,   104,
02087        0,     0,     0,     0,     0,     0,     0,   104,     0,     0,
02088      106,     0,   106,     0,   104,   104,     0,    77,     0,     0,
02089        0,     0,     0,   746,     0,     0,     0,     0,     0,     0,
02090        0,   107,     0,     0,   106,     0,     0,     0,   263,     0,
02091      104,   104,     0,     0,   515,   516,     0,     0,   517,     0,
02092        0,     0,   104,     0,     0,     0,     0,     0,   155,   156,
02093      157,   158,   159,   160,   161,   162,   163,     0,     0,   164,
02094      165,     0,     0,   166,   167,   168,   169,   107,     0,     0,
02095        0,     0,     0,     0,     0,   107,     0,   170,     0,     0,
02096      104,     0,   107,   107,     0,     0,     0,   104,   104,     0,
02097        0,   104,     0,    77,   171,   172,   173,   174,   175,   176,
02098      177,   178,   179,   180,     0,   181,   182,   104,   107,   107,
02099      106,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02100      107,     0,     0,   183,   217,     0,     0,     0,   356,     0,
02101        0,     0,     0,     0,     0,     0,     0,     0,     0,    77,
02102        0,     0,     0,     0,     0,     0,   900,    77,     0,     0,
02103      104,     0,     0,     0,    77,    77,   106,     0,   107,     0,
02104        0,   104,     0,     0,   106,   107,   107,     0,     0,   107,
02105        0,   106,   106,     0,     0,     0,     0,     0,     0,     0,
02106       77,    77,     0,     0,     0,   107,     0,     0,     0,     0,
02107        0,     0,    77,     0,     0,     0,     0,   106,   106,     0,
02108        0,     0,     0,   104,     0,   104,   357,     0,     0,   106,
02109        0,   104,     0,   104,     0,     0,     0,   304,   305,   306,
02110      307,   308,   309,   310,   901,     0,   313,   314,   107,     0,
02111       77,     0,   317,   318,     0,     0,     0,    77,    77,   107,
02112        0,    77,     0,   235,   235,     0,     0,   106,   235,   235,
02113      235,     0,     0,     0,   106,   106,     0,    77,   106,     0,
02114      235,   320,   321,   322,   323,   324,   325,   326,   327,   328,
02115      329,     0,   235,     0,   106,     0,     0,     0,     0,     0,
02116        0,   107,     0,   107,   235,   235,   235,     0,     0,   107,
02117        0,   107,     0,     0,     0,     0,   898,     0,     0,     0,
02118       77,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02119        0,    77,     0,     0,     0,     0,     0,   106,     0,     0,
02120        0,     0,     0,     0,     0,     0,     0,     0,   106,     0,
02121        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02122        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02123        0,     0,     0,    77,     0,    77,     0,     0,     0,     0,
02124        0,    77,     0,    77,     0,     0,     0,     0,     0,     0,
02125      106,     0,   106,     0,     0,     0,     0,     0,   106,     0,
02126      106,     0,   523,   524,     0,     0,   525,     0,     0,     0,
02127      235,     0,     0,   235,   235,   235,   155,   156,   157,   158,
02128      159,   160,   161,   162,   163,     0,     0,   164,   165,     0,
02129        0,   166,   167,   168,   169,     0,     0,   304,   305,   306,
02130      307,   308,   309,   310,   311,   170,   313,   314,     0,     0,
02131        0,     0,   317,   318,     0,     0,     0,     0,     0,     0,
02132        0,     0,   171,   172,   173,   174,   175,   176,   177,   178,
02133      179,   180,     0,   181,   182,   235,     0,     0,     0,     0,
02134        0,   320,   321,   322,   323,   324,   325,   326,   327,   328,
02135      329,   183,   217,     0,     0,     0,     0,     0,     0,     0,
02136        0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
02137      310,   311,   312,   313,   314,  -566,  -566,     0,   235,   317,
02138      318,   235,   235,   235,   235,   235,   235,   235,   235,   235,
02139      235,   235,   235,   235,   235,   235,   235,   235,   235,   235,
02140      235,   235,   235,   235,   235,   235,   235,     0,   320,   321,
02141      322,   323,   324,   325,   326,   327,   328,   329,   581,   516,
02142        0,     0,   582,     0,     0,     0,     0,     0,     0,     0,
02143        0,     0,   155,   156,   157,   158,   159,   160,   161,   162,
02144      163,     0,     0,   164,   165,     0,     0,   166,   167,   168,
02145      169,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02146        0,   170,     0,     0,     0,   235,   235,   235,     0,     0,
02147        0,     0,     0,   235,   235,   235,     0,     0,   171,   172,
02148      173,   174,   175,   176,   177,   178,   179,   180,     0,   181,
02149      182,     0,   235,     0,     0,     0,     0,   235,     0,     0,
02150        0,     0,     0,     0,     0,     0,   235,   183,   217,   235,
02151        0,     0,     0,     0,     0,     0,     0,     0,     0,   235,
02152        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02153        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02154        0,   235,   235,     0,  -565,     4,     0,     5,     6,     7,
02155        8,     9,     0,   235,     0,    10,    11,     0,     0,   235,
02156       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02157        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02158       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02159       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
02160       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02161       46,    47,     0,     0,     0,   235,     0,     0,     0,     0,
02162        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02163       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02164        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02165        0,     0,     0,     0,   235,     0,     0,     0,     0,     0,
02166        0,     0,     0,     0,     0,     0,    61,    62,    63,     0,
02167        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02168      235,     0,     0,     0,     0,     0,     0,     0,     0,  -565,
02169        0,  -565,     0,     0,     0,     0,     0,     0,     0,     0,
02170        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02171        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02172        0,     0,     0,   235,     0,     0,   235,   235,     0,     0,
02173        0,  -279,     0,     0,     0,     0,     0,     0,     0,  -279,
02174     -279,  -279,     0,   235,  -279,  -279,  -279,     0,  -279,     0,
02175        0,     0,     0,     0,     0,     0,     0,     0,  -279,  -279,
02176     -279,     0,     0,     0,     0,     0,     0,     0,  -279,  -279,
02177        0,  -279,  -279,  -279,  -279,  -279,     0,     0,     0,     0,
02178        0,     0,   235,     0,     0,     0,     0,   235,   235,     0,
02179      235,   235,     0,     0,     0,     0,     0,   235,     0,  -279,
02180     -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
02181     -279,  -279,     0,     0,  -279,  -279,  -279,     0,   711,  -279,
02182        0,     0,     0,     0,     0,  -279,     0,     0,     0,     0,
02183        0,     0,     0,     0,     0,   235,     0,     0,  -279,   235,
02184     -101,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
02185     -279,  -279,  -279,     0,     0,     0,     0,     0,     0,     0,
02186        0,     0,     0,     0,     0,     0,   235,     0,  -279,  -279,
02187     -279,  -279,  -405,     0,  -279,  -279,  -279,     0,  -279,     0,
02188     -405,  -405,  -405,     0,   235,  -405,  -405,  -405,     0,  -405,
02189        0,     0,     0,     0,     0,     0,     0,     0,  -405,  -405,
02190     -405,     0,     0,     0,   235,     0,     0,     0,     0,  -405,
02191     -405,     0,  -405,  -405,  -405,  -405,  -405,     0,     0,     0,
02192        0,     0,   235,   304,   305,   306,   307,   308,   309,   310,
02193      311,   312,   313,   314,   315,   316,     0,     0,   317,   318,
02194     -405,  -405,  -405,  -405,  -405,  -405,  -405,  -405,  -405,  -405,
02195     -405,  -405,  -405,     0,     0,  -405,  -405,  -405,     0,     0,
02196     -405,     0,     0,     0,     0,   319,  -405,   320,   321,   322,
02197      323,   324,   325,   326,   327,   328,   329,     0,     0,     0,
02198        0,     0,  -405,     0,  -405,  -405,  -405,  -405,  -405,  -405,
02199     -405,  -405,  -405,  -405,     0,     0,     0,     0,     0,     0,
02200        0,     0,   221,     0,     0,     0,     0,     0,  -405,  -405,
02201     -405,  -405,  -405,  -273,   217,  -405,  -405,  -405,     0,  -405,
02202        0,  -273,  -273,  -273,     0,     0,  -273,  -273,  -273,     0,
02203     -273,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02204     -273,  -273,  -273,     0,     0,     0,     0,     0,     0,     0,
02205     -273,  -273,     0,  -273,  -273,  -273,  -273,  -273,     0,     0,
02206        0,     0,     0,     0,   304,   305,   306,   307,   308,   309,
02207      310,   311,   312,   313,   314,   315,   316,     0,     0,   317,
02208      318,  -273,  -273,  -273,  -273,  -273,  -273,  -273,  -273,  -273,
02209     -273,  -273,  -273,  -273,     0,     0,  -273,  -273,  -273,     0,
02210        0,  -273,     0,     0,     0,     0,   319,  -273,   320,   321,
02211      322,   323,   324,   325,   326,   327,   328,   329,     0,     0,
02212     -273,     0,     0,  -273,  -273,  -273,  -273,  -273,  -273,  -273,
02213     -273,  -273,  -273,  -273,  -273,     0,     0,     0,     0,     0,
02214        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02215     -273,  -273,  -273,  -273,  -565,     0,  -273,  -273,  -273,     0,
02216     -273,     0,  -565,  -565,  -565,     0,     0,  -565,  -565,  -565,
02217        0,  -565,     0,     0,     0,     0,     0,     0,     0,     0,
02218     -565,  -565,  -565,     0,     0,     0,     0,     0,     0,     0,
02219        0,  -565,  -565,     0,  -565,  -565,  -565,  -565,  -565,     0,
02220        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02221        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02222        0,     0,  -565,  -565,  -565,  -565,  -565,  -565,  -565,  -565,
02223     -565,  -565,  -565,  -565,  -565,     0,     0,  -565,  -565,  -565,
02224        0,     0,  -565,     0,     0,     0,     0,     0,  -565,     0,
02225        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02226        0,     0,     0,     0,  -565,     0,  -565,  -565,  -565,  -565,
02227     -565,  -565,  -565,  -565,  -565,  -565,     0,     0,     0,     0,
02228        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02229     -565,  -565,  -565,  -565,  -565,  -286,   217,  -565,  -565,  -565,
02230        0,  -565,     0,  -286,  -286,  -286,     0,     0,  -286,  -286,
02231     -286,     0,  -286,     0,     0,     0,     0,     0,     0,     0,
02232        0,     0,  -286,  -286,     0,     0,     0,     0,     0,     0,
02233        0,     0,  -286,  -286,     0,  -286,  -286,  -286,  -286,  -286,
02234        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02235        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02236        0,     0,     0,  -286,  -286,  -286,  -286,  -286,  -286,  -286,
02237     -286,  -286,  -286,  -286,  -286,  -286,     0,     0,  -286,  -286,
02238     -286,     0,     0,  -286,     0,     0,     0,     0,     0,  -286,
02239        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02240        0,     0,     0,     0,     0,  -286,     0,  -286,  -286,  -286,
02241     -286,  -286,  -286,  -286,  -286,  -286,  -286,     0,     0,     0,
02242        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02243        0,     0,  -286,  -286,  -286,  -286,  -547,   214,  -286,  -286,
02244     -286,     0,  -286,     0,  -547,  -547,  -547,     0,     0,     0,
02245     -547,  -547,     0,  -547,     0,     0,     0,     0,     0,     0,
02246        0,     0,  -547,     0,     0,     0,     0,     0,     0,     0,
02247        0,     0,     0,  -547,  -547,     0,  -547,  -547,  -547,  -547,
02248     -547,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02249        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02250        0,     0,     0,     0,  -547,  -547,  -547,  -547,  -547,  -547,
02251     -547,  -547,  -547,  -547,  -547,  -547,  -547,     0,     0,  -547,
02252     -547,  -547,  -279,   652,     0,     0,     0,     0,     0,     0,
02253     -279,  -279,  -279,     0,     0,     0,  -279,  -279,     0,  -279,
02254        0,     0,     0,     0,     0,   -99,  -547,     0,  -547,  -547,
02255     -547,  -547,  -547,  -547,  -547,  -547,  -547,  -547,     0,  -279,
02256     -279,     0,  -279,  -279,  -279,  -279,  -279,     0,     0,     0,
02257        0,     0,  -547,  -547,  -547,  -547,   -91,     0,     0,  -547,
02258        0,  -547,     0,  -547,     0,     0,     0,     0,     0,     0,
02259     -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
02260     -279,  -279,  -279,     0,     0,  -279,  -279,  -279,     0,   653,
02261        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02262        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02263        0,  -101,  -279,     0,  -279,  -279,  -279,  -279,  -279,  -279,
02264     -279,  -279,  -279,  -279,     0,     0,     0,     0,     0,     0,
02265        0,     0,     0,     0,     0,     0,     0,     0,     0,  -279,
02266     -279,  -279,   -93,     0,     0,  -279,     0,  -279,   238,  -279,
02267        5,     6,     7,     8,     9,  -565,  -565,  -565,    10,    11,
02268        0,     0,  -565,    12,     0,    13,    14,    15,    16,    17,
02269       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02270       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02271        0,     0,    28,    29,     0,    31,    32,    33,    34,    35,
02272       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02273       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02274        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02275        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02276       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02277       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02278        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02279       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02280        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02281        0,     0,  -565,   238,  -565,     5,     6,     7,     8,     9,
02282        0,     0,  -565,    10,    11,     0,  -565,  -565,    12,     0,
02283       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02284        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02285        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02286       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02287        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02288        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02289        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02290        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02291       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02292        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02293        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02294        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02295        0,     0,     0,     0,     0,     0,     0,  -565,   238,  -565,
02296        5,     6,     7,     8,     9,     0,     0,  -565,    10,    11,
02297        0,     0,  -565,    12,  -565,    13,    14,    15,    16,    17,
02298       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02299       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02300        0,     0,    28,    29,     0,    31,    32,    33,    34,    35,
02301       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02302       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02303        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02304        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02305       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02306       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02307        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02308       62,    63,     0,     0,     0,     0,     0,     0,     4,     0,
02309        5,     6,     7,     8,     9,     0,     0,     0,    10,    11,
02310        0,     0,  -565,    12,  -565,    13,    14,    15,    16,    17,
02311       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02312       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02313        0,     0,    28,    29,    30,    31,    32,    33,    34,    35,
02314       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02315       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02316        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02317        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02318       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02319       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02320        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02321       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02322        0,     0,     0,     0,  -565,     0,     0,     0,     0,     0,
02323        0,     0,  -565,   238,  -565,     5,     6,     7,     8,     9,
02324        0,     0,  -565,    10,    11,     0,     0,  -565,    12,     0,
02325       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02326        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02327        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02328       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02329        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02330        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02331        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02332        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02333       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02334        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02335        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02336        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02337        0,  -565,  -565,    10,    11,     0,     0,  -565,    12,  -565,
02338       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02339        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02340        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02341       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02342        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02343        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02344        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02345        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02346       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02347        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02348        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02349        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02350        0,     0,     0,    10,    11,     0,     0,  -565,    12,  -565,
02351       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02352        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02353        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02354       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02355        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02356        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02357        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02358        0,   239,    50,     0,    51,    52,     0,    53,     0,    54,
02359       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02360        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02361        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02362        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02363        0,     0,     0,    10,    11,  -565,     0,  -565,    12,  -565,
02364       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02365        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02366        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02367       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02368        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02369        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02370        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02371        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02372       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02373        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02374        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02375        0,     0,     0,   238,     0,     5,     6,     7,     8,     9,
02376        0,     0,     0,    10,    11,  -565,     0,  -565,    12,  -565,
02377       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02378        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02379        0,    27,     0,     0,     0,     0,     0,    28,    29,     0,
02380       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02381        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02382        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02383        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02384        0,    49,    50,     0,    51,    52,     0,    53,     0,    54,
02385       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02386        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02387        0,     0,     0,     0,    61,    62,    63,     0,     0,     0,
02388        0,     0,     0,     0,     0,     0,     0,     0,     0,  -565,
02389        0,     0,     0,     0,     0,     0,     0,  -565,   238,  -565,
02390        5,     6,     7,     8,     9,     0,     0,  -565,    10,    11,
02391        0,     0,     0,    12,     0,    13,    14,    15,    16,    17,
02392       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02393       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
02394        0,     0,    28,    29,     0,    31,    32,    33,    34,    35,
02395       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02396       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02397        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02398        0,     0,     0,    48,     0,     0,    49,    50,     0,    51,
02399       52,     0,    53,     0,    54,    55,    56,    57,    58,    59,
02400       60,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02401        0,     0,     0,     0,     0,     0,     0,     0,     0,    61,
02402       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02403        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02404        0,     0,  -565,    12,  -565,    13,    14,    15,    16,    17,
02405       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
02406       23,    24,    25,    26,     0,     0,   192,     0,     0,     0,
02407        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02408       36,    37,    38,    39,    40,   193,    41,    42,     0,    43,
02409       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02410        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02411        0,     0,     0,   194,     0,     0,   195,    50,     0,    51,
02412       52,     0,   196,   197,    54,    55,    56,    57,    58,    59,
02413       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02414        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02415      198,    63,    12,     0,    13,    14,    15,    16,    17,    18,
02416       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02417       24,    25,    26,     0,   221,    27,     0,     0,     0,     0,
02418        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02419       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02420       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02421        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02422        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02423        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02424        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02425        0,     0,     0,     0,     0,     0,     0,     0,    61,    62,
02426       63,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02427        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02428        0,   284,    12,   285,    13,    14,    15,    16,    17,    18,
02429       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02430       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02431        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02432       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02433       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02434        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02435        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02436        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02437        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02438        7,     8,     9,     0,     0,     0,    10,    11,    61,    62,
02439       63,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02440        0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02441       25,    26,     0,   221,    27,     0,     0,     0,     0,     0,
02442       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
02443       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02444        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02445        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02446        0,    48,     0,     0,    49,    50,     0,    51,    52,     0,
02447       53,     0,    54,    55,    56,    57,    58,    59,    60,     0,
02448        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02449        0,     0,     0,     0,     0,     0,     0,    61,    62,    63,
02450        0,     0,     0,     0,     0,     0,     5,     6,     7,     8,
02451        9,     0,     0,     0,    10,    11,     0,     0,     0,    12,
02452      466,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02453        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02454        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02455        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02456       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02457       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02458        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02459        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02460       54,    55,    56,    57,    58,    59,    60,     0,     0,     0,
02461        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02462        0,     0,     0,     0,     0,    61,    62,    63,     0,     0,
02463        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02464        0,     0,     0,     0,     0,     0,     0,     0,   466,   111,
02465      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
02466      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02467      132,   133,   134,     0,     0,     0,   135,   136,   137,   359,
02468      360,   361,   362,   142,   143,   144,     0,     0,     0,     0,
02469        0,   145,   146,   147,   148,   363,   364,   365,   366,   153,
02470       37,    38,   367,    40,     0,     0,     0,     0,     0,     0,
02471        0,     0,   155,   156,   157,   158,   159,   160,   161,   162,
02472      163,     0,     0,   164,   165,     0,     0,   166,   167,   168,
02473      169,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02474        0,   170,     0,     0,     0,     0,     0,     0,     0,     0,
02475        0,     0,     0,     0,     0,     0,     0,     0,   171,   172,
02476      173,   174,   175,   176,   177,   178,   179,   180,     0,   181,
02477      182,     0,     0,     0,     0,     0,  -540,  -540,  -540,     0,
02478     -540,     0,     0,     0,  -540,  -540,     0,   183,   368,  -540,
02479        0,  -540,  -540,  -540,  -540,  -540,  -540,  -540,     0,  -540,
02480        0,     0,     0,  -540,  -540,  -540,  -540,  -540,  -540,  -540,
02481        0,     0,  -540,     0,     0,     0,     0,     0,     0,  -540,
02482        0,     0,  -540,  -540,  -540,  -540,  -540,  -540,  -540,  -540,
02483     -540,  -540,  -540,  -540,     0,  -540,  -540,  -540,     0,  -540,
02484     -540,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02485        0,     0,     0,     0,     0,     0,     0,     0,     0,  -540,
02486        0,     0,  -540,  -540,     0,  -540,  -540,     0,  -540,  -540,
02487     -540,  -540,  -540,  -540,  -540,  -540,  -540,     0,     0,     0,
02488        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02489        0,     0,     0,     0,     0,  -540,  -540,  -540,     0,     0,
02490        0,     0,     0,  -541,  -541,  -541,     0,  -541,     0,  -540,
02491        0,  -541,  -541,     0,     0,  -540,  -541,     0,  -541,  -541,
02492     -541,  -541,  -541,  -541,  -541,     0,  -541,     0,     0,     0,
02493     -541,  -541,  -541,  -541,  -541,  -541,  -541,     0,     0,  -541,
02494        0,     0,     0,     0,     0,     0,  -541,     0,     0,  -541,
02495     -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,  -541,
02496     -541,     0,  -541,  -541,  -541,     0,  -541,  -541,     0,     0,
02497        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02498        0,     0,     0,     0,     0,     0,  -541,     0,     0,  -541,
02499     -541,     0,  -541,  -541,     0,  -541,  -541,  -541,  -541,  -541,
02500     -541,  -541,  -541,  -541,     0,     0,     0,     0,     0,     0,
02501        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02502        0,     0,  -541,  -541,  -541,     0,     0,     0,     0,     0,
02503     -543,  -543,  -543,     0,  -543,     0,  -541,     0,  -543,  -543,
02504        0,     0,  -541,  -543,     0,  -543,  -543,  -543,  -543,  -543,
02505     -543,  -543,     0,     0,     0,     0,     0,  -543,  -543,  -543,
02506     -543,  -543,  -543,  -543,     0,     0,  -543,     0,     0,     0,
02507        0,     0,     0,  -543,     0,     0,  -543,  -543,  -543,  -543,
02508     -543,  -543,  -543,  -543,  -543,  -543,  -543,  -543,     0,  -543,
02509     -543,  -543,     0,  -543,  -543,     0,     0,     0,     0,     0,
02510        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02511        0,     0,     0,  -543,   710,     0,  -543,  -543,     0,  -543,
02512     -543,     0,  -543,  -543,  -543,  -543,  -543,  -543,  -543,  -543,
02513     -543,     0,     0,     0,     0,     0,   -99,     0,     0,     0,
02514        0,     0,     0,     0,  -545,  -545,  -545,     0,  -545,  -543,
02515     -543,  -543,  -545,  -545,     0,     0,     0,  -545,     0,  -545,
02516     -545,  -545,  -545,  -545,  -545,  -545,     0,     0,     0,  -543,
02517        0,  -545,  -545,  -545,  -545,  -545,  -545,  -545,     0,     0,
02518     -545,     0,     0,     0,     0,     0,     0,  -545,     0,     0,
02519     -545,  -545,  -545,  -545,  -545,  -545,  -545,  -545,  -545,  -545,
02520     -545,  -545,     0,  -545,  -545,  -545,     0,  -545,  -545,     0,
02521        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02522        0,     0,     0,     0,     0,     0,     0,  -545,     0,     0,
02523     -545,  -545,     0,  -545,  -545,     0,  -545,  -545,  -545,  -545,
02524     -545,  -545,  -545,  -545,  -545,     0,     0,     0,     0,     0,
02525        0,     0,     0,     0,     0,     0,     0,     0,  -546,  -546,
02526     -546,     0,  -546,  -545,  -545,  -545,  -546,  -546,     0,     0,
02527        0,  -546,     0,  -546,  -546,  -546,  -546,  -546,  -546,  -546,
02528        0,     0,     0,  -545,     0,  -546,  -546,  -546,  -546,  -546,
02529     -546,  -546,     0,     0,  -546,     0,     0,     0,     0,     0,
02530        0,  -546,     0,     0,  -546,  -546,  -546,  -546,  -546,  -546,
02531     -546,  -546,  -546,  -546,  -546,  -546,     0,  -546,  -546,  -546,
02532        0,  -546,  -546,     0,     0,     0,     0,     0,     0,     0,
02533        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02534        0,  -546,     0,     0,  -546,  -546,     0,  -546,  -546,     0,
02535     -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,  -546,     0,
02536        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02537        0,     0,     0,     0,     0,     0,     0,  -546,  -546,  -546,
02538        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02539        0,     0,     0,     0,     0,     0,     0,  -546,   111,   112,
02540      113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
02541      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02542      133,   134,     0,     0,     0,   135,   136,   137,   138,   139,
02543      140,   141,   142,   143,   144,     0,     0,     0,     0,     0,
02544      145,   146,   147,   148,   149,   150,   151,   152,   153,   266,
02545      267,   154,   268,     0,     0,     0,     0,     0,     0,     0,
02546        0,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02547        0,     0,   164,   165,     0,     0,   166,   167,   168,   169,
02548        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02549      170,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02550        0,     0,     0,     0,     0,     0,     0,   171,   172,   173,
02551      174,   175,   176,   177,   178,   179,   180,     0,   181,   182,
02552        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02553        0,     0,     0,     0,     0,     0,   183,   111,   112,   113,
02554      114,   115,   116,   117,   118,   119,   120,   121,   122,   123,
02555      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
02556      134,     0,     0,     0,   135,   136,   137,   138,   139,   140,
02557      141,   142,   143,   144,     0,     0,     0,     0,     0,   145,
02558      146,   147,   148,   149,   150,   151,   152,   153,   223,     0,
02559      154,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02560      155,   156,   157,   158,   159,   160,   161,   162,   163,     0,
02561        0,   164,   165,     0,     0,   166,   167,   168,   169,     0,
02562        0,     0,     0,     0,     0,     0,     0,     0,     0,   170,
02563        0,     0,    55,     0,     0,     0,     0,     0,     0,     0,
02564        0,     0,     0,     0,     0,     0,   171,   172,   173,   174,
02565      175,   176,   177,   178,   179,   180,     0,   181,   182,     0,
02566        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02567        0,     0,     0,     0,     0,   183,   111,   112,   113,   114,
02568      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
02569      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
02570        0,     0,     0,   135,   136,   137,   138,   139,   140,   141,
02571      142,   143,   144,     0,     0,     0,     0,     0,   145,   146,
02572      147,   148,   149,   150,   151,   152,   153,     0,     0,   154,
02573        0,     0,     0,     0,     0,     0,     0,     0,     0,   155,
02574      156,   157,   158,   159,   160,   161,   162,   163,     0,     0,
02575      164,   165,     0,     0,   166,   167,   168,   169,     0,     0,
02576        0,     0,     0,     0,     0,     0,     0,     0,   170,     0,
02577        0,    55,     0,     0,     0,     0,     0,     0,     0,     0,
02578        0,     0,     0,     0,     0,   171,   172,   173,   174,   175,
02579      176,   177,   178,   179,   180,     0,   181,   182,     0,     0,
02580        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02581        0,     0,     0,     0,   183,   111,   112,   113,   114,   115,
02582      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
02583      126,   127,   128,   129,   130,   131,   132,   133,   134,     0,
02584        0,     0,   135,   136,   137,   138,   139,   140,   141,   142,
02585      143,   144,     0,     0,     0,     0,     0,   145,   146,   147,
02586      148,   149,   150,   151,   152,   153,     0,     0,   154,     0,
02587        0,     0,     0,     0,     0,     0,     0,     0,   155,   156,
02588      157,   158,   159,   160,   161,   162,   163,     0,     0,   164,
02589      165,     0,     0,   166,   167,   168,   169,     0,     0,     0,
02590        0,     0,     0,     0,     0,     0,     0,   170,     0,     0,
02591        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02592        0,     0,     0,     0,   171,   172,   173,   174,   175,   176,
02593      177,   178,   179,   180,     0,   181,   182,     0,     0,     5,
02594        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02595        0,     0,    12,   183,    13,    14,    15,   228,   229,    18,
02596       19,     0,     0,     0,     0,     0,   230,   231,   232,    23,
02597       24,    25,    26,     0,     0,   192,     0,     0,     0,     0,
02598        0,     0,   255,     0,     0,    32,    33,    34,    35,    36,
02599       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02600       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02601        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02602        0,     0,   256,     0,     0,   195,    50,     0,    51,    52,
02603        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02604        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02605        0,     5,     6,     7,     0,     9,     0,     0,   257,    10,
02606       11,     0,     0,     0,    12,     0,    13,    14,    15,   228,
02607      229,    18,    19,     0,     0,     0,   258,     0,   230,   231,
02608      232,    23,    24,    25,    26,     0,     0,   192,     0,     0,
02609        0,     0,     0,     0,   255,     0,     0,    32,    33,    34,
02610       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02611       43,    44,    45,     0,     0,     0,     0,     0,     0,     0,
02612        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02613        0,     0,     0,     0,   256,     0,     0,   195,    50,     0,
02614       51,    52,     0,     0,     0,    54,    55,    56,    57,    58,
02615       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02616        0,     0,     0,     5,     6,     7,     8,     9,     0,     0,
02617      257,    10,    11,     0,     0,     0,    12,     0,    13,    14,
02618       15,    16,    17,    18,    19,     0,     0,     0,   482,     0,
02619       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02620        0,     0,     0,     0,     0,    28,    29,    30,    31,    32,
02621       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02622       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02623        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02624        0,     0,     0,     0,     0,     0,    48,     0,     0,    49,
02625       50,     0,    51,    52,     0,    53,     0,    54,    55,    56,
02626       57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
02627        0,     0,     5,     6,     7,     8,     9,     0,     0,     0,
02628       10,    11,    61,    62,    63,    12,     0,    13,    14,    15,
02629       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02630       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02631        0,     0,     0,     0,    28,    29,     0,    31,    32,    33,
02632       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02633        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02634        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02635        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02636        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02637       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02638        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02639       11,    61,    62,    63,    12,     0,    13,    14,    15,    16,
02640       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02641       22,    23,    24,    25,    26,     0,     0,   192,     0,     0,
02642        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02643       35,    36,    37,    38,    39,    40,   193,    41,    42,     0,
02644       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02645        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02646        0,     0,     0,     0,   194,     0,     0,   195,    50,     0,
02647       51,    52,     0,   196,   197,    54,    55,    56,    57,    58,
02648       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02649        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02650       61,   198,    63,    12,     0,    13,    14,    15,   228,   229,
02651       18,    19,     0,     0,     0,     0,     0,   230,   231,   232,
02652       23,    24,    25,    26,     0,     0,   192,     0,     0,     0,
02653        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02654       36,    37,    38,    39,    40,   193,    41,    42,     0,    43,
02655       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02656        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02657        0,     0,     0,   194,     0,     0,   195,    50,     0,    51,
02658       52,     0,   577,   197,    54,    55,    56,    57,    58,    59,
02659       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02660        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02661      198,    63,    12,     0,    13,    14,    15,   228,   229,    18,
02662       19,     0,     0,     0,     0,     0,   230,   231,   232,    23,
02663       24,    25,    26,     0,     0,   192,     0,     0,     0,     0,
02664        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02665       37,    38,    39,    40,   193,    41,    42,     0,    43,    44,
02666       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02667        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02668        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02669        0,   196,     0,    54,    55,    56,    57,    58,    59,    60,
02670        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02671        7,     0,     9,     0,     0,     0,    10,    11,    61,   198,
02672       63,    12,     0,    13,    14,    15,   228,   229,    18,    19,
02673        0,     0,     0,     0,     0,   230,   231,   232,    23,    24,
02674       25,    26,     0,     0,   192,     0,     0,     0,     0,     0,
02675        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02676       38,    39,    40,   193,    41,    42,     0,    43,    44,    45,
02677        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02678        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02679        0,   194,     0,     0,   195,    50,     0,    51,    52,     0,
02680        0,   197,    54,    55,    56,    57,    58,    59,    60,     0,
02681        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02682        0,     9,     0,     0,     0,    10,    11,    61,   198,    63,
02683       12,     0,    13,    14,    15,   228,   229,    18,    19,     0,
02684        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02685       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02686       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02687       39,    40,   193,    41,    42,     0,    43,    44,    45,     0,
02688       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02689        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02690      194,     0,     0,   195,    50,     0,    51,    52,     0,   577,
02691        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02692        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02693        9,     0,     0,     0,    10,    11,    61,   198,    63,    12,
02694        0,    13,    14,    15,   228,   229,    18,    19,     0,     0,
02695        0,     0,     0,   230,   231,   232,    23,    24,    25,    26,
02696        0,     0,   192,     0,     0,     0,     0,     0,     0,    29,
02697        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02698       40,   193,    41,    42,     0,    43,    44,    45,     0,    46,
02699       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02700        0,     0,     0,     0,     0,     0,     0,     0,     0,   194,
02701        0,     0,   195,    50,     0,    51,    52,     0,     0,     0,
02702       54,    55,    56,    57,    58,    59,    60,     0,     0,     0,
02703        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02704        0,     0,     0,    10,    11,    61,   198,    63,    12,     0,
02705       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02706        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02707        0,   192,     0,     0,     0,     0,     0,     0,    29,     0,
02708        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02709        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02710        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02711        0,     0,     0,     0,     0,     0,     0,     0,   194,     0,
02712        0,   195,    50,     0,    51,    52,     0,   476,     0,    54,
02713       55,    56,    57,    58,    59,    60,     0,     0,     0,     0,
02714        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
02715        0,     0,    10,    11,    61,   198,    63,    12,     0,    13,
02716       14,    15,   228,   229,    18,    19,     0,     0,     0,     0,
02717        0,   230,   231,   232,    23,    24,    25,    26,     0,     0,
02718      192,     0,     0,     0,     0,     0,     0,    29,     0,     0,
02719       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02720       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02721        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02722        0,     0,     0,     0,     0,     0,     0,   194,     0,     0,
02723      195,    50,     0,    51,    52,     0,   196,     0,    54,    55,
02724       56,    57,    58,    59,    60,     0,     0,     0,     0,     0,
02725        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02726        0,    10,    11,    61,   198,    63,    12,     0,    13,    14,
02727       15,   228,   229,    18,    19,     0,     0,     0,     0,     0,
02728      230,   231,   232,    23,    24,    25,    26,     0,     0,   192,
02729        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02730       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02731       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02732        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02733        0,     0,     0,     0,     0,     0,   194,     0,     0,   195,
02734       50,     0,    51,    52,     0,   758,     0,    54,    55,    56,
02735       57,    58,    59,    60,     0,     0,     0,     0,     0,     0,
02736        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02737       10,    11,    61,   198,    63,    12,     0,    13,    14,    15,
02738      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02739      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02740        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02741       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02742        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02743        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02744        0,     0,     0,     0,     0,   194,     0,     0,   195,    50,
02745        0,    51,    52,     0,   476,     0,    54,    55,    56,    57,
02746       58,    59,    60,     0,     0,     0,     0,     0,     0,     0,
02747        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02748       11,    61,   198,    63,    12,     0,    13,    14,    15,   228,
02749      229,    18,    19,     0,     0,     0,     0,     0,   230,   231,
02750      232,    23,    24,    25,    26,     0,     0,   192,     0,     0,
02751        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02752       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02753       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02754        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02755        0,     0,     0,     0,   194,     0,     0,   195,    50,     0,
02756       51,    52,     0,   577,     0,    54,    55,    56,    57,    58,
02757       59,    60,     0,     0,     0,     0,     0,     0,     0,     0,
02758        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02759       61,   198,    63,    12,     0,    13,    14,    15,   228,   229,
02760       18,    19,     0,     0,     0,     0,     0,   230,   231,   232,
02761       23,    24,    25,    26,     0,     0,   192,     0,     0,     0,
02762        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02763       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02764       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02765        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02766        0,     0,     0,   194,     0,     0,   195,    50,     0,    51,
02767       52,     0,     0,     0,    54,    55,    56,    57,    58,    59,
02768       60,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02769        6,     7,     0,     9,     0,     0,     0,    10,    11,    61,
02770      198,    63,    12,     0,    13,    14,    15,    16,    17,    18,
02771       19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
02772       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02773        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02774       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02775       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02776        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02777        0,     0,   194,     0,     0,   195,    50,     0,    51,    52,
02778        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02779        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02780        7,     0,     9,     0,     0,     0,    10,    11,    61,    62,
02781       63,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02782        0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02783       25,    26,     0,     0,   192,     0,     0,     0,     0,     0,
02784        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02785       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02786        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02787        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02788        0,   194,     0,     0,   195,    50,     0,    51,    52,     0,
02789        0,     0,    54,    55,    56,    57,    58,    59,    60,     0,
02790        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02791        0,     9,     0,     0,     0,    10,    11,    61,   198,    63,
02792       12,     0,    13,    14,    15,   228,   229,    18,    19,     0,
02793        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02794       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02795      255,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02796       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02797        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02798        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02799      256,     0,     0,   300,    50,     0,    51,    52,     0,   301,
02800        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02801        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02802       10,    11,     0,     0,     0,    12,   257,    13,    14,    15,
02803      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02804      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02805        0,     0,     0,     0,     0,   255,     0,     0,    32,    33,
02806       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02807        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02808        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02809        0,     0,     0,     0,     0,   342,     0,     0,    49,    50,
02810        0,    51,    52,     0,    53,     0,    54,    55,    56,    57,
02811       58,    59,    60,     0,     0,     0,     0,     5,     6,     7,
02812        0,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02813       12,   257,    13,    14,    15,   228,   229,    18,    19,     0,
02814        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02815       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02816      255,     0,     0,    32,    33,    34,   349,    36,    37,    38,
02817      350,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02818        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02819        0,     0,     0,     0,     0,     0,     0,   351,     0,     0,
02820      352,     0,     0,   195,    50,     0,    51,    52,     0,     0,
02821        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02822        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02823       10,    11,     0,     0,     0,    12,   257,    13,    14,    15,
02824      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02825      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02826        0,     0,     0,     0,     0,   255,     0,     0,    32,    33,
02827       34,   349,    36,    37,    38,   350,    40,     0,    41,    42,
02828        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02829        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02830        0,     0,     0,     0,     0,   352,     0,     0,   195,    50,
02831        0,    51,    52,     0,     0,     0,    54,    55,    56,    57,
02832       58,    59,    60,     0,     0,     0,     0,     5,     6,     7,
02833        0,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02834       12,   257,    13,    14,    15,   228,   229,    18,    19,     0,
02835        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02836       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02837      255,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02838       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02839        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02840        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02841      256,     0,     0,   300,    50,     0,    51,    52,     0,     0,
02842        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02843        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02844       10,    11,     0,     0,     0,    12,   257,    13,    14,    15,
02845      228,   229,    18,    19,     0,     0,     0,     0,     0,   230,
02846      231,   232,    23,    24,    25,    26,     0,     0,   192,     0,
02847        0,     0,     0,     0,     0,   255,     0,     0,    32,    33,
02848       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02849        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
02850        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02851        0,     0,     0,     0,     0,   887,     0,     0,   195,    50,
02852        0,    51,    52,     0,     0,     0,    54,    55,    56,    57,
02853       58,    59,    60,     0,     0,     0,     0,     5,     6,     7,
02854        0,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02855       12,   257,    13,    14,    15,   228,   229,    18,    19,     0,
02856        0,     0,     0,     0,   230,   231,   232,    23,    24,    25,
02857       26,     0,     0,   192,     0,     0,     0,     0,     0,     0,
02858      255,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02859       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02860        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02861        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02862      897,     0,     0,   195,    50,     0,    51,    52,     0,     0,
02863        0,    54,    55,    56,    57,    58,    59,    60,     0,     0,
02864        0,     0,     0,   584,   524,     0,     0,   585,     0,     0,
02865        0,     0,     0,     0,     0,     0,   257,   155,   156,   157,
02866      158,   159,   160,   161,   162,   163,     0,     0,   164,   165,
02867        0,     0,   166,   167,   168,   169,     0,     0,     0,     0,
02868        0,     0,     0,     0,     0,     0,   170,     0,     0,     0,
02869        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02870        0,     0,     0,   171,   172,   173,   174,   175,   176,   177,
02871      178,   179,   180,     0,   181,   182,     0,     0,     0,     0,
02872      605,   516,     0,     0,   606,     0,     0,     0,     0,     0,
02873        0,     0,   183,   217,   155,   156,   157,   158,   159,   160,
02874      161,   162,   163,     0,     0,   164,   165,     0,     0,   166,
02875      167,   168,   169,     0,     0,     0,     0,     0,     0,     0,
02876        0,     0,     0,   170,     0,     0,     0,     0,     0,     0,
02877        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02878      171,   172,   173,   174,   175,   176,   177,   178,   179,   180,
02879        0,   181,   182,     0,     0,     0,     0,   608,   524,     0,
02880        0,   609,     0,     0,     0,     0,     0,     0,     0,   183,
02881      217,   155,   156,   157,   158,   159,   160,   161,   162,   163,
02882        0,     0,   164,   165,     0,     0,   166,   167,   168,   169,
02883        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02884      170,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02885        0,     0,     0,     0,     0,     0,     0,   171,   172,   173,
02886      174,   175,   176,   177,   178,   179,   180,     0,   181,   182,
02887        0,     0,     0,     0,   679,   516,     0,     0,   680,     0,
02888        0,     0,     0,     0,     0,     0,   183,   217,   155,   156,
02889      157,   158,   159,   160,   161,   162,   163,     0,     0,   164,
02890      165,     0,     0,   166,   167,   168,   169,     0,     0,     0,
02891        0,     0,     0,     0,     0,     0,     0,   170,     0,     0,
02892        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02893        0,     0,     0,     0,   171,   172,   173,   174,   175,   176,
02894      177,   178,   179,   180,     0,   181,   182,     0,     0,     0,
02895        0,   682,   524,     0,     0,   683,     0,     0,     0,     0,
02896        0,     0,     0,   183,   217,   155,   156,   157,   158,   159,
02897      160,   161,   162,   163,     0,     0,   164,   165,     0,     0,
02898      166,   167,   168,   169,     0,     0,     0,     0,     0,     0,
02899        0,     0,     0,     0,   170,     0,     0,     0,     0,     0,
02900        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02901        0,   171,   172,   173,   174,   175,   176,   177,   178,   179,
02902      180,     0,   181,   182,     0,     0,     0,     0,   689,   516,
02903        0,     0,   690,     0,     0,     0,     0,     0,     0,     0,
02904      183,   217,   155,   156,   157,   158,   159,   160,   161,   162,
02905      163,     0,     0,   164,   165,     0,     0,   166,   167,   168,
02906      169,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02907        0,   170,     0,     0,     0,     0,     0,     0,     0,     0,
02908        0,     0,     0,     0,     0,     0,     0,     0,   171,   172,
02909      173,   174,   175,   176,   177,   178,   179,   180,     0,   181,
02910      182,     0,     0,     0,     0,   562,   524,     0,     0,   563,
02911        0,     0,     0,     0,     0,     0,     0,   183,   217,   155,
02912      156,   157,   158,   159,   160,   161,   162,   163,     0,     0,
02913      164,   165,     0,     0,   166,   167,   168,   169,     0,     0,
02914        0,     0,     0,     0,     0,     0,     0,     0,   170,     0,
02915        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02916        0,     0,     0,     0,     0,   171,   172,   173,   174,   175,
02917      176,   177,   178,   179,   180,     0,   181,   182,     0,     0,
02918        0,     0,   949,   516,     0,     0,   950,     0,     0,     0,
02919        0,     0,     0,     0,   183,   217,   155,   156,   157,   158,
02920      159,   160,   161,   162,   163,     0,     0,   164,   165,     0,
02921        0,   166,   167,   168,   169,     0,     0,     0,     0,     0,
02922        0,     0,     0,     0,     0,   170,     0,     0,     0,     0,
02923        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02924        0,     0,   171,   172,   173,   174,   175,   176,   177,   178,
02925      179,   180,     0,   181,   182,     0,     0,     0,     0,   955,
02926      516,     0,     0,   956,     0,     0,     0,     0,     0,     0,
02927        0,   183,   217,   155,   156,   157,   158,   159,   160,   161,
02928      162,   163,     0,     0,   164,   165,     0,     0,   166,   167,
02929      168,   169,     0,     0,     0,     0,     0,     0,     0,     0,
02930        0,     0,   170,     0,     0,     0,     0,     0,     0,     0,
02931        0,     0,     0,     0,     0,     0,     0,     0,     0,   171,
02932      172,   173,   174,   175,   176,   177,   178,   179,   180,     0,
02933      181,   182,     0,     0,     0,     0,   958,   524,     0,     0,
02934      959,     0,     0,     0,     0,     0,     0,     0,   183,   217,
02935      155,   156,   157,   158,   159,   160,   161,   162,   163,     0,
02936        0,   164,   165,     0,     0,   166,   167,   168,   169,     0,
02937        0,     0,     0,     0,     0,     0,     0,     0,     0,   170,
02938        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02939        0,     0,     0,     0,     0,     0,   171,   172,   173,   174,
02940      175,   176,   177,   178,   179,   180,     0,   181,   182,     0,
02941        0,     0,     0,   562,   524,     0,     0,   563,     0,     0,
02942        0,     0,     0,     0,     0,   183,   217,   155,   156,   157,
02943      158,   159,   160,   161,   162,   163,     0,     0,   164,   165,
02944        0,     0,   166,   167,   168,   169,     0,     0,     0,     0,
02945        0,     0,     0,     0,     0,     0,   170,     0,     0,     0,
02946        0,     0,     0,     0,   705,     0,     0,     0,     0,     0,
02947        0,     0,     0,   171,   172,   173,   174,   175,   176,   177,
02948      178,   179,   180,   650,   181,   182,     0,     0,   304,   305,
02949      306,   307,   308,   309,   310,   311,   312,   313,   314,   315,
02950      316,     0,   183,   317,   318,     0,     0,   304,   305,   306,
02951      307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
02952        0,     0,   317,   318,     0,     0,     0,     0,     0,     0,
02953      319,     0,   320,   321,   322,   323,   324,   325,   326,   327,
02954      328,   329,     0,     0,     0,     0,     0,     0,     0,   319,
02955        0,   320,   321,   322,   323,   324,   325,   326,   327,   328,
02956      329
02957 };
02958 
02959 #define yypact_value_is_default(yystate) \
02960   ((yystate) == (-778))
02961 
02962 #define yytable_value_is_error(yytable_value) \
02963   ((yytable_value) == (-566))
02964 
02965 static const yytype_int16 yycheck[] =
02966 {
02967        2,    16,    17,    55,     2,    20,     4,    51,    28,    75,
02968       51,    52,   446,   336,   210,     8,    49,   537,    16,    17,
02969      303,     8,    20,    27,   536,    29,   556,    53,    83,   583,
02970      446,    86,   249,   331,    65,    28,   253,     4,    90,   442,
02971        8,    28,   748,   272,    13,   274,   352,   276,    49,    51,
02972       52,    49,    50,   607,    86,    53,   735,   667,   813,   836,
02973       28,   671,   641,   811,    62,   732,   615,     1,    22,    27,
02974       16,    17,    29,    50,    20,    25,   330,    75,   332,   482,
02975       53,   566,   567,    62,    82,    83,    26,    55,    86,    87,
02976       88,    89,   728,    13,    13,    61,   394,    25,    22,    13,
02977       61,    85,    75,   239,    76,    82,    83,    37,    38,    86,
02978      140,   398,   390,   749,    87,    88,    89,   147,   372,   373,
02979      398,    85,    90,   871,   558,    87,    85,   681,    65,   109,
02980       15,    13,    17,     0,    25,    25,   147,    13,   692,   393,
02981      106,   395,   114,   104,   105,   432,   444,   109,   925,    86,
02982      107,    25,    56,   732,   108,   139,   735,    25,   688,   914,
02983      140,     2,   195,     4,   300,   419,   696,   834,   916,    25,
02984      140,   140,    25,   722,   723,   139,   145,   147,   147,   113,
02985      139,    59,    60,   889,   108,   146,   620,   145,    85,   147,
02986      140,   445,   258,   655,   227,   943,   136,   195,   877,   214,
02987      662,   216,   217,   205,   620,   136,   239,   641,   210,   241,
02988      241,   145,   140,   147,   881,   217,   214,   147,   216,   217,
02989      146,   706,   220,   142,   222,   145,   145,   147,   147,   227,
02990      459,   145,    26,   147,   289,   290,   291,   292,   239,   146,
02991      238,   239,   139,   220,   542,   222,   649,   553,   858,   140,
02992      140,   255,   142,    25,   298,   834,   554,   836,    28,   303,
02993      258,   695,   811,   145,   813,   147,   140,   300,   214,   145,
02994      216,   147,   140,    99,   142,   301,   109,    26,   232,   695,
02995      792,   235,   337,   338,   140,   258,    25,   140,    87,   543,
02996      288,   289,   290,   291,   292,   293,   294,   295,   877,   300,
02997      298,   555,   300,   301,   241,   303,   142,   339,   220,    85,
02998      109,   147,   289,   290,   291,   292,   331,   294,   295,   298,
02999      140,   288,   871,   872,   303,    37,    38,    26,   301,   331,
03000      860,   243,   145,   331,   147,   333,    85,   109,   858,   337,
03001      338,   140,   136,   109,    85,    87,   925,    26,   142,   390,
03002       87,    85,   140,   351,   677,    87,    85,   142,    85,    56,
03003      337,   338,   330,   139,    26,   914,   109,   916,   140,    87,
03004      109,   143,   109,    88,   351,   147,   442,   109,   332,   394,
03005      378,   379,   912,   666,   580,   602,    85,   136,   429,   138,
03006      139,   109,   394,   413,   943,    85,   394,   238,   139,   378,
03007      379,   140,   339,   957,   143,   139,    85,    85,   147,   138,
03008      139,   138,   139,   142,   416,    52,   482,   354,   416,    56,
03009      413,   140,   140,    85,    87,   393,   413,   425,    85,   444,
03010      140,   865,    85,    85,    59,    60,    85,   136,   142,   138,
03011      139,   395,   444,   142,   442,   413,   444,   288,   138,   139,
03012      418,   136,   293,   142,    85,    14,    15,   136,    85,   138,
03013      139,   139,    85,   142,    68,   419,   564,   565,    85,   442,
03014      142,    85,   143,   475,   136,   443,   138,   139,    85,   109,
03015      142,   138,   139,   144,   482,   138,   139,   139,   400,   138,
03016      139,   445,   404,   137,   538,   407,    85,    87,    56,   532,
03017      504,   534,    52,   106,    54,    55,    56,    57,   139,   482,
03018      422,   138,   139,   106,    85,   427,   139,    85,   522,   109,
03019      641,   138,   139,   846,   138,   139,   528,   542,   530,   852,
03020      140,   138,   139,    87,   532,    87,   534,   603,    87,   554,
03021      542,    68,    68,    52,   542,    54,    55,    56,    57,   138,
03022      139,    17,   554,   140,   574,   109,   554,   109,   556,   557,
03023      109,   145,   564,   565,   566,   567,   520,   138,   139,   481,
03024      138,   139,    56,   541,   528,   416,    61,    94,   580,   583,
03025      557,   574,    68,   649,   425,   553,   140,   574,   140,   543,
03026      140,   140,    52,    25,   592,   597,   520,   143,   535,   536,
03027      137,   555,   140,   607,   528,   603,   574,   140,   140,   642,
03028      564,   565,   549,    61,   735,   592,    87,   738,   146,   104,
03029      105,   106,   666,    87,   626,    87,   628,   140,   630,   684,
03030      603,   140,   687,   119,   120,   121,   140,   935,   109,   641,
03031      564,   565,   596,   597,   642,   109,   698,   109,    61,    10,
03032       68,   649,     8,    54,   652,   653,   104,   105,   106,    13,
03033      658,   659,    63,    64,   666,   667,   109,   669,    61,   671,
03034      703,   704,   137,   652,   653,    52,   649,   681,   140,   658,
03035      659,    61,   936,   140,   140,    65,   684,   140,   692,   687,
03036      688,   104,   105,   106,    52,   140,   729,   730,   696,   117,
03037      118,   119,   120,   121,   706,   703,   704,   684,   741,   111,
03038      687,   104,   105,   106,   144,   836,    15,   838,    52,   140,
03039       54,    55,    56,    57,   104,   105,   728,   782,   145,   114,
03040      698,   729,   730,   193,   109,   140,   196,   197,    40,    41,
03041       42,    43,    44,   741,   140,   140,   779,   749,   685,   751,
03042       10,   753,   754,   786,   787,    89,   877,   790,   879,   140,
03043      697,    95,   883,    88,    16,    17,     9,   137,    20,    10,
03044       10,   769,   140,   806,   137,   777,    54,    55,   780,    57,
03045      140,   779,   694,   140,   782,    63,    64,   140,   786,   787,
03046      769,   140,   790,   137,    46,    47,   114,   140,   140,    51,
03047       52,   137,   140,   715,   925,   782,   927,    56,   806,   930,
03048       62,    63,   140,   140,   726,   416,   849,   819,   820,   140,
03049      822,    56,   824,   825,   945,   140,   140,   140,    87,   827,
03050      142,    52,   142,    54,    55,    56,    57,   539,   298,    89,
03051      889,   938,   722,   303,    92,   937,   967,   845,    95,    57,
03052       -1,   849,    90,   865,   827,   792,   858,   794,    68,   834,
03053      732,    52,   860,    54,    55,    56,    57,    -1,    89,   902,
03054       -1,   904,   845,    83,    84,    96,    -1,   910,    52,    -1,
03055       54,    55,    56,    57,    -1,    -1,    -1,   799,    -1,   891,
03056      892,   893,    -1,   895,   896,   116,    -1,    52,   810,    54,
03057       55,    56,    57,   815,   902,    -1,   904,   117,   118,   119,
03058      120,   121,   910,    -1,   912,    89,   918,   919,   920,   921,
03059      935,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   389,
03060      390,    -1,    -1,   935,    89,   937,   938,   935,   398,    -1,
03061       -1,   193,    -1,    -1,   196,   197,   198,    -1,    -1,   951,
03062      952,   953,   954,   957,    -1,   923,    52,    -1,    54,    55,
03063       56,    57,   214,   965,   216,   217,   934,    -1,    -1,   429,
03064       -1,   973,   432,    -1,   676,    52,    -1,    54,    55,    56,
03065       57,    -1,   936,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03066       -1,   693,    -1,    89,    -1,    -1,    -1,    -1,    -1,    95,
03067       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03068       -1,    -1,    89,    -1,    -1,    -1,   476,    -1,    95,    96,
03069      116,    -1,    -1,   119,    -1,    -1,    -1,    -1,    -1,    -1,
03070       -1,    -1,    -1,     2,    -1,     4,    -1,    -1,    -1,   116,
03071       -1,    -1,   119,    -1,    -1,    -1,   298,    -1,    -1,   145,
03072       -1,   303,   304,   305,   306,   307,   308,   309,   310,   311,
03073      312,   313,   314,   315,   316,   317,   318,   319,   320,   321,
03074      322,   323,   324,   325,   326,   327,   328,   329,   538,   331,
03075       49,   783,    -1,   785,    53,    52,    -1,    54,    55,    56,
03076       57,    -1,    -1,   795,    -1,    -1,    -1,    -1,   800,    -1,
03077       -1,    -1,    -1,    -1,    -1,    -1,    75,    -1,    -1,    -1,
03078       -1,     2,    -1,     4,    -1,    -1,    -1,   577,    87,    88,
03079       89,    90,    89,    -1,    -1,    -1,   378,   379,    95,    96,
03080       -1,    -1,    -1,    -1,    -1,    -1,   388,   389,   390,    -1,
03081       -1,    -1,   394,    -1,   396,   397,   398,    -1,    -1,   116,
03082       -1,    -1,   119,   855,   856,    -1,    -1,    -1,    49,   628,
03083       -1,   630,    53,   415,    -1,    -1,    68,    52,   420,    54,
03084       55,    56,    57,    -1,    -1,   142,    -1,   429,    -1,    -1,
03085      432,    83,    84,     2,    75,     4,   646,    -1,    -1,    -1,
03086       -1,    -1,   444,    -1,    -1,    -1,    87,    88,    89,    -1,
03087        2,    -1,     4,    -1,    89,    -1,   666,    -1,    -1,   911,
03088       95,    96,   464,   465,   116,   117,   118,   119,   120,   121,
03089       -1,    -1,    -1,    -1,   476,    -1,   195,    -1,    -1,    -1,
03090       49,   116,    -1,    -1,   119,     0,    -1,   939,    -1,   941,
03091       -1,    -1,    -1,     8,     9,    10,    -1,    49,    13,    14,
03092       15,    52,    17,    54,    55,    56,    57,   142,   227,    -1,
03093      720,    -1,    27,    -1,    -1,    -1,    -1,    -1,    87,   238,
03094      239,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
03095       -1,    -1,   751,    -1,   753,   754,   538,    -1,    89,   258,
03096      542,    68,    -1,    -1,    95,    96,    -1,    -1,   758,    -1,
03097       -1,    -1,   554,    -1,   195,    -1,    83,    84,    -1,    -1,
03098       -1,    -1,    -1,    -1,    -1,   116,    -1,    -1,   119,   288,
03099       85,    -1,    -1,    -1,   293,   577,    -1,    -1,    -1,   789,
03100       -1,   300,   301,    -1,    -1,    -1,   227,   114,   115,   116,
03101      117,   118,   119,   120,   121,    -1,    -1,   238,   239,    -1,
03102      819,   820,    -1,   822,    -1,   824,   825,    -1,    -1,    -1,
03103       -1,    -1,    -1,    -1,   333,    -1,    -1,   258,    -1,    -1,
03104       -1,    -1,   137,    -1,   139,    -1,   195,   142,   143,    -1,
03105      145,    -1,   147,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03106       -1,    -1,    -1,   195,   646,    -1,    -1,   288,   650,    -1,
03107      652,   653,   293,    -1,    -1,    -1,   658,   659,   227,   300,
03108      301,    -1,    -1,    -1,   666,    -1,    -1,    -1,    -1,   238,
03109      239,    -1,   891,   892,   893,   227,   895,   896,    -1,    -1,
03110       -1,    -1,    -1,    -1,    -1,    -1,   238,   239,    -1,    -1,
03111       -1,    -1,   333,    -1,    -1,    -1,    -1,   416,    -1,   918,
03112      919,   920,   921,   705,    -1,    -1,   425,    -1,   710,   711,
03113       -1,   713,   714,    -1,    -1,    -1,    -1,    -1,   720,   288,
03114       -1,    -1,    -1,   442,   293,    -1,    -1,    -1,    -1,    -1,
03115       -1,   300,   951,   952,   953,   954,   288,    -1,    -1,    -1,
03116       -1,   293,    -1,    -1,    -1,    -1,   965,    -1,   300,    -1,
03117       -1,    -1,    -1,    -1,   973,    -1,   758,    -1,    -1,    -1,
03118      762,    -1,    -1,   482,   333,    -1,    -1,   769,    -1,    -1,
03119       -1,    -1,    -1,    -1,    -1,   416,    -1,    -1,    -1,    -1,
03120       -1,   333,    -1,    -1,   425,    -1,    -1,   789,    -1,    -1,
03121       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03122       -1,   442,    -1,    -1,    -1,   807,    -1,    -1,    -1,    -1,
03123       -1,    -1,    -1,   532,    -1,   534,    -1,    -1,    -1,    -1,
03124       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03125       68,    69,    70,    71,    72,    73,    74,   556,    -1,    77,
03126       78,   482,    -1,    -1,    -1,    83,    84,   416,    -1,    -1,
03127       -1,    -1,    -1,    -1,    -1,    -1,   425,    -1,    -1,    -1,
03128       -1,    -1,    -1,    -1,   416,    -1,    -1,    -1,    -1,    -1,
03129       44,    -1,    -1,   425,   112,   113,   114,   115,   116,   117,
03130      118,   119,   120,   121,   603,    -1,    -1,    -1,    -1,    -1,
03131       -1,   532,    -1,   534,    68,    69,    70,    71,    72,    73,
03132       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03133       84,    -1,    -1,    -1,    -1,   556,    -1,    -1,    -1,    -1,
03134       -1,    -1,    -1,   642,    -1,    -1,    -1,    -1,    -1,    -1,
03135      649,    -1,    -1,   935,    -1,    -1,   110,    -1,   112,   113,
03136      114,   115,   116,   117,   118,   119,   120,   121,    -1,    -1,
03137       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03138       -1,    -1,   603,   532,    -1,   534,   140,    -1,    -1,   688,
03139       -1,    -1,    -1,    -1,    -1,    -1,    -1,   696,    -1,    -1,
03140      532,    -1,   534,    -1,   703,   704,    -1,   556,    -1,    -1,
03141       -1,    -1,    -1,   634,    -1,    -1,    -1,    -1,    -1,    -1,
03142       -1,   642,    -1,    -1,   556,    -1,    -1,    -1,   649,    -1,
03143      729,   730,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,
03144       -1,    -1,   741,    -1,    -1,    -1,    -1,    -1,    66,    67,
03145       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03146       78,    -1,    -1,    81,    82,    83,    84,   688,    -1,    -1,
03147       -1,    -1,    -1,    -1,    -1,   696,    -1,    95,    -1,    -1,
03148      779,    -1,   703,   704,    -1,    -1,    -1,   786,   787,    -1,
03149       -1,   790,    -1,   642,   112,   113,   114,   115,   116,   117,
03150      118,   119,   120,   121,    -1,   123,   124,   806,   729,   730,
03151      642,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03152      741,    -1,    -1,   141,   142,    -1,    -1,    -1,   827,    -1,
03153       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   688,
03154       -1,    -1,    -1,    -1,    -1,    -1,   845,   696,    -1,    -1,
03155      849,    -1,    -1,    -1,   703,   704,   688,    -1,   779,    -1,
03156       -1,   860,    -1,    -1,   696,   786,   787,    -1,    -1,   790,
03157       -1,   703,   704,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03158      729,   730,    -1,    -1,    -1,   806,    -1,    -1,    -1,    -1,
03159       -1,    -1,   741,    -1,    -1,    -1,    -1,   729,   730,    -1,
03160       -1,    -1,    -1,   902,    -1,   904,   827,    -1,    -1,   741,
03161       -1,   910,    -1,   912,    -1,    -1,    -1,    68,    69,    70,
03162       71,    72,    73,    74,   845,    -1,    77,    78,   849,    -1,
03163      779,    -1,    83,    84,    -1,    -1,    -1,   786,   787,   860,
03164       -1,   790,    -1,    46,    47,    -1,    -1,   779,    51,    52,
03165       53,    -1,    -1,    -1,   786,   787,    -1,   806,   790,    -1,
03166       63,   112,   113,   114,   115,   116,   117,   118,   119,   120,
03167      121,    -1,    75,    -1,   806,    -1,    -1,    -1,    -1,    -1,
03168       -1,   902,    -1,   904,    87,    88,    89,    -1,    -1,   910,
03169       -1,   912,    -1,    -1,    -1,    -1,   845,    -1,    -1,    -1,
03170      849,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03171       -1,   860,    -1,    -1,    -1,    -1,    -1,   849,    -1,    -1,
03172       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   860,    -1,
03173       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03174       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03175       -1,    -1,    -1,   902,    -1,   904,    -1,    -1,    -1,    -1,
03176       -1,   910,    -1,   912,    -1,    -1,    -1,    -1,    -1,    -1,
03177      902,    -1,   904,    -1,    -1,    -1,    -1,    -1,   910,    -1,
03178      912,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,
03179      193,    -1,    -1,   196,   197,   198,    66,    67,    68,    69,
03180       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
03181       -1,    81,    82,    83,    84,    -1,    -1,    68,    69,    70,
03182       71,    72,    73,    74,    75,    95,    77,    78,    -1,    -1,
03183       -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
03184       -1,    -1,   112,   113,   114,   115,   116,   117,   118,   119,
03185      120,   121,    -1,   123,   124,   258,    -1,    -1,    -1,    -1,
03186       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
03187      121,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03188       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03189       74,    75,    76,    77,    78,    79,    80,    -1,   301,    83,
03190       84,   304,   305,   306,   307,   308,   309,   310,   311,   312,
03191      313,   314,   315,   316,   317,   318,   319,   320,   321,   322,
03192      323,   324,   325,   326,   327,   328,   329,    -1,   112,   113,
03193      114,   115,   116,   117,   118,   119,   120,   121,    52,    53,
03194       -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03195       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
03196       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
03197       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03198       -1,    95,    -1,    -1,    -1,   388,   389,   390,    -1,    -1,
03199       -1,    -1,    -1,   396,   397,   398,    -1,    -1,   112,   113,
03200      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
03201      124,    -1,   415,    -1,    -1,    -1,    -1,   420,    -1,    -1,
03202       -1,    -1,    -1,    -1,    -1,    -1,   429,   141,   142,   432,
03203       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   442,
03204       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03205       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03206       -1,   464,   465,    -1,     0,     1,    -1,     3,     4,     5,
03207        6,     7,    -1,   476,    -1,    11,    12,    -1,    -1,   482,
03208       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03209       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03210       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03211       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03212       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03213       66,    67,    -1,    -1,    -1,   538,    -1,    -1,    -1,    -1,
03214       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03215       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03216       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03217       -1,    -1,    -1,    -1,   577,    -1,    -1,    -1,    -1,    -1,
03218       -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,
03219       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03220      603,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,
03221       -1,   147,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03222       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03223       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03224       -1,    -1,    -1,   646,    -1,    -1,   649,   650,    -1,    -1,
03225       -1,     0,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     8,
03226        9,    10,    -1,   666,    13,    14,    15,    -1,    17,    -1,
03227       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    27,    28,
03228       29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,
03229       -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
03230       -1,    -1,   705,    -1,    -1,    -1,    -1,   710,   711,    -1,
03231      713,   714,    -1,    -1,    -1,    -1,    -1,   720,    -1,    68,
03232       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
03233       79,    80,    -1,    -1,    83,    84,    85,    -1,    87,    88,
03234       -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,    -1,    -1,
03235       -1,    -1,    -1,    -1,    -1,   758,    -1,    -1,   107,   762,
03236      109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
03237      119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03238       -1,    -1,    -1,    -1,    -1,    -1,   789,    -1,   137,   138,
03239      139,   140,     0,    -1,   143,   144,   145,    -1,   147,    -1,
03240        8,     9,    10,    -1,   807,    13,    14,    15,    -1,    17,
03241       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    26,    27,
03242       28,    -1,    -1,    -1,   827,    -1,    -1,    -1,    -1,    37,
03243       38,    -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,
03244       -1,    -1,   845,    68,    69,    70,    71,    72,    73,    74,
03245       75,    76,    77,    78,    79,    80,    -1,    -1,    83,    84,
03246       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03247       78,    79,    80,    -1,    -1,    83,    84,    85,    -1,    -1,
03248       88,    -1,    -1,    -1,    -1,   110,    94,   112,   113,   114,
03249      115,   116,   117,   118,   119,   120,   121,    -1,    -1,    -1,
03250       -1,    -1,   110,    -1,   112,   113,   114,   115,   116,   117,
03251      118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
03252       -1,    -1,   147,    -1,    -1,    -1,    -1,    -1,   136,   137,
03253      138,   139,   140,     0,   142,   143,   144,   145,    -1,   147,
03254       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03255       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03256       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03257       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03258       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03259       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03260       84,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03261       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03262       -1,    88,    -1,    -1,    -1,    -1,   110,    94,   112,   113,
03263      114,   115,   116,   117,   118,   119,   120,   121,    -1,    -1,
03264      107,    -1,    -1,   110,   111,   112,   113,   114,   115,   116,
03265      117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,
03266       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03267      137,   138,   139,   140,     0,    -1,   143,   144,   145,    -1,
03268      147,    -1,     8,     9,    10,    -1,    -1,    13,    14,    15,
03269       -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03270       26,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03271       -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
03272       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03273       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03274       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03275       76,    77,    78,    79,    80,    -1,    -1,    83,    84,    85,
03276       -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,
03277       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03278       -1,    -1,    -1,    -1,   110,    -1,   112,   113,   114,   115,
03279      116,   117,   118,   119,   120,   121,    -1,    -1,    -1,    -1,
03280       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03281      136,   137,   138,   139,   140,     0,   142,   143,   144,   145,
03282       -1,   147,    -1,     8,     9,    10,    -1,    -1,    13,    14,
03283       15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03284       -1,    -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,
03285       -1,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
03286       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03287       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03288       -1,    -1,    -1,    68,    69,    70,    71,    72,    73,    74,
03289       75,    76,    77,    78,    79,    80,    -1,    -1,    83,    84,
03290       85,    -1,    -1,    88,    -1,    -1,    -1,    -1,    -1,    94,
03291       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03292       -1,    -1,    -1,    -1,    -1,   110,    -1,   112,   113,   114,
03293      115,   116,   117,   118,   119,   120,   121,    -1,    -1,    -1,
03294       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03295       -1,    -1,   137,   138,   139,   140,     0,   142,   143,   144,
03296      145,    -1,   147,    -1,     8,     9,    10,    -1,    -1,    -1,
03297       14,    15,    -1,    17,    -1,    -1,    -1,    -1,    -1,    -1,
03298       -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03299       -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
03300       44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03301       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03302       -1,    -1,    -1,    -1,    68,    69,    70,    71,    72,    73,
03303       74,    75,    76,    77,    78,    79,    80,    -1,    -1,    83,
03304       84,    85,     0,    87,    -1,    -1,    -1,    -1,    -1,    -1,
03305        8,     9,    10,    -1,    -1,    -1,    14,    15,    -1,    17,
03306       -1,    -1,    -1,    -1,    -1,   109,   110,    -1,   112,   113,
03307      114,   115,   116,   117,   118,   119,   120,   121,    -1,    37,
03308       38,    -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,
03309       -1,    -1,   136,   137,   138,   139,   140,    -1,    -1,   143,
03310       -1,   145,    -1,   147,    -1,    -1,    -1,    -1,    -1,    -1,
03311       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03312       78,    79,    80,    -1,    -1,    83,    84,    85,    -1,    87,
03313       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03314       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03315       -1,   109,   110,    -1,   112,   113,   114,   115,   116,   117,
03316      118,   119,   120,   121,    -1,    -1,    -1,    -1,    -1,    -1,
03317       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   137,
03318      138,   139,   140,    -1,    -1,   143,    -1,   145,     1,   147,
03319        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
03320       -1,    -1,    15,    16,    -1,    18,    19,    20,    21,    22,
03321       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03322       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03323       -1,    -1,    45,    46,    -1,    48,    49,    50,    51,    52,
03324       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03325       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03326       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03327       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03328       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03329      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03330       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03331      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03332       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03333       -1,    -1,   145,     1,   147,     3,     4,     5,     6,     7,
03334       -1,    -1,    10,    11,    12,    -1,    14,    15,    16,    -1,
03335       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03336       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03337       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03338       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03339       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03340       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03341       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03342       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03343       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03344       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03345       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03346       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03347       -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,     1,   147,
03348        3,     4,     5,     6,     7,    -1,    -1,    10,    11,    12,
03349       -1,    -1,    15,    16,    17,    18,    19,    20,    21,    22,
03350       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03351       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03352       -1,    -1,    45,    46,    -1,    48,    49,    50,    51,    52,
03353       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03354       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03355       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03356       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03357       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03358      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03359       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03360      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,
03361        3,     4,     5,     6,     7,    -1,    -1,    -1,    11,    12,
03362       -1,    -1,   145,    16,   147,    18,    19,    20,    21,    22,
03363       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03364       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03365       -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
03366       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03367       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03368       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03369       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03370       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03371      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03372       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03373      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03374       -1,    -1,    -1,    -1,   137,    -1,    -1,    -1,    -1,    -1,
03375       -1,    -1,   145,     1,   147,     3,     4,     5,     6,     7,
03376       -1,    -1,    10,    11,    12,    -1,    -1,    15,    16,    -1,
03377       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03378       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03379       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03380       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03381       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03382       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03383       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03384       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03385       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03386       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03387       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03388       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03389       -1,     9,    10,    11,    12,    -1,    -1,   145,    16,   147,
03390       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03391       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03392       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03393       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03394       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03395       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03396       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03397       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03398       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03399       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03400       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03401       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03402       -1,    -1,    -1,    11,    12,    -1,    -1,   145,    16,   147,
03403       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03404       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03405       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03406       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03407       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03408       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03409       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03410       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03411       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03412       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03413       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03414       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03415       -1,    -1,    -1,    11,    12,   143,    -1,   145,    16,   147,
03416       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03417       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03418       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03419       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03420       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03421       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03422       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03423       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03424       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03425       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03426       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03427       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03428       -1,    -1,    -1,    11,    12,   143,    -1,   145,    16,   147,
03429       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03430       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03431       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,
03432       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03433       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03434       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03435       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03436       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03437       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03438       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03439       -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,    -1,
03440       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   137,
03441       -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,     1,   147,
03442        3,     4,     5,     6,     7,    -1,    -1,    10,    11,    12,
03443       -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,    22,
03444       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03445       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03446       -1,    -1,    45,    46,    -1,    48,    49,    50,    51,    52,
03447       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03448       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03449       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03450       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03451       93,    -1,    95,    -1,    97,    98,    99,   100,   101,   102,
03452      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03453       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
03454      123,   124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03455        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03456       -1,    -1,   145,    16,   147,    18,    19,    20,    21,    22,
03457       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03458       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03459       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03460       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03461       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03462       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03463       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03464       93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03465      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03466        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03467      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03468       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03469       34,    35,    36,    -1,   147,    39,    -1,    -1,    -1,    -1,
03470       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03471       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03472       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03473       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03474       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03475       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03476       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03477       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,
03478      124,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03479        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03480       -1,   145,    16,   147,    18,    19,    20,    21,    22,    23,
03481       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03482       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03483       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03484       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03485       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03486       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03487       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03488       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03489       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03490        5,     6,     7,    -1,    -1,    -1,    11,    12,   122,   123,
03491      124,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03492       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03493       35,    36,    -1,   147,    39,    -1,    -1,    -1,    -1,    -1,
03494       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03495       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03496       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03497       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03498       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03499       95,    -1,    97,    98,    99,   100,   101,   102,   103,    -1,
03500       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03501       -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
03502       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,
03503        7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,
03504      145,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03505       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03506       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03507       -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03508       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03509       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03510       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03511       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03512       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03513       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03514       -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,
03515       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03516       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   145,     3,
03517        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03518       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03519       24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
03520       34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
03521       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03522       54,    55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,
03523       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
03524       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
03525       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03526       -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03527       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,
03528      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
03529      124,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03530        7,    -1,    -1,    -1,    11,    12,    -1,   141,   142,    16,
03531       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    26,
03532       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03533       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03534       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03535       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
03536       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03537       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03538       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    96,
03539       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03540       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03541       -1,    -1,    -1,    -1,    -1,   122,   123,   124,    -1,    -1,
03542       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,   136,
03543       -1,    11,    12,    -1,    -1,   142,    16,    -1,    18,    19,
03544       20,    21,    22,    23,    24,    -1,    26,    -1,    -1,    -1,
03545       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03546       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03547       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
03548       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03549       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03550       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03551       90,    -1,    92,    93,    -1,    95,    96,    97,    98,    99,
03552      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03553       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03554       -1,    -1,   122,   123,   124,    -1,    -1,    -1,    -1,    -1,
03555        3,     4,     5,    -1,     7,    -1,   136,    -1,    11,    12,
03556       -1,    -1,   142,    16,    -1,    18,    19,    20,    21,    22,
03557       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03558       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03559       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03560       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03561       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03562       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03563       -1,    -1,    -1,    86,    87,    -1,    89,    90,    -1,    92,
03564       93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03565      103,    -1,    -1,    -1,    -1,    -1,   109,    -1,    -1,    -1,
03566       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,   122,
03567      123,   124,    11,    12,    -1,    -1,    -1,    16,    -1,    18,
03568       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,   142,
03569       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03570       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03571       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03572       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03573       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03574       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03575       89,    90,    -1,    92,    93,    -1,    95,    96,    97,    98,
03576       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
03577       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03578        5,    -1,     7,   122,   123,   124,    11,    12,    -1,    -1,
03579       -1,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03580       -1,    -1,    -1,   142,    -1,    30,    31,    32,    33,    34,
03581       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03582       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03583       55,    56,    57,    58,    59,    60,    -1,    62,    63,    64,
03584       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03585       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03586       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03587       95,    96,    97,    98,    99,   100,   101,   102,   103,    -1,
03588       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03589       -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
03590       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03591       -1,    -1,    -1,    -1,    -1,    -1,    -1,   142,     3,     4,
03592        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03593       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03594       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03595       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03596       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03597       55,    56,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03598       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03599       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03600       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03601       95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03602       -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,
03603      115,   116,   117,   118,   119,   120,   121,    -1,   123,   124,
03604       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03605       -1,    -1,    -1,    -1,    -1,    -1,   141,     3,     4,     5,
03606        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
03607       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03608       26,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03609       36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    45,
03610       46,    47,    48,    49,    50,    51,    52,    53,    54,    -1,
03611       56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03612       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
03613       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
03614       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
03615       -1,    -1,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03616       -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,
03617      116,   117,   118,   119,   120,   121,    -1,   123,   124,    -1,
03618       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03619       -1,    -1,    -1,    -1,    -1,   141,     3,     4,     5,     6,
03620        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
03621       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
03622       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03623       37,    38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03624       47,    48,    49,    50,    51,    52,    53,    -1,    -1,    56,
03625       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,
03626       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
03627       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
03628       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,
03629       -1,    98,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03630       -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,
03631      117,   118,   119,   120,   121,    -1,   123,   124,    -1,    -1,
03632       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03633       -1,    -1,    -1,    -1,   141,     3,     4,     5,     6,     7,
03634        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03635       18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
03636       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
03637       38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03638       48,    49,    50,    51,    52,    53,    -1,    -1,    56,    -1,
03639       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
03640       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03641       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
03642       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,
03643       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03644       -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,   117,
03645      118,   119,   120,   121,    -1,   123,   124,    -1,    -1,     3,
03646        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03647       -1,    -1,    16,   141,    18,    19,    20,    21,    22,    23,
03648       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03649       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03650       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03651       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03652       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03653       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03654       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03655       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03656       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03657       -1,     3,     4,     5,    -1,     7,    -1,    -1,   122,    11,
03658       12,    -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,
03659       22,    23,    24,    -1,    -1,    -1,   140,    -1,    30,    31,
03660       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03661       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03662       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03663       62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03664       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03665       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03666       92,    93,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03667      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03668       -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,    -1,
03669      122,    11,    12,    -1,    -1,    -1,    16,    -1,    18,    19,
03670       20,    21,    22,    23,    24,    -1,    -1,    -1,   140,    -1,
03671       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03672       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03673       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03674       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03675       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03676       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03677       90,    -1,    92,    93,    -1,    95,    -1,    97,    98,    99,
03678      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03679       -1,    -1,     3,     4,     5,     6,     7,    -1,    -1,    -1,
03680       11,    12,   122,   123,   124,    16,    -1,    18,    19,    20,
03681       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03682       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03683       -1,    -1,    -1,    -1,    45,    46,    -1,    48,    49,    50,
03684       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03685       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03686       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03687       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03688       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03689      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03690       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03691       12,   122,   123,   124,    16,    -1,    18,    19,    20,    21,
03692       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03693       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03694       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03695       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03696       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03697       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03698       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03699       92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
03700      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03701        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03702      122,   123,   124,    16,    -1,    18,    19,    20,    21,    22,
03703       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03704       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03705       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03706       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
03707       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03708       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03709       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03710       93,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03711      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03712        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03713      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03714       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03715       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03716       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03717       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03718       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03719       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03720       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03721       -1,    95,    -1,    97,    98,    99,   100,   101,   102,   103,
03722       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03723        5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,
03724      124,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03725       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03726       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03727       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03728       55,    56,    57,    58,    59,    60,    -1,    62,    63,    64,
03729       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03730       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03731       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03732       -1,    96,    97,    98,    99,   100,   101,   102,   103,    -1,
03733       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03734       -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,   124,
03735       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03736       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03737       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03738       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03739       56,    57,    58,    59,    60,    -1,    62,    63,    64,    -1,
03740       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03741       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03742       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03743       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03744       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
03745        7,    -1,    -1,    -1,    11,    12,   122,   123,   124,    16,
03746       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03747       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03748       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
03749       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
03750       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
03751       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03752       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03753       -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,    -1,
03754       97,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
03755       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03756       -1,    -1,    -1,    11,    12,   122,   123,   124,    16,    -1,
03757       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03758       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03759       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03760       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03761       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03762       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03763       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03764       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    97,
03765       98,    99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,
03766       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
03767       -1,    -1,    11,    12,   122,   123,   124,    16,    -1,    18,
03768       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03769       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03770       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
03771       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03772       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03773       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03774       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03775       89,    90,    -1,    92,    93,    -1,    95,    -1,    97,    98,
03776       99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
03777       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
03778       -1,    11,    12,   122,   123,   124,    16,    -1,    18,    19,
03779       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03780       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03781       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
03782       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03783       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03784       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03785       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03786       90,    -1,    92,    93,    -1,    95,    -1,    97,    98,    99,
03787      100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,
03788       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03789       11,    12,   122,   123,   124,    16,    -1,    18,    19,    20,
03790       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03791       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03792       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03793       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03794       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03795       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03796       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03797       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03798      101,   102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03799       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03800       12,   122,   123,   124,    16,    -1,    18,    19,    20,    21,
03801       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03802       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03803       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03804       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03805       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03806       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03807       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03808       92,    93,    -1,    95,    -1,    97,    98,    99,   100,   101,
03809      102,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03810        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
03811      122,   123,   124,    16,    -1,    18,    19,    20,    21,    22,
03812       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03813       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03814       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03815       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03816       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
03817       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03818       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03819       93,    -1,    -1,    -1,    97,    98,    99,   100,   101,   102,
03820      103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03821        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,
03822      123,   124,    16,    -1,    18,    19,    20,    21,    22,    23,
03823       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03824       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03825       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03826       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03827       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03828       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03829       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03830       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03831       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03832        5,    -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,
03833      124,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03834       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03835       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03836       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03837       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03838       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03839       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03840       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03841       -1,    -1,    97,    98,    99,   100,   101,   102,   103,    -1,
03842       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
03843       -1,     7,    -1,    -1,    -1,    11,    12,   122,   123,   124,
03844       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03845       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03846       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03847       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03848       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03849       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03850       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03851       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03852       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03853       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03854       11,    12,    -1,    -1,    -1,    16,   122,    18,    19,    20,
03855       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03856       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03857       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03858       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03859       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
03860       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03861       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03862       -1,    92,    93,    -1,    95,    -1,    97,    98,    99,   100,
03863      101,   102,   103,    -1,    -1,    -1,    -1,     3,     4,     5,
03864       -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03865       16,   122,    18,    19,    20,    21,    22,    23,    24,    -1,
03866       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03867       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03868       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03869       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03870       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03871       -1,    -1,    -1,    -1,    -1,    -1,    -1,    83,    -1,    -1,
03872       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03873       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03874       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03875       11,    12,    -1,    -1,    -1,    16,   122,    18,    19,    20,
03876       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03877       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03878       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03879       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03880       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
03881       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03882       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03883       -1,    92,    93,    -1,    -1,    -1,    97,    98,    99,   100,
03884      101,   102,   103,    -1,    -1,    -1,    -1,     3,     4,     5,
03885       -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03886       16,   122,    18,    19,    20,    21,    22,    23,    24,    -1,
03887       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03888       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03889       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03890       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03891       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03892       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03893       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03894       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03895       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03896       11,    12,    -1,    -1,    -1,    16,   122,    18,    19,    20,
03897       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03898       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03899       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03900       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03901       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
03902       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03903       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03904       -1,    92,    93,    -1,    -1,    -1,    97,    98,    99,   100,
03905      101,   102,   103,    -1,    -1,    -1,    -1,     3,     4,     5,
03906       -1,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03907       16,   122,    18,    19,    20,    21,    22,    23,    24,    -1,
03908       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03909       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
03910       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
03911       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03912       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03913       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03914       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
03915       -1,    97,    98,    99,   100,   101,   102,   103,    -1,    -1,
03916       -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,
03917       -1,    -1,    -1,    -1,    -1,    -1,   122,    66,    67,    68,
03918       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
03919       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
03920       -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,
03921       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03922       -1,    -1,    -1,   112,   113,   114,   115,   116,   117,   118,
03923      119,   120,   121,    -1,   123,   124,    -1,    -1,    -1,    -1,
03924       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
03925       -1,    -1,   141,   142,    66,    67,    68,    69,    70,    71,
03926       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03927       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03928       -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,
03929       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03930      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
03931       -1,   123,   124,    -1,    -1,    -1,    -1,    52,    53,    -1,
03932       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,
03933      142,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03934       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03935       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03936       95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03937       -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,
03938      115,   116,   117,   118,   119,   120,   121,    -1,   123,   124,
03939       -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,
03940       -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    66,    67,
03941       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03942       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
03943       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,
03944       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03945       -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,   117,
03946      118,   119,   120,   121,    -1,   123,   124,    -1,    -1,    -1,
03947       -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,
03948       -1,    -1,    -1,   141,   142,    66,    67,    68,    69,    70,
03949       71,    72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,
03950       81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
03951       -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,
03952       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03953       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
03954      121,    -1,   123,   124,    -1,    -1,    -1,    -1,    52,    53,
03955       -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03956      141,   142,    66,    67,    68,    69,    70,    71,    72,    73,
03957       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
03958       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03959       -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03960       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,   113,
03961      114,   115,   116,   117,   118,   119,   120,   121,    -1,   123,
03962      124,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,    56,
03963       -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    66,
03964       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
03965       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
03966       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,
03967       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03968       -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,   116,
03969      117,   118,   119,   120,   121,    -1,   123,   124,    -1,    -1,
03970       -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,    -1,
03971       -1,    -1,    -1,    -1,   141,   142,    66,    67,    68,    69,
03972       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
03973       -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,
03974       -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,    -1,
03975       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03976       -1,    -1,   112,   113,   114,   115,   116,   117,   118,   119,
03977      120,   121,    -1,   123,   124,    -1,    -1,    -1,    -1,    52,
03978       53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,
03979       -1,   141,   142,    66,    67,    68,    69,    70,    71,    72,
03980       73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,
03981       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03982       -1,    -1,    95,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03983       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   112,
03984      113,   114,   115,   116,   117,   118,   119,   120,   121,    -1,
03985      123,   124,    -1,    -1,    -1,    -1,    52,    53,    -1,    -1,
03986       56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,   142,
03987       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
03988       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
03989       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
03990       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03991       -1,    -1,    -1,    -1,    -1,    -1,   112,   113,   114,   115,
03992      116,   117,   118,   119,   120,   121,    -1,   123,   124,    -1,
03993       -1,    -1,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,
03994       -1,    -1,    -1,    -1,    -1,   141,   142,    66,    67,    68,
03995       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
03996       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
03997       -1,    -1,    -1,    -1,    -1,    -1,    95,    -1,    -1,    -1,
03998       -1,    -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,
03999       -1,    -1,    -1,   112,   113,   114,   115,   116,   117,   118,
04000      119,   120,   121,    44,   123,   124,    -1,    -1,    68,    69,
04001       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
04002       80,    -1,   141,    83,    84,    -1,    -1,    68,    69,    70,
04003       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
04004       -1,    -1,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
04005      110,    -1,   112,   113,   114,   115,   116,   117,   118,   119,
04006      120,   121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   110,
04007       -1,   112,   113,   114,   115,   116,   117,   118,   119,   120,
04008      121
04009 };
04010 
04011 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04012    symbol of state STATE-NUM.  */
04013 static const yytype_uint16 yystos[] =
04014 {
04015        0,   149,   150,     0,     1,     3,     4,     5,     6,     7,
04016       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04017       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04018       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04019       57,    59,    60,    62,    63,    64,    66,    67,    86,    89,
04020       90,    92,    93,    95,    97,    98,    99,   100,   101,   102,
04021      103,   122,   123,   124,   151,   152,   153,   158,   160,   162,
04022      163,   166,   167,   169,   170,   171,   173,   174,   184,   198,
04023      215,   216,   217,   218,   219,   220,   221,   222,   223,   224,
04024      225,   248,   249,   259,   260,   261,   262,   263,   264,   265,
04025      268,   278,   280,   281,   282,   283,   284,   285,   308,   319,
04026      153,     3,     4,     5,     6,     7,     8,     9,    10,    11,
04027       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
04028       22,    23,    24,    25,    26,    30,    31,    32,    33,    34,
04029       35,    36,    37,    38,    39,    45,    46,    47,    48,    49,
04030       50,    51,    52,    53,    56,    66,    67,    68,    69,    70,
04031       71,    72,    73,    74,    77,    78,    81,    82,    83,    84,
04032       95,   112,   113,   114,   115,   116,   117,   118,   119,   120,
04033      121,   123,   124,   141,   177,   178,   179,   180,   182,   183,
04034      278,   280,    39,    58,    86,    89,    95,    96,   123,   166,
04035      174,   184,   186,   191,   194,   196,   215,   282,   284,   285,
04036      306,   307,   191,   191,   142,   192,   193,   142,   188,   192,
04037      142,   147,   313,    54,   179,   313,   154,   136,    21,    22,
04038       30,    31,    32,   184,   215,   308,   184,    56,     1,    89,
04039      156,   157,   158,   168,   169,   319,   160,   187,   196,   306,
04040      319,   186,   305,   306,   319,    46,    86,   122,   140,   173,
04041      198,   215,   282,   285,   241,   242,    54,    55,    57,   177,
04042      271,   279,   270,   271,   272,   146,   266,   146,   269,    59,
04043       60,   162,   184,   184,   145,   147,   312,   317,   318,    40,
04044       41,    42,    43,    44,    37,    38,    28,   246,   109,   140,
04045       89,    95,   170,   109,    68,    69,    70,    71,    72,    73,
04046       74,    75,    76,    77,    78,    79,    80,    83,    84,   110,
04047      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
04048       85,   138,   139,   199,   160,   161,   161,   202,   204,   161,
04049      312,   318,    86,   167,   174,   215,   231,   282,   285,    52,
04050       56,    83,    86,   175,   176,   215,   282,   285,   176,    33,
04051       34,    35,    36,    49,    50,    51,    52,    56,   142,   177,
04052      283,   303,    85,   139,    26,   136,   250,   262,    87,    87,
04053      188,   192,   250,   140,   186,    56,   186,   186,   109,    88,
04054      140,   195,   319,    85,   138,   139,    87,    87,   140,   195,
04055      191,   313,   314,   191,   190,   191,   319,   160,   314,   160,
04056       54,    63,    64,   159,   142,   185,   136,   156,    85,   139,
04057       87,   158,   168,   143,   312,   318,   314,   200,   144,   140,
04058      147,   316,   140,   316,   137,   316,   313,    56,    59,    60,
04059      170,   172,   140,    85,   138,   139,   243,    61,   104,   105,
04060      106,   273,   106,   273,   106,    65,   273,   106,   106,   267,
04061      273,   106,    61,   106,    68,    68,   145,   153,   161,   161,
04062      161,   161,   158,   160,   160,   247,    95,   162,   186,   196,
04063      197,   168,   140,   173,   140,   162,   184,   186,   197,   184,
04064      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04065      184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
04066      184,   184,   184,   184,   184,    52,    53,    56,   182,   188,
04067      309,   310,   190,    52,    53,    56,   182,   188,   309,   155,
04068      156,    13,   227,   317,   227,   161,   161,   312,    17,   253,
04069       56,    85,   138,   139,    25,   160,    52,    56,   175,     1,
04070      113,   286,   317,    85,   138,   139,   211,   304,   212,    85,
04071      139,   311,    52,    56,   309,   309,   252,   251,   162,   184,
04072      162,   184,    94,   164,   181,   184,   186,    95,   186,   194,
04073      306,    52,    56,   190,    52,    56,   307,   314,   143,   314,
04074      314,   179,   201,   184,   151,   137,   309,   309,   184,   314,
04075      158,   314,   306,   140,   172,    52,    56,   190,    52,    56,
04076       52,    54,    55,    56,    57,    89,    95,    96,   116,   119,
04077      142,   244,   289,   290,   291,   292,   293,   294,   297,   298,
04078      299,   300,   301,   275,   274,   146,   273,   146,   184,   184,
04079       76,   114,   236,   237,   319,   186,   140,   314,   172,   140,
04080       44,   313,    87,    87,   188,   192,   313,   315,    87,    87,
04081      188,   189,   192,   319,    10,   226,     8,   255,   319,   156,
04082       13,   156,    27,   228,   317,   228,   253,   196,   226,    52,
04083       56,   190,    52,    56,   206,   209,   317,   287,   208,    52,
04084       56,   175,   190,   155,   160,   142,   288,   289,   213,   189,
04085      192,   189,   192,   236,   236,    44,   165,   179,   186,   195,
04086       87,    87,   315,    87,    87,   160,   137,   316,   170,   315,
04087      109,    52,    89,    95,   232,   233,   234,   291,   289,    29,
04088      107,   245,   140,   302,   319,   140,   302,    52,   140,   302,
04089       52,   276,    54,    55,    57,   277,   285,    52,   145,   235,
04090      238,   293,   295,   296,   299,   301,   319,   156,    95,   186,
04091      172,   184,   111,   162,   184,   162,   184,   164,   144,    87,
04092      162,   184,   162,   184,   164,   186,   197,   256,   319,    15,
04093      230,   319,    14,   229,   230,   230,   203,   205,   226,   140,
04094      227,   315,   161,   317,   161,   155,   315,   226,   314,   289,
04095      155,   317,   177,   156,   156,   184,   236,    87,   314,   186,
04096      234,   140,   291,   140,   314,   238,   156,   156,   292,   297,
04097      299,   301,   293,   294,   299,   293,   156,   109,    52,   239,
04098      240,   290,   238,   114,   140,   302,   140,   302,   140,   302,
04099       10,   186,   184,   162,   184,    88,   257,   319,   156,     9,
04100      258,   319,   161,   226,   226,   156,   156,   186,   156,   228,
04101      210,   317,   226,   314,   226,   214,    10,   137,   156,   314,
04102      233,   140,    95,   232,   314,    10,   137,   140,   302,   140,
04103      302,   140,   302,   140,   302,   302,   137,    86,   215,   140,
04104      114,   296,   299,   293,   295,   299,   293,    86,   174,   215,
04105      282,   285,   227,   156,   227,   226,   226,   230,   253,   254,
04106      207,   155,   288,   137,   140,   233,   140,   291,   293,   299,
04107      293,   293,    56,    85,   240,   140,   302,   140,   302,   302,
04108      140,   302,   302,    56,    85,   138,   139,   156,   156,   156,
04109      226,   155,   233,   140,   302,   140,   302,   302,   302,    52,
04110       56,   293,   299,   293,   293,    52,    56,   190,    52,    56,
04111      255,   229,   226,   226,   233,   293,   302,   140,   302,   302,
04112      302,   315,   302,   293,   302
04113 };
04114 
04115 #define yyerrok         (yyerrstatus = 0)
04116 #define yyclearin       (yychar = YYEMPTY)
04117 #define YYEMPTY         (-2)
04118 #define YYEOF           0
04119 
04120 #define YYACCEPT        goto yyacceptlab
04121 #define YYABORT         goto yyabortlab
04122 #define YYERROR         goto yyerrorlab
04123 
04124 
04125 /* Like YYERROR except do call yyerror.  This remains here temporarily
04126    to ease the transition to the new meaning of YYERROR, for GCC.
04127    Once GCC version 2 has supplanted version 1, this can go.  However,
04128    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
04129    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
04130    discussed.  */
04131 
04132 #define YYFAIL          goto yyerrlab
04133 #if defined YYFAIL
04134   /* This is here to suppress warnings from the GCC cpp's
04135      -Wunused-macros.  Normally we don't worry about that warning, but
04136      some users do, and we want to make it easy for users to remove
04137      YYFAIL uses, which will produce warnings from Bison 2.5.  */
04138 #endif
04139 
04140 #define YYRECOVERING()  (!!yyerrstatus)
04141 
04142 #define YYBACKUP(Token, Value)                                  \
04143 do                                                              \
04144   if (yychar == YYEMPTY && yylen == 1)                          \
04145     {                                                           \
04146       yychar = (Token);                                         \
04147       yylval = (Value);                                         \
04148       YYPOPSTACK (1);                                           \
04149       goto yybackup;                                            \
04150     }                                                           \
04151   else                                                          \
04152     {                                                           \
04153       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04154       YYERROR;                                                  \
04155     }                                                           \
04156 while (YYID (0))
04157 
04158 
04159 #define YYTERROR        1
04160 #define YYERRCODE       256
04161 
04162 
04163 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04164    If N is 0, then set CURRENT to the empty location which ends
04165    the previous symbol: RHS[0] (always defined).  */
04166 
04167 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04168 #ifndef YYLLOC_DEFAULT
04169 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04170     do                                                                  \
04171       if (YYID (N))                                                    \
04172         {                                                               \
04173           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04174           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
04175           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
04176           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
04177         }                                                               \
04178       else                                                              \
04179         {                                                               \
04180           (Current).first_line   = (Current).last_line   =              \
04181             YYRHSLOC (Rhs, 0).last_line;                                \
04182           (Current).first_column = (Current).last_column =              \
04183             YYRHSLOC (Rhs, 0).last_column;                              \
04184         }                                                               \
04185     while (YYID (0))
04186 #endif
04187 
04188 
04189 /* This macro is provided for backward compatibility. */
04190 
04191 #ifndef YY_LOCATION_PRINT
04192 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04193 #endif
04194 
04195 
04196 /* YYLEX -- calling `yylex' with the right arguments.  */
04197 
04198 #ifdef YYLEX_PARAM
04199 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04200 #else
04201 # define YYLEX yylex (&yylval)
04202 #endif
04203 
04204 /* Enable debugging if requested.  */
04205 #if YYDEBUG
04206 
04207 # ifndef YYFPRINTF
04208 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04209 #  define YYFPRINTF fprintf
04210 # endif
04211 
04212 # define YYDPRINTF(Args)                        \
04213 do {                                            \
04214   if (yydebug)                                  \
04215     YYFPRINTF Args;                             \
04216 } while (YYID (0))
04217 
04218 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04219 do {                                                                      \
04220   if (yydebug)                                                            \
04221     {                                                                     \
04222       YYFPRINTF (stderr, "%s ", Title);                                   \
04223       yy_symbol_print (stderr,                                            \
04224                   Type, Value, parser); \
04225       YYFPRINTF (stderr, "\n");                                           \
04226     }                                                                     \
04227 } while (YYID (0))
04228 
04229 
04230 /*--------------------------------.
04231 | Print this symbol on YYOUTPUT.  |
04232 `--------------------------------*/
04233 
04234 /*ARGSUSED*/
04235 #if (defined __STDC__ || defined __C99__FUNC__ \
04236      || defined __cplusplus || defined _MSC_VER)
04237 static void
04238 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04239 #else
04240 static void
04241 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04242     FILE *yyoutput;
04243     int yytype;
04244     YYSTYPE const * const yyvaluep;
04245     struct parser_params *parser;
04246 #endif
04247 {
04248   if (!yyvaluep)
04249     return;
04250   YYUSE (parser);
04251 # ifdef YYPRINT
04252   if (yytype < YYNTOKENS)
04253     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04254 # else
04255   YYUSE (yyoutput);
04256 # endif
04257   switch (yytype)
04258     {
04259       default:
04260         break;
04261     }
04262 }
04263 
04264 
04265 /*--------------------------------.
04266 | Print this symbol on YYOUTPUT.  |
04267 `--------------------------------*/
04268 
04269 #if (defined __STDC__ || defined __C99__FUNC__ \
04270      || defined __cplusplus || defined _MSC_VER)
04271 static void
04272 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04273 #else
04274 static void
04275 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04276     FILE *yyoutput;
04277     int yytype;
04278     YYSTYPE const * const yyvaluep;
04279     struct parser_params *parser;
04280 #endif
04281 {
04282   if (yytype < YYNTOKENS)
04283     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04284   else
04285     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04286 
04287   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04288   YYFPRINTF (yyoutput, ")");
04289 }
04290 
04291 /*------------------------------------------------------------------.
04292 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04293 | TOP (included).                                                   |
04294 `------------------------------------------------------------------*/
04295 
04296 #if (defined __STDC__ || defined __C99__FUNC__ \
04297      || defined __cplusplus || defined _MSC_VER)
04298 static void
04299 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04300 #else
04301 static void
04302 yy_stack_print (yybottom, yytop)
04303     yytype_int16 *yybottom;
04304     yytype_int16 *yytop;
04305 #endif
04306 {
04307   YYFPRINTF (stderr, "Stack now");
04308   for (; yybottom <= yytop; yybottom++)
04309     {
04310       int yybot = *yybottom;
04311       YYFPRINTF (stderr, " %d", yybot);
04312     }
04313   YYFPRINTF (stderr, "\n");
04314 }
04315 
04316 # define YY_STACK_PRINT(Bottom, Top)                            \
04317 do {                                                            \
04318   if (yydebug)                                                  \
04319     yy_stack_print ((Bottom), (Top));                           \
04320 } while (YYID (0))
04321 
04322 
04323 /*------------------------------------------------.
04324 | Report that the YYRULE is going to be reduced.  |
04325 `------------------------------------------------*/
04326 
04327 #if (defined __STDC__ || defined __C99__FUNC__ \
04328      || defined __cplusplus || defined _MSC_VER)
04329 static void
04330 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04331 #else
04332 static void
04333 yy_reduce_print (yyvsp, yyrule, parser)
04334     YYSTYPE *yyvsp;
04335     int yyrule;
04336     struct parser_params *parser;
04337 #endif
04338 {
04339   int yynrhs = yyr2[yyrule];
04340   int yyi;
04341   unsigned long int yylno = yyrline[yyrule];
04342   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04343              yyrule - 1, yylno);
04344   /* The symbols being reduced.  */
04345   for (yyi = 0; yyi < yynrhs; yyi++)
04346     {
04347       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04348       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04349                        &(yyvsp[(yyi + 1) - (yynrhs)])
04350                                        , parser);
04351       YYFPRINTF (stderr, "\n");
04352     }
04353 }
04354 
04355 # define YY_REDUCE_PRINT(Rule)          \
04356 do {                                    \
04357   if (yydebug)                          \
04358     yy_reduce_print (yyvsp, Rule, parser); \
04359 } while (YYID (0))
04360 
04361 /* Nonzero means print parse trace.  It is left uninitialized so that
04362    multiple parsers can coexist.  */
04363 #ifndef yydebug
04364 int yydebug;
04365 #endif
04366 #else /* !YYDEBUG */
04367 # define YYDPRINTF(Args)
04368 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04369 # define YY_STACK_PRINT(Bottom, Top)
04370 # define YY_REDUCE_PRINT(Rule)
04371 #endif /* !YYDEBUG */
04372 
04373 
04374 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04375 #ifndef YYINITDEPTH
04376 # define YYINITDEPTH 200
04377 #endif
04378 
04379 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04380    if the built-in stack extension method is used).
04381 
04382    Do not make this value too large; the results are undefined if
04383    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04384    evaluated with infinite-precision integer arithmetic.  */
04385 
04386 #ifndef YYMAXDEPTH
04387 # define YYMAXDEPTH 10000
04388 #endif
04389 
04390 
04391 #if YYERROR_VERBOSE
04392 
04393 # ifndef yystrlen
04394 #  if defined __GLIBC__ && defined _STRING_H
04395 #   define yystrlen strlen
04396 #  else
04397 /* Return the length of YYSTR.  */
04398 #if (defined __STDC__ || defined __C99__FUNC__ \
04399      || defined __cplusplus || defined _MSC_VER)
04400 static YYSIZE_T
04401 yystrlen (const char *yystr)
04402 #else
04403 static YYSIZE_T
04404 yystrlen (yystr)
04405     const char *yystr;
04406 #endif
04407 {
04408   YYSIZE_T yylen;
04409   for (yylen = 0; yystr[yylen]; yylen++)
04410     continue;
04411   return yylen;
04412 }
04413 #  endif
04414 # endif
04415 
04416 # ifndef yystpcpy
04417 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04418 #   define yystpcpy stpcpy
04419 #  else
04420 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04421    YYDEST.  */
04422 #if (defined __STDC__ || defined __C99__FUNC__ \
04423      || defined __cplusplus || defined _MSC_VER)
04424 static char *
04425 yystpcpy (char *yydest, const char *yysrc)
04426 #else
04427 static char *
04428 yystpcpy (yydest, yysrc)
04429     char *yydest;
04430     const char *yysrc;
04431 #endif
04432 {
04433   char *yyd = yydest;
04434   const char *yys = yysrc;
04435 
04436   while ((*yyd++ = *yys++) != '\0')
04437     continue;
04438 
04439   return yyd - 1;
04440 }
04441 #  endif
04442 # endif
04443 
04444 # ifndef yytnamerr
04445 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04446    quotes and backslashes, so that it's suitable for yyerror.  The
04447    heuristic is that double-quoting is unnecessary unless the string
04448    contains an apostrophe, a comma, or backslash (other than
04449    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04450    null, do not copy; instead, return the length of what the result
04451    would have been.  */
04452 static YYSIZE_T
04453 yytnamerr (char *yyres, const char *yystr)
04454 {
04455   if (*yystr == '"')
04456     {
04457       YYSIZE_T yyn = 0;
04458       char const *yyp = yystr;
04459 
04460       for (;;)
04461         switch (*++yyp)
04462           {
04463           case '\'':
04464           case ',':
04465             goto do_not_strip_quotes;
04466 
04467           case '\\':
04468             if (*++yyp != '\\')
04469               goto do_not_strip_quotes;
04470             /* Fall through.  */
04471           default:
04472             if (yyres)
04473               yyres[yyn] = *yyp;
04474             yyn++;
04475             break;
04476 
04477           case '"':
04478             if (yyres)
04479               yyres[yyn] = '\0';
04480             return yyn;
04481           }
04482     do_not_strip_quotes: ;
04483     }
04484 
04485   if (! yyres)
04486     return yystrlen (yystr);
04487 
04488   return yystpcpy (yyres, yystr) - yyres;
04489 }
04490 # endif
04491 
04492 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
04493    about the unexpected token YYTOKEN for the state stack whose top is
04494    YYSSP.
04495 
04496    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
04497    not large enough to hold the message.  In that case, also set
04498    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
04499    required number of bytes is too large to store.  */
04500 static int
04501 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
04502                 yytype_int16 *yyssp, int yytoken)
04503 {
04504   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
04505   YYSIZE_T yysize = yysize0;
04506   YYSIZE_T yysize1;
04507   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04508   /* Internationalized format string. */
04509   const char *yyformat = 0;
04510   /* Arguments of yyformat. */
04511   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04512   /* Number of reported tokens (one for the "unexpected", one per
04513      "expected"). */
04514   int yycount = 0;
04515 
04516   /* There are many possibilities here to consider:
04517      - Assume YYFAIL is not used.  It's too flawed to consider.  See
04518        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
04519        for details.  YYERROR is fine as it does not invoke this
04520        function.
04521      - If this state is a consistent state with a default action, then
04522        the only way this function was invoked is if the default action
04523        is an error action.  In that case, don't check for expected
04524        tokens because there are none.
04525      - The only way there can be no lookahead present (in yychar) is if
04526        this state is a consistent state with a default action.  Thus,
04527        detecting the absence of a lookahead is sufficient to determine
04528        that there is no unexpected or expected token to report.  In that
04529        case, just report a simple "syntax error".
04530      - Don't assume there isn't a lookahead just because this state is a
04531        consistent state with a default action.  There might have been a
04532        previous inconsistent state, consistent state with a non-default
04533        action, or user semantic action that manipulated yychar.
04534      - Of course, the expected token list depends on states to have
04535        correct lookahead information, and it depends on the parser not
04536        to perform extra reductions after fetching a lookahead from the
04537        scanner and before detecting a syntax error.  Thus, state merging
04538        (from LALR or IELR) and default reductions corrupt the expected
04539        token list.  However, the list is correct for canonical LR with
04540        one exception: it will still contain any token that will not be
04541        accepted due to an error action in a later state.
04542   */
04543   if (yytoken != YYEMPTY)
04544     {
04545       int yyn = yypact[*yyssp];
04546       yyarg[yycount++] = yytname[yytoken];
04547       if (!yypact_value_is_default (yyn))
04548         {
04549           /* Start YYX at -YYN if negative to avoid negative indexes in
04550              YYCHECK.  In other words, skip the first -YYN actions for
04551              this state because they are default actions.  */
04552           int yyxbegin = yyn < 0 ? -yyn : 0;
04553           /* Stay within bounds of both yycheck and yytname.  */
04554           int yychecklim = YYLAST - yyn + 1;
04555           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04556           int yyx;
04557 
04558           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04559             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
04560                 && !yytable_value_is_error (yytable[yyx + yyn]))
04561               {
04562                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04563                   {
04564                     yycount = 1;
04565                     yysize = yysize0;
04566                     break;
04567                   }
04568                 yyarg[yycount++] = yytname[yyx];
04569                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04570                 if (! (yysize <= yysize1
04571                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04572                   return 2;
04573                 yysize = yysize1;
04574               }
04575         }
04576     }
04577 
04578   switch (yycount)
04579     {
04580 # define YYCASE_(N, S)                      \
04581       case N:                               \
04582         yyformat = S;                       \
04583       break
04584       YYCASE_(0, YY_("syntax error"));
04585       YYCASE_(1, YY_("syntax error, unexpected %s"));
04586       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
04587       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
04588       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
04589       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
04590 # undef YYCASE_
04591     }
04592 
04593   yysize1 = yysize + yystrlen (yyformat);
04594   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
04595     return 2;
04596   yysize = yysize1;
04597 
04598   if (*yymsg_alloc < yysize)
04599     {
04600       *yymsg_alloc = 2 * yysize;
04601       if (! (yysize <= *yymsg_alloc
04602              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
04603         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
04604       return 1;
04605     }
04606 
04607   /* Avoid sprintf, as that infringes on the user's name space.
04608      Don't have undefined behavior even if the translation
04609      produced a string with the wrong number of "%s"s.  */
04610   {
04611     char *yyp = *yymsg;
04612     int yyi = 0;
04613     while ((*yyp = *yyformat) != '\0')
04614       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
04615         {
04616           yyp += yytnamerr (yyp, yyarg[yyi++]);
04617           yyformat += 2;
04618         }
04619       else
04620         {
04621           yyp++;
04622           yyformat++;
04623         }
04624   }
04625   return 0;
04626 }
04627 #endif /* YYERROR_VERBOSE */
04628 
04629 /*-----------------------------------------------.
04630 | Release the memory associated to this symbol.  |
04631 `-----------------------------------------------*/
04632 
04633 /*ARGSUSED*/
04634 #if (defined __STDC__ || defined __C99__FUNC__ \
04635      || defined __cplusplus || defined _MSC_VER)
04636 static void
04637 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04638 #else
04639 static void
04640 yydestruct (yymsg, yytype, yyvaluep, parser)
04641     const char *yymsg;
04642     int yytype;
04643     YYSTYPE *yyvaluep;
04644     struct parser_params *parser;
04645 #endif
04646 {
04647   YYUSE (yyvaluep);
04648   YYUSE (parser);
04649 
04650   if (!yymsg)
04651     yymsg = "Deleting";
04652   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04653 
04654   switch (yytype)
04655     {
04656 
04657       default:
04658         break;
04659     }
04660 }
04661 
04662 
04663 /* Prevent warnings from -Wmissing-prototypes.  */
04664 #ifdef YYPARSE_PARAM
04665 #if defined __STDC__ || defined __cplusplus
04666 int yyparse (void *YYPARSE_PARAM);
04667 #else
04668 int yyparse ();
04669 #endif
04670 #else /* ! YYPARSE_PARAM */
04671 #if defined __STDC__ || defined __cplusplus
04672 int yyparse (struct parser_params *parser);
04673 #else
04674 int yyparse ();
04675 #endif
04676 #endif /* ! YYPARSE_PARAM */
04677 
04678 
04679 /*----------.
04680 | yyparse.  |
04681 `----------*/
04682 
04683 #ifdef YYPARSE_PARAM
04684 #if (defined __STDC__ || defined __C99__FUNC__ \
04685      || defined __cplusplus || defined _MSC_VER)
04686 int
04687 yyparse (void *YYPARSE_PARAM)
04688 #else
04689 int
04690 yyparse (YYPARSE_PARAM)
04691     void *YYPARSE_PARAM;
04692 #endif
04693 #else /* ! YYPARSE_PARAM */
04694 #if (defined __STDC__ || defined __C99__FUNC__ \
04695      || defined __cplusplus || defined _MSC_VER)
04696 int
04697 yyparse (struct parser_params *parser)
04698 #else
04699 int
04700 yyparse (parser)
04701     struct parser_params *parser;
04702 #endif
04703 #endif
04704 {
04705 /* The lookahead symbol.  */
04706 int yychar;
04707 
04708 /* The semantic value of the lookahead symbol.  */
04709 YYSTYPE yylval;
04710 
04711     /* Number of syntax errors so far.  */
04712     int yynerrs;
04713 
04714     int yystate;
04715     /* Number of tokens to shift before error messages enabled.  */
04716     int yyerrstatus;
04717 
04718     /* The stacks and their tools:
04719        `yyss': related to states.
04720        `yyvs': related to semantic values.
04721 
04722        Refer to the stacks thru separate pointers, to allow yyoverflow
04723        to reallocate them elsewhere.  */
04724 
04725     /* The state stack.  */
04726     yytype_int16 yyssa[YYINITDEPTH];
04727     yytype_int16 *yyss;
04728     yytype_int16 *yyssp;
04729 
04730     /* The semantic value stack.  */
04731     YYSTYPE yyvsa[YYINITDEPTH];
04732     YYSTYPE *yyvs;
04733     YYSTYPE *yyvsp;
04734 
04735     YYSIZE_T yystacksize;
04736 
04737   int yyn;
04738   int yyresult;
04739   /* Lookahead token as an internal (translated) token number.  */
04740   int yytoken;
04741   /* The variables used to return semantic value and location from the
04742      action routines.  */
04743   YYSTYPE yyval;
04744 
04745 #if YYERROR_VERBOSE
04746   /* Buffer for error messages, and its allocated size.  */
04747   char yymsgbuf[128];
04748   char *yymsg = yymsgbuf;
04749   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
04750 #endif
04751 
04752 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
04753 
04754   /* The number of symbols on the RHS of the reduced rule.
04755      Keep to zero when no symbol should be popped.  */
04756   int yylen = 0;
04757 
04758   yytoken = 0;
04759   yyss = yyssa;
04760   yyvs = yyvsa;
04761   yystacksize = YYINITDEPTH;
04762 
04763   YYDPRINTF ((stderr, "Starting parse\n"));
04764 
04765   yystate = 0;
04766   yyerrstatus = 0;
04767   yynerrs = 0;
04768   yychar = YYEMPTY; /* Cause a token to be read.  */
04769 
04770   /* Initialize stack pointers.
04771      Waste one element of value and location stack
04772      so that they stay on the same level as the state stack.
04773      The wasted elements are never initialized.  */
04774   yyssp = yyss;
04775   yyvsp = yyvs;
04776 
04777   goto yysetstate;
04778 
04779 /*------------------------------------------------------------.
04780 | yynewstate -- Push a new state, which is found in yystate.  |
04781 `------------------------------------------------------------*/
04782  yynewstate:
04783   /* In all cases, when you get here, the value and location stacks
04784      have just been pushed.  So pushing a state here evens the stacks.  */
04785   yyssp++;
04786 
04787  yysetstate:
04788   *yyssp = yystate;
04789 
04790   if (yyss + yystacksize - 1 <= yyssp)
04791     {
04792       /* Get the current used size of the three stacks, in elements.  */
04793       YYSIZE_T yysize = yyssp - yyss + 1;
04794 
04795 #ifdef yyoverflow
04796       {
04797         /* Give user a chance to reallocate the stack.  Use copies of
04798            these so that the &'s don't force the real ones into
04799            memory.  */
04800         YYSTYPE *yyvs1 = yyvs;
04801         yytype_int16 *yyss1 = yyss;
04802 
04803         /* Each stack pointer address is followed by the size of the
04804            data in use in that stack, in bytes.  This used to be a
04805            conditional around just the two extra args, but that might
04806            be undefined if yyoverflow is a macro.  */
04807         yyoverflow (YY_("memory exhausted"),
04808                     &yyss1, yysize * sizeof (*yyssp),
04809                     &yyvs1, yysize * sizeof (*yyvsp),
04810                     &yystacksize);
04811 
04812         yyss = yyss1;
04813         yyvs = yyvs1;
04814       }
04815 #else /* no yyoverflow */
04816 # ifndef YYSTACK_RELOCATE
04817       goto yyexhaustedlab;
04818 # else
04819       /* Extend the stack our own way.  */
04820       if (YYMAXDEPTH <= yystacksize)
04821         goto yyexhaustedlab;
04822       yystacksize *= 2;
04823       if (YYMAXDEPTH < yystacksize)
04824         yystacksize = YYMAXDEPTH;
04825 
04826       {
04827         yytype_int16 *yyss1 = yyss;
04828         union yyalloc *yyptr =
04829           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
04830         if (! yyptr)
04831           goto yyexhaustedlab;
04832         YYSTACK_RELOCATE (yyss_alloc, yyss);
04833         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
04834 #  undef YYSTACK_RELOCATE
04835         if (yyss1 != yyssa)
04836           YYSTACK_FREE (yyss1);
04837       }
04838 # endif
04839 #endif /* no yyoverflow */
04840 
04841       yyssp = yyss + yysize - 1;
04842       yyvsp = yyvs + yysize - 1;
04843 
04844       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
04845                   (unsigned long int) yystacksize));
04846 
04847       if (yyss + yystacksize - 1 <= yyssp)
04848         YYABORT;
04849     }
04850 
04851   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
04852 
04853   if (yystate == YYFINAL)
04854     YYACCEPT;
04855 
04856   goto yybackup;
04857 
04858 /*-----------.
04859 | yybackup.  |
04860 `-----------*/
04861 yybackup:
04862 
04863   /* Do appropriate processing given the current state.  Read a
04864      lookahead token if we need one and don't already have one.  */
04865 
04866   /* First try to decide what to do without reference to lookahead token.  */
04867   yyn = yypact[yystate];
04868   if (yypact_value_is_default (yyn))
04869     goto yydefault;
04870 
04871   /* Not known => get a lookahead token if don't already have one.  */
04872 
04873   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
04874   if (yychar == YYEMPTY)
04875     {
04876       YYDPRINTF ((stderr, "Reading a token: "));
04877       yychar = YYLEX;
04878     }
04879 
04880   if (yychar <= YYEOF)
04881     {
04882       yychar = yytoken = YYEOF;
04883       YYDPRINTF ((stderr, "Now at end of input.\n"));
04884     }
04885   else
04886     {
04887       yytoken = YYTRANSLATE (yychar);
04888       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
04889     }
04890 
04891   /* If the proper action on seeing token YYTOKEN is to reduce or to
04892      detect an error, take that action.  */
04893   yyn += yytoken;
04894   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
04895     goto yydefault;
04896   yyn = yytable[yyn];
04897   if (yyn <= 0)
04898     {
04899       if (yytable_value_is_error (yyn))
04900         goto yyerrlab;
04901       yyn = -yyn;
04902       goto yyreduce;
04903     }
04904 
04905   /* Count tokens shifted since error; after three, turn off error
04906      status.  */
04907   if (yyerrstatus)
04908     yyerrstatus--;
04909 
04910   /* Shift the lookahead token.  */
04911   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
04912 
04913   /* Discard the shifted token.  */
04914   yychar = YYEMPTY;
04915 
04916   yystate = yyn;
04917   *++yyvsp = yylval;
04918 
04919   goto yynewstate;
04920 
04921 
04922 /*-----------------------------------------------------------.
04923 | yydefault -- do the default action for the current state.  |
04924 `-----------------------------------------------------------*/
04925 yydefault:
04926   yyn = yydefact[yystate];
04927   if (yyn == 0)
04928     goto yyerrlab;
04929   goto yyreduce;
04930 
04931 
04932 /*-----------------------------.
04933 | yyreduce -- Do a reduction.  |
04934 `-----------------------------*/
04935 yyreduce:
04936   /* yyn is the number of a rule to reduce with.  */
04937   yylen = yyr2[yyn];
04938 
04939   /* If YYLEN is nonzero, implement the default value of the action:
04940      `$$ = $1'.
04941 
04942      Otherwise, the following line sets YYVAL to garbage.
04943      This behavior is undocumented and Bison
04944      users should not rely upon it.  Assigning to YYVAL
04945      unconditionally makes the parser a bit smaller, and it avoids a
04946      GCC warning that YYVAL may be used uninitialized.  */
04947   yyval = yyvsp[1-yylen];
04948 
04949 
04950   YY_REDUCE_PRINT (yyn);
04951   switch (yyn)
04952     {
04953         case 2:
04954 
04955 /* Line 1806 of yacc.c  */
04956 #line 786 "ripper.y"
04957     {
04958                         lex_state = EXPR_BEG;
04959 #if 0
04960                         local_push(compile_for_eval || rb_parse_in_main());
04961 #endif
04962                         local_push(0);
04963 
04964                     }
04965     break;
04966 
04967   case 3:
04968 
04969 /* Line 1806 of yacc.c  */
04970 #line 795 "ripper.y"
04971     {
04972 #if 0
04973                         if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
04974                             /* last expression should not be void */
04975                             if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
04976                             else {
04977                                 NODE *node = (yyvsp[(2) - (2)].val);
04978                                 while (node->nd_next) {
04979                                     node = node->nd_next;
04980                                 }
04981                                 void_expr(node->nd_head);
04982                             }
04983                         }
04984                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
04985 #endif
04986                         (yyval.val) = (yyvsp[(2) - (2)].val);
04987                         parser->result = dispatch1(program, (yyval.val));
04988 
04989                         local_pop();
04990                     }
04991     break;
04992 
04993   case 4:
04994 
04995 /* Line 1806 of yacc.c  */
04996 #line 818 "ripper.y"
04997     {
04998 #if 0
04999                         void_stmts((yyvsp[(1) - (2)].val));
05000                         fixup_nodes(&deferred_nodes);
05001 #endif
05002 
05003                         (yyval.val) = (yyvsp[(1) - (2)].val);
05004                     }
05005     break;
05006 
05007   case 5:
05008 
05009 /* Line 1806 of yacc.c  */
05010 #line 829 "ripper.y"
05011     {
05012 #if 0
05013                         (yyval.val) = NEW_BEGIN(0);
05014 #endif
05015                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05016                                                   dispatch0(void_stmt));
05017 
05018                     }
05019     break;
05020 
05021   case 6:
05022 
05023 /* Line 1806 of yacc.c  */
05024 #line 838 "ripper.y"
05025     {
05026 #if 0
05027                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05028 #endif
05029                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05030 
05031                     }
05032     break;
05033 
05034   case 7:
05035 
05036 /* Line 1806 of yacc.c  */
05037 #line 846 "ripper.y"
05038     {
05039 #if 0
05040                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05041 #endif
05042                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05043 
05044                     }
05045     break;
05046 
05047   case 8:
05048 
05049 /* Line 1806 of yacc.c  */
05050 #line 854 "ripper.y"
05051     {
05052                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05053                     }
05054     break;
05055 
05056   case 10:
05057 
05058 /* Line 1806 of yacc.c  */
05059 #line 861 "ripper.y"
05060     {
05061                         if (in_def || in_single) {
05062                             yyerror("BEGIN in method");
05063                         }
05064 #if 0
05065                         /* local_push(0); */
05066 #endif
05067 
05068                     }
05069     break;
05070 
05071   case 11:
05072 
05073 /* Line 1806 of yacc.c  */
05074 #line 871 "ripper.y"
05075     {
05076 #if 0
05077                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05078                                                             (yyvsp[(4) - (5)].val));
05079                         /* NEW_PREEXE($4)); */
05080                         /* local_pop(); */
05081                         (yyval.val) = NEW_BEGIN(0);
05082 #endif
05083                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05084 
05085                     }
05086     break;
05087 
05088   case 12:
05089 
05090 /* Line 1806 of yacc.c  */
05091 #line 888 "ripper.y"
05092     {
05093 #if 0
05094                         (yyval.val) = (yyvsp[(1) - (4)].val);
05095                         if ((yyvsp[(2) - (4)].val)) {
05096                             (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05097                         }
05098                         else if ((yyvsp[(3) - (4)].val)) {
05099                             rb_warn0("else without rescue is useless");
05100                             (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
05101                         }
05102                         if ((yyvsp[(4) - (4)].val)) {
05103                             if ((yyval.val)) {
05104                                 (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
05105                             }
05106                             else {
05107                                 (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
05108                             }
05109                         }
05110                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05111 #endif
05112                         (yyval.val) = dispatch4(bodystmt,
05113                                        escape_Qundef((yyvsp[(1) - (4)].val)),
05114                                        escape_Qundef((yyvsp[(2) - (4)].val)),
05115                                        escape_Qundef((yyvsp[(3) - (4)].val)),
05116                                        escape_Qundef((yyvsp[(4) - (4)].val)));
05117 
05118                     }
05119     break;
05120 
05121   case 13:
05122 
05123 /* Line 1806 of yacc.c  */
05124 #line 918 "ripper.y"
05125     {
05126 #if 0
05127                         void_stmts((yyvsp[(1) - (2)].val));
05128                         fixup_nodes(&deferred_nodes);
05129 #endif
05130 
05131                         (yyval.val) = (yyvsp[(1) - (2)].val);
05132                     }
05133     break;
05134 
05135   case 14:
05136 
05137 /* Line 1806 of yacc.c  */
05138 #line 929 "ripper.y"
05139     {
05140 #if 0
05141                         (yyval.val) = NEW_BEGIN(0);
05142 #endif
05143                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05144                                                   dispatch0(void_stmt));
05145 
05146                     }
05147     break;
05148 
05149   case 15:
05150 
05151 /* Line 1806 of yacc.c  */
05152 #line 938 "ripper.y"
05153     {
05154 #if 0
05155                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05156 #endif
05157                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05158 
05159                     }
05160     break;
05161 
05162   case 16:
05163 
05164 /* Line 1806 of yacc.c  */
05165 #line 946 "ripper.y"
05166     {
05167 #if 0
05168                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05169 #endif
05170                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05171 
05172                     }
05173     break;
05174 
05175   case 17:
05176 
05177 /* Line 1806 of yacc.c  */
05178 #line 954 "ripper.y"
05179     {
05180                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05181                     }
05182     break;
05183 
05184   case 18:
05185 
05186 /* Line 1806 of yacc.c  */
05187 #line 959 "ripper.y"
05188     {lex_state = EXPR_FNAME;}
05189     break;
05190 
05191   case 19:
05192 
05193 /* Line 1806 of yacc.c  */
05194 #line 960 "ripper.y"
05195     {
05196 #if 0
05197                         (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05198 #endif
05199                         (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05200 
05201                     }
05202     break;
05203 
05204   case 20:
05205 
05206 /* Line 1806 of yacc.c  */
05207 #line 968 "ripper.y"
05208     {
05209 #if 0
05210                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05211 #endif
05212                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05213 
05214                     }
05215     break;
05216 
05217   case 21:
05218 
05219 /* Line 1806 of yacc.c  */
05220 #line 976 "ripper.y"
05221     {
05222 #if 0
05223                         char buf[2];
05224                         buf[0] = '$';
05225                         buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
05226                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
05227 #endif
05228                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05229 
05230                     }
05231     break;
05232 
05233   case 22:
05234 
05235 /* Line 1806 of yacc.c  */
05236 #line 987 "ripper.y"
05237     {
05238 #if 0
05239                         yyerror("can't make alias for the number variables");
05240                         (yyval.val) = NEW_BEGIN(0);
05241 #endif
05242                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05243                         (yyval.val) = dispatch1(alias_error, (yyval.val));
05244 
05245                     }
05246     break;
05247 
05248   case 23:
05249 
05250 /* Line 1806 of yacc.c  */
05251 #line 997 "ripper.y"
05252     {
05253 #if 0
05254                         (yyval.val) = (yyvsp[(2) - (2)].val);
05255 #endif
05256                         (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
05257 
05258                     }
05259     break;
05260 
05261   case 24:
05262 
05263 /* Line 1806 of yacc.c  */
05264 #line 1005 "ripper.y"
05265     {
05266 #if 0
05267                         (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05268                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05269 #endif
05270                         (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05271 
05272                     }
05273     break;
05274 
05275   case 25:
05276 
05277 /* Line 1806 of yacc.c  */
05278 #line 1014 "ripper.y"
05279     {
05280 #if 0
05281                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05282                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05283 #endif
05284                         (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05285 
05286                     }
05287     break;
05288 
05289   case 26:
05290 
05291 /* Line 1806 of yacc.c  */
05292 #line 1023 "ripper.y"
05293     {
05294 #if 0
05295                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05296                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05297                         }
05298                         else {
05299                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05300                         }
05301 #endif
05302                         (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05303 
05304                     }
05305     break;
05306 
05307   case 27:
05308 
05309 /* Line 1806 of yacc.c  */
05310 #line 1036 "ripper.y"
05311     {
05312 #if 0
05313                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05314                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05315                         }
05316                         else {
05317                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05318                         }
05319 #endif
05320                         (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05321 
05322                     }
05323     break;
05324 
05325   case 28:
05326 
05327 /* Line 1806 of yacc.c  */
05328 #line 1049 "ripper.y"
05329     {
05330 #if 0
05331                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
05332                         (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
05333 #endif
05334                         (yyval.val) = dispatch2(rescue_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05335 
05336                     }
05337     break;
05338 
05339   case 29:
05340 
05341 /* Line 1806 of yacc.c  */
05342 #line 1058 "ripper.y"
05343     {
05344                         if (in_def || in_single) {
05345                             rb_warn0("END in method; use at_exit");
05346                         }
05347 #if 0
05348                         (yyval.val) = NEW_POSTEXE(NEW_NODE(
05349                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
05350 #endif
05351                         (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
05352 
05353                     }
05354     break;
05355 
05356   case 30:
05357 
05358 /* Line 1806 of yacc.c  */
05359 #line 1070 "ripper.y"
05360     {
05361 #if 0
05362                         value_expr((yyvsp[(3) - (3)].val));
05363                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05364 #endif
05365                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05366 
05367                     }
05368     break;
05369 
05370   case 31:
05371 
05372 /* Line 1806 of yacc.c  */
05373 #line 1079 "ripper.y"
05374     {
05375 #if 0
05376                         value_expr((yyvsp[(3) - (3)].val));
05377                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05378                         (yyval.val) = (yyvsp[(1) - (3)].val);
05379 #endif
05380                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05381 
05382                     }
05383     break;
05384 
05385   case 32:
05386 
05387 /* Line 1806 of yacc.c  */
05388 #line 1089 "ripper.y"
05389     {
05390 #if 0
05391                         value_expr((yyvsp[(3) - (3)].val));
05392                         if ((yyvsp[(1) - (3)].val)) {
05393                             ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
05394                             if ((yyvsp[(2) - (3)].val) == tOROP) {
05395                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05396                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
05397                                 if (is_asgn_or_id(vid)) {
05398                                     (yyval.val)->nd_aid = vid;
05399                                 }
05400                             }
05401                             else if ((yyvsp[(2) - (3)].val) == tANDOP) {
05402                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05403                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
05404                             }
05405                             else {
05406                                 (yyval.val) = (yyvsp[(1) - (3)].val);
05407                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
05408                             }
05409                         }
05410                         else {
05411                             (yyval.val) = NEW_BEGIN(0);
05412                         }
05413 #endif
05414                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05415 
05416                     }
05417     break;
05418 
05419   case 33:
05420 
05421 /* Line 1806 of yacc.c  */
05422 #line 1118 "ripper.y"
05423     {
05424 #if 0
05425                         NODE *args;
05426 
05427                         value_expr((yyvsp[(6) - (6)].val));
05428                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
05429                         args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
05430                         if ((yyvsp[(5) - (6)].val) == tOROP) {
05431                             (yyvsp[(5) - (6)].val) = 0;
05432                         }
05433                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
05434                             (yyvsp[(5) - (6)].val) = 1;
05435                         }
05436                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
05437                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
05438 #endif
05439                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
05440                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
05441 
05442                     }
05443     break;
05444 
05445   case 34:
05446 
05447 /* Line 1806 of yacc.c  */
05448 #line 1139 "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 35:
05468 
05469 /* Line 1806 of yacc.c  */
05470 #line 1156 "ripper.y"
05471     {
05472 #if 0
05473                         value_expr((yyvsp[(5) - (5)].val));
05474                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05475                             (yyvsp[(4) - (5)].val) = 0;
05476                         }
05477                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05478                             (yyvsp[(4) - (5)].val) = 1;
05479                         }
05480                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05481                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05482 #endif
05483                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
05484                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05485 
05486                     }
05487     break;
05488 
05489   case 36:
05490 
05491 /* Line 1806 of yacc.c  */
05492 #line 1173 "ripper.y"
05493     {
05494 #if 0
05495                         yyerror("constant re-assignment");
05496                         (yyval.val) = 0;
05497 #endif
05498                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05499                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05500                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05501 
05502                     }
05503     break;
05504 
05505   case 37:
05506 
05507 /* Line 1806 of yacc.c  */
05508 #line 1184 "ripper.y"
05509     {
05510 #if 0
05511                         value_expr((yyvsp[(5) - (5)].val));
05512                         if ((yyvsp[(4) - (5)].val) == tOROP) {
05513                             (yyvsp[(4) - (5)].val) = 0;
05514                         }
05515                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
05516                             (yyvsp[(4) - (5)].val) = 1;
05517                         }
05518                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05519                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05520 #endif
05521                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
05522                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05523 
05524                     }
05525     break;
05526 
05527   case 38:
05528 
05529 /* Line 1806 of yacc.c  */
05530 #line 1201 "ripper.y"
05531     {
05532 #if 0
05533                         rb_backref_error((yyvsp[(1) - (3)].val));
05534                         (yyval.val) = NEW_BEGIN(0);
05535 #endif
05536                         (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
05537                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05538 
05539                     }
05540     break;
05541 
05542   case 39:
05543 
05544 /* Line 1806 of yacc.c  */
05545 #line 1211 "ripper.y"
05546     {
05547 #if 0
05548                         value_expr((yyvsp[(3) - (3)].val));
05549                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05550 #endif
05551                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05552 
05553                     }
05554     break;
05555 
05556   case 40:
05557 
05558 /* Line 1806 of yacc.c  */
05559 #line 1220 "ripper.y"
05560     {
05561 #if 0
05562                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05563                         (yyval.val) = (yyvsp[(1) - (3)].val);
05564 #endif
05565                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05566 
05567                     }
05568     break;
05569 
05570   case 41:
05571 
05572 /* Line 1806 of yacc.c  */
05573 #line 1229 "ripper.y"
05574     {
05575 #if 0
05576                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05577                         (yyval.val) = (yyvsp[(1) - (3)].val);
05578 #endif
05579                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05580 
05581                     }
05582     break;
05583 
05584   case 44:
05585 
05586 /* Line 1806 of yacc.c  */
05587 #line 1242 "ripper.y"
05588     {
05589 #if 0
05590                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05591 #endif
05592                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
05593 
05594                     }
05595     break;
05596 
05597   case 45:
05598 
05599 /* Line 1806 of yacc.c  */
05600 #line 1250 "ripper.y"
05601     {
05602 #if 0
05603                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05604 #endif
05605                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
05606 
05607                     }
05608     break;
05609 
05610   case 46:
05611 
05612 /* Line 1806 of yacc.c  */
05613 #line 1258 "ripper.y"
05614     {
05615 #if 0
05616                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
05617 #endif
05618                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
05619 
05620                     }
05621     break;
05622 
05623   case 47:
05624 
05625 /* Line 1806 of yacc.c  */
05626 #line 1266 "ripper.y"
05627     {
05628 #if 0
05629                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
05630 #endif
05631                         (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
05632 
05633                     }
05634     break;
05635 
05636   case 49:
05637 
05638 /* Line 1806 of yacc.c  */
05639 #line 1277 "ripper.y"
05640     {
05641 #if 0
05642                         value_expr((yyvsp[(1) - (1)].val));
05643                         (yyval.val) = (yyvsp[(1) - (1)].val);
05644                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
05645 #endif
05646                         (yyval.val) = (yyvsp[(1) - (1)].val);
05647 
05648                     }
05649     break;
05650 
05651   case 53:
05652 
05653 /* Line 1806 of yacc.c  */
05654 #line 1294 "ripper.y"
05655     {
05656 #if 0
05657                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05658 #endif
05659                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
05660                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05661 
05662                     }
05663     break;
05664 
05665   case 54:
05666 
05667 /* Line 1806 of yacc.c  */
05668 #line 1303 "ripper.y"
05669     {
05670 #if 0
05671                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05672 #endif
05673                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
05674                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05675 
05676                     }
05677     break;
05678 
05679   case 55:
05680 
05681 /* Line 1806 of yacc.c  */
05682 #line 1314 "ripper.y"
05683     {
05684                         (yyvsp[(1) - (1)].vars) = dyna_push();
05685 #if 0
05686                         (yyval.num) = ruby_sourceline;
05687 #endif
05688 
05689                     }
05690     break;
05691 
05692   case 56:
05693 
05694 /* Line 1806 of yacc.c  */
05695 #line 1324 "ripper.y"
05696     {
05697 #if 0
05698                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
05699                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
05700 #endif
05701                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
05702 
05703                         dyna_pop((yyvsp[(1) - (5)].vars));
05704                     }
05705     break;
05706 
05707   case 57:
05708 
05709 /* Line 1806 of yacc.c  */
05710 #line 1336 "ripper.y"
05711     {
05712 #if 0
05713                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05714                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05715 #endif
05716                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05717 
05718                     }
05719     break;
05720 
05721   case 58:
05722 
05723 /* Line 1806 of yacc.c  */
05724 #line 1345 "ripper.y"
05725     {
05726 #if 0
05727                         block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
05728                         (yyvsp[(3) - (3)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05729                         (yyval.val) = (yyvsp[(3) - (3)].val);
05730                         fixpos((yyval.val), (yyvsp[(2) - (3)].val));
05731 #endif
05732                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05733                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
05734 
05735                     }
05736     break;
05737 
05738   case 59:
05739 
05740 /* Line 1806 of yacc.c  */
05741 #line 1357 "ripper.y"
05742     {
05743 #if 0
05744                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05745                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05746 #endif
05747                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05748 
05749                     }
05750     break;
05751 
05752   case 60:
05753 
05754 /* Line 1806 of yacc.c  */
05755 #line 1366 "ripper.y"
05756     {
05757 #if 0
05758                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05759                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05760                         (yyval.val) = (yyvsp[(5) - (5)].val);
05761                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05762 #endif
05763                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05764                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05765 
05766                    }
05767     break;
05768 
05769   case 61:
05770 
05771 /* Line 1806 of yacc.c  */
05772 #line 1378 "ripper.y"
05773     {
05774 #if 0
05775                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05776                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05777 #endif
05778                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05779 
05780                     }
05781     break;
05782 
05783   case 62:
05784 
05785 /* Line 1806 of yacc.c  */
05786 #line 1387 "ripper.y"
05787     {
05788 #if 0
05789                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05790                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05791                         (yyval.val) = (yyvsp[(5) - (5)].val);
05792                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05793 #endif
05794                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05795                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05796 
05797                    }
05798     break;
05799 
05800   case 63:
05801 
05802 /* Line 1806 of yacc.c  */
05803 #line 1399 "ripper.y"
05804     {
05805 #if 0
05806                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
05807                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05808 #endif
05809                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
05810 
05811                     }
05812     break;
05813 
05814   case 64:
05815 
05816 /* Line 1806 of yacc.c  */
05817 #line 1408 "ripper.y"
05818     {
05819 #if 0
05820                         (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
05821                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05822 #endif
05823                         (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
05824 
05825                     }
05826     break;
05827 
05828   case 65:
05829 
05830 /* Line 1806 of yacc.c  */
05831 #line 1417 "ripper.y"
05832     {
05833 #if 0
05834                         (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
05835 #endif
05836                         (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
05837 
05838                     }
05839     break;
05840 
05841   case 66:
05842 
05843 /* Line 1806 of yacc.c  */
05844 #line 1425 "ripper.y"
05845     {
05846 #if 0
05847                         (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
05848 #endif
05849                         (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
05850 
05851                     }
05852     break;
05853 
05854   case 67:
05855 
05856 /* Line 1806 of yacc.c  */
05857 #line 1433 "ripper.y"
05858     {
05859 #if 0
05860                         (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
05861 #endif
05862                         (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
05863 
05864                     }
05865     break;
05866 
05867   case 69:
05868 
05869 /* Line 1806 of yacc.c  */
05870 #line 1444 "ripper.y"
05871     {
05872 #if 0
05873                         (yyval.val) = (yyvsp[(2) - (3)].val);
05874 #endif
05875                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
05876 
05877                     }
05878     break;
05879 
05880   case 71:
05881 
05882 /* Line 1806 of yacc.c  */
05883 #line 1455 "ripper.y"
05884     {
05885 #if 0
05886                         (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
05887 #endif
05888                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
05889 
05890                     }
05891     break;
05892 
05893   case 72:
05894 
05895 /* Line 1806 of yacc.c  */
05896 #line 1465 "ripper.y"
05897     {
05898 #if 0
05899                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
05900 #endif
05901                         (yyval.val) = (yyvsp[(1) - (1)].val);
05902 
05903                     }
05904     break;
05905 
05906   case 73:
05907 
05908 /* Line 1806 of yacc.c  */
05909 #line 1473 "ripper.y"
05910     {
05911 #if 0
05912                         (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
05913 #endif
05914                         (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05915 
05916                     }
05917     break;
05918 
05919   case 74:
05920 
05921 /* Line 1806 of yacc.c  */
05922 #line 1481 "ripper.y"
05923     {
05924 #if 0
05925                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05926 #endif
05927                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05928 
05929                     }
05930     break;
05931 
05932   case 75:
05933 
05934 /* Line 1806 of yacc.c  */
05935 #line 1489 "ripper.y"
05936     {
05937 #if 0
05938                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
05939 #endif
05940                         (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05941                         (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
05942 
05943                     }
05944     break;
05945 
05946   case 76:
05947 
05948 /* Line 1806 of yacc.c  */
05949 #line 1498 "ripper.y"
05950     {
05951 #if 0
05952                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
05953 #endif
05954                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
05955 
05956                     }
05957     break;
05958 
05959   case 77:
05960 
05961 /* Line 1806 of yacc.c  */
05962 #line 1506 "ripper.y"
05963     {
05964 #if 0
05965                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
05966 #endif
05967                         (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
05968                         (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
05969 
05970                     }
05971     break;
05972 
05973   case 78:
05974 
05975 /* Line 1806 of yacc.c  */
05976 #line 1515 "ripper.y"
05977     {
05978 #if 0
05979                         (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
05980 #endif
05981                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
05982 
05983                     }
05984     break;
05985 
05986   case 79:
05987 
05988 /* Line 1806 of yacc.c  */
05989 #line 1523 "ripper.y"
05990     {
05991 #if 0
05992                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
05993 #endif
05994                         (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
05995                         (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05996 
05997                     }
05998     break;
05999 
06000   case 80:
06001 
06002 /* Line 1806 of yacc.c  */
06003 #line 1532 "ripper.y"
06004     {
06005 #if 0
06006                         (yyval.val) = NEW_MASGN(0, -1);
06007 #endif
06008                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06009 
06010                     }
06011     break;
06012 
06013   case 81:
06014 
06015 /* Line 1806 of yacc.c  */
06016 #line 1540 "ripper.y"
06017     {
06018 #if 0
06019                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
06020 #endif
06021                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06022                         (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
06023 
06024                     }
06025     break;
06026 
06027   case 83:
06028 
06029 /* Line 1806 of yacc.c  */
06030 #line 1552 "ripper.y"
06031     {
06032 #if 0
06033                         (yyval.val) = (yyvsp[(2) - (3)].val);
06034 #endif
06035                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06036 
06037                     }
06038     break;
06039 
06040   case 84:
06041 
06042 /* Line 1806 of yacc.c  */
06043 #line 1562 "ripper.y"
06044     {
06045 #if 0
06046                         (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
06047 #endif
06048                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
06049 
06050                     }
06051     break;
06052 
06053   case 85:
06054 
06055 /* Line 1806 of yacc.c  */
06056 #line 1570 "ripper.y"
06057     {
06058 #if 0
06059                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06060 #endif
06061                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06062 
06063                     }
06064     break;
06065 
06066   case 86:
06067 
06068 /* Line 1806 of yacc.c  */
06069 #line 1580 "ripper.y"
06070     {
06071 #if 0
06072                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
06073 #endif
06074                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
06075 
06076                     }
06077     break;
06078 
06079   case 87:
06080 
06081 /* Line 1806 of yacc.c  */
06082 #line 1588 "ripper.y"
06083     {
06084 #if 0
06085                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06086 #endif
06087                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06088 
06089                     }
06090     break;
06091 
06092   case 88:
06093 
06094 /* Line 1806 of yacc.c  */
06095 #line 1598 "ripper.y"
06096     {
06097                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06098                     }
06099     break;
06100 
06101   case 89:
06102 
06103 /* Line 1806 of yacc.c  */
06104 #line 1602 "ripper.y"
06105     {
06106 #if 0
06107                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06108 #endif
06109                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06110 
06111                     }
06112     break;
06113 
06114   case 90:
06115 
06116 /* Line 1806 of yacc.c  */
06117 #line 1610 "ripper.y"
06118     {
06119 #if 0
06120                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06121 #endif
06122                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06123 
06124                     }
06125     break;
06126 
06127   case 91:
06128 
06129 /* Line 1806 of yacc.c  */
06130 #line 1618 "ripper.y"
06131     {
06132 #if 0
06133                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06134 #endif
06135                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06136 
06137                     }
06138     break;
06139 
06140   case 92:
06141 
06142 /* Line 1806 of yacc.c  */
06143 #line 1626 "ripper.y"
06144     {
06145 #if 0
06146                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06147 #endif
06148                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06149 
06150                     }
06151     break;
06152 
06153   case 93:
06154 
06155 /* Line 1806 of yacc.c  */
06156 #line 1634 "ripper.y"
06157     {
06158 #if 0
06159                         if (in_def || in_single)
06160                             yyerror("dynamic constant assignment");
06161                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06162 #endif
06163                         if (in_def || in_single)
06164                             yyerror("dynamic constant assignment");
06165                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06166 
06167                     }
06168     break;
06169 
06170   case 94:
06171 
06172 /* Line 1806 of yacc.c  */
06173 #line 1646 "ripper.y"
06174     {
06175 #if 0
06176                         if (in_def || in_single)
06177                             yyerror("dynamic constant assignment");
06178                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06179 #endif
06180                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06181 
06182                     }
06183     break;
06184 
06185   case 95:
06186 
06187 /* Line 1806 of yacc.c  */
06188 #line 1656 "ripper.y"
06189     {
06190 #if 0
06191                         rb_backref_error((yyvsp[(1) - (1)].val));
06192                         (yyval.val) = NEW_BEGIN(0);
06193 #endif
06194                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
06195                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06196 
06197                     }
06198     break;
06199 
06200   case 96:
06201 
06202 /* Line 1806 of yacc.c  */
06203 #line 1668 "ripper.y"
06204     {
06205                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06206 #if 0
06207                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06208 #endif
06209                         (yyval.val) = dispatch1(var_field, (yyval.val));
06210 
06211                     }
06212     break;
06213 
06214   case 97:
06215 
06216 /* Line 1806 of yacc.c  */
06217 #line 1677 "ripper.y"
06218     {
06219 #if 0
06220                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06221 #endif
06222                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06223 
06224                     }
06225     break;
06226 
06227   case 98:
06228 
06229 /* Line 1806 of yacc.c  */
06230 #line 1685 "ripper.y"
06231     {
06232 #if 0
06233                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06234 #endif
06235                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06236 
06237                     }
06238     break;
06239 
06240   case 99:
06241 
06242 /* Line 1806 of yacc.c  */
06243 #line 1693 "ripper.y"
06244     {
06245 #if 0
06246                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06247 #endif
06248                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
06249 
06250                     }
06251     break;
06252 
06253   case 100:
06254 
06255 /* Line 1806 of yacc.c  */
06256 #line 1701 "ripper.y"
06257     {
06258 #if 0
06259                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06260 #endif
06261                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06262 
06263                     }
06264     break;
06265 
06266   case 101:
06267 
06268 /* Line 1806 of yacc.c  */
06269 #line 1709 "ripper.y"
06270     {
06271 #if 0
06272                         if (in_def || in_single)
06273                             yyerror("dynamic constant assignment");
06274                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06275 #endif
06276                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06277                         if (in_def || in_single) {
06278                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06279                         }
06280 
06281                     }
06282     break;
06283 
06284   case 102:
06285 
06286 /* Line 1806 of yacc.c  */
06287 #line 1722 "ripper.y"
06288     {
06289 #if 0
06290                         if (in_def || in_single)
06291                             yyerror("dynamic constant assignment");
06292                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06293 #endif
06294                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06295                         if (in_def || in_single) {
06296                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06297                         }
06298 
06299                     }
06300     break;
06301 
06302   case 103:
06303 
06304 /* Line 1806 of yacc.c  */
06305 #line 1735 "ripper.y"
06306     {
06307 #if 0
06308                         rb_backref_error((yyvsp[(1) - (1)].val));
06309                         (yyval.val) = NEW_BEGIN(0);
06310 #endif
06311                         (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
06312 
06313                     }
06314     break;
06315 
06316   case 104:
06317 
06318 /* Line 1806 of yacc.c  */
06319 #line 1746 "ripper.y"
06320     {
06321 #if 0
06322                         yyerror("class/module name must be CONSTANT");
06323 #endif
06324                         (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
06325 
06326                     }
06327     break;
06328 
06329   case 106:
06330 
06331 /* Line 1806 of yacc.c  */
06332 #line 1757 "ripper.y"
06333     {
06334 #if 0
06335                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
06336 #endif
06337                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
06338 
06339                     }
06340     break;
06341 
06342   case 107:
06343 
06344 /* Line 1806 of yacc.c  */
06345 #line 1765 "ripper.y"
06346     {
06347 #if 0
06348                         (yyval.val) = NEW_COLON2(0, (yyval.val));
06349 #endif
06350                         (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
06351 
06352                     }
06353     break;
06354 
06355   case 108:
06356 
06357 /* Line 1806 of yacc.c  */
06358 #line 1773 "ripper.y"
06359     {
06360 #if 0
06361                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06362 #endif
06363                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06364 
06365                     }
06366     break;
06367 
06368   case 112:
06369 
06370 /* Line 1806 of yacc.c  */
06371 #line 1786 "ripper.y"
06372     {
06373                         lex_state = EXPR_ENDFN;
06374                         (yyval.val) = (yyvsp[(1) - (1)].val);
06375                     }
06376     break;
06377 
06378   case 113:
06379 
06380 /* Line 1806 of yacc.c  */
06381 #line 1791 "ripper.y"
06382     {
06383                         lex_state = EXPR_ENDFN;
06384 #if 0
06385                         (yyval.val) = (yyvsp[(1) - (1)].id);
06386 #endif
06387                         (yyval.val) = (yyvsp[(1) - (1)].val);
06388 
06389                     }
06390     break;
06391 
06392   case 116:
06393 
06394 /* Line 1806 of yacc.c  */
06395 #line 1806 "ripper.y"
06396     {
06397 #if 0
06398                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
06399 #endif
06400                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
06401 
06402                     }
06403     break;
06404 
06405   case 118:
06406 
06407 /* Line 1806 of yacc.c  */
06408 #line 1817 "ripper.y"
06409     {
06410 #if 0
06411                         (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
06412 #endif
06413                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
06414 
06415                     }
06416     break;
06417 
06418   case 119:
06419 
06420 /* Line 1806 of yacc.c  */
06421 #line 1824 "ripper.y"
06422     {lex_state = EXPR_FNAME;}
06423     break;
06424 
06425   case 120:
06426 
06427 /* Line 1806 of yacc.c  */
06428 #line 1825 "ripper.y"
06429     {
06430 #if 0
06431                         (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
06432 #endif
06433                         rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06434 
06435                     }
06436     break;
06437 
06438   case 121:
06439 
06440 /* Line 1806 of yacc.c  */
06441 #line 1834 "ripper.y"
06442     { ifndef_ripper((yyval.val) = '|'); }
06443     break;
06444 
06445   case 122:
06446 
06447 /* Line 1806 of yacc.c  */
06448 #line 1835 "ripper.y"
06449     { ifndef_ripper((yyval.val) = '^'); }
06450     break;
06451 
06452   case 123:
06453 
06454 /* Line 1806 of yacc.c  */
06455 #line 1836 "ripper.y"
06456     { ifndef_ripper((yyval.val) = '&'); }
06457     break;
06458 
06459   case 124:
06460 
06461 /* Line 1806 of yacc.c  */
06462 #line 1837 "ripper.y"
06463     { ifndef_ripper((yyval.val) = tCMP); }
06464     break;
06465 
06466   case 125:
06467 
06468 /* Line 1806 of yacc.c  */
06469 #line 1838 "ripper.y"
06470     { ifndef_ripper((yyval.val) = tEQ); }
06471     break;
06472 
06473   case 126:
06474 
06475 /* Line 1806 of yacc.c  */
06476 #line 1839 "ripper.y"
06477     { ifndef_ripper((yyval.val) = tEQQ); }
06478     break;
06479 
06480   case 127:
06481 
06482 /* Line 1806 of yacc.c  */
06483 #line 1840 "ripper.y"
06484     { ifndef_ripper((yyval.val) = tMATCH); }
06485     break;
06486 
06487   case 128:
06488 
06489 /* Line 1806 of yacc.c  */
06490 #line 1841 "ripper.y"
06491     { ifndef_ripper((yyval.val) = tNMATCH); }
06492     break;
06493 
06494   case 129:
06495 
06496 /* Line 1806 of yacc.c  */
06497 #line 1842 "ripper.y"
06498     { ifndef_ripper((yyval.val) = '>'); }
06499     break;
06500 
06501   case 130:
06502 
06503 /* Line 1806 of yacc.c  */
06504 #line 1843 "ripper.y"
06505     { ifndef_ripper((yyval.val) = tGEQ); }
06506     break;
06507 
06508   case 131:
06509 
06510 /* Line 1806 of yacc.c  */
06511 #line 1844 "ripper.y"
06512     { ifndef_ripper((yyval.val) = '<'); }
06513     break;
06514 
06515   case 132:
06516 
06517 /* Line 1806 of yacc.c  */
06518 #line 1845 "ripper.y"
06519     { ifndef_ripper((yyval.val) = tLEQ); }
06520     break;
06521 
06522   case 133:
06523 
06524 /* Line 1806 of yacc.c  */
06525 #line 1846 "ripper.y"
06526     { ifndef_ripper((yyval.val) = tNEQ); }
06527     break;
06528 
06529   case 134:
06530 
06531 /* Line 1806 of yacc.c  */
06532 #line 1847 "ripper.y"
06533     { ifndef_ripper((yyval.val) = tLSHFT); }
06534     break;
06535 
06536   case 135:
06537 
06538 /* Line 1806 of yacc.c  */
06539 #line 1848 "ripper.y"
06540     { ifndef_ripper((yyval.val) = tRSHFT); }
06541     break;
06542 
06543   case 136:
06544 
06545 /* Line 1806 of yacc.c  */
06546 #line 1849 "ripper.y"
06547     { ifndef_ripper((yyval.val) = '+'); }
06548     break;
06549 
06550   case 137:
06551 
06552 /* Line 1806 of yacc.c  */
06553 #line 1850 "ripper.y"
06554     { ifndef_ripper((yyval.val) = '-'); }
06555     break;
06556 
06557   case 138:
06558 
06559 /* Line 1806 of yacc.c  */
06560 #line 1851 "ripper.y"
06561     { ifndef_ripper((yyval.val) = '*'); }
06562     break;
06563 
06564   case 139:
06565 
06566 /* Line 1806 of yacc.c  */
06567 #line 1852 "ripper.y"
06568     { ifndef_ripper((yyval.val) = '*'); }
06569     break;
06570 
06571   case 140:
06572 
06573 /* Line 1806 of yacc.c  */
06574 #line 1853 "ripper.y"
06575     { ifndef_ripper((yyval.val) = '/'); }
06576     break;
06577 
06578   case 141:
06579 
06580 /* Line 1806 of yacc.c  */
06581 #line 1854 "ripper.y"
06582     { ifndef_ripper((yyval.val) = '%'); }
06583     break;
06584 
06585   case 142:
06586 
06587 /* Line 1806 of yacc.c  */
06588 #line 1855 "ripper.y"
06589     { ifndef_ripper((yyval.val) = tPOW); }
06590     break;
06591 
06592   case 143:
06593 
06594 /* Line 1806 of yacc.c  */
06595 #line 1856 "ripper.y"
06596     { ifndef_ripper((yyval.val) = '!'); }
06597     break;
06598 
06599   case 144:
06600 
06601 /* Line 1806 of yacc.c  */
06602 #line 1857 "ripper.y"
06603     { ifndef_ripper((yyval.val) = '~'); }
06604     break;
06605 
06606   case 145:
06607 
06608 /* Line 1806 of yacc.c  */
06609 #line 1858 "ripper.y"
06610     { ifndef_ripper((yyval.val) = tUPLUS); }
06611     break;
06612 
06613   case 146:
06614 
06615 /* Line 1806 of yacc.c  */
06616 #line 1859 "ripper.y"
06617     { ifndef_ripper((yyval.val) = tUMINUS); }
06618     break;
06619 
06620   case 147:
06621 
06622 /* Line 1806 of yacc.c  */
06623 #line 1860 "ripper.y"
06624     { ifndef_ripper((yyval.val) = tAREF); }
06625     break;
06626 
06627   case 148:
06628 
06629 /* Line 1806 of yacc.c  */
06630 #line 1861 "ripper.y"
06631     { ifndef_ripper((yyval.val) = tASET); }
06632     break;
06633 
06634   case 149:
06635 
06636 /* Line 1806 of yacc.c  */
06637 #line 1862 "ripper.y"
06638     { ifndef_ripper((yyval.val) = '`'); }
06639     break;
06640 
06641   case 191:
06642 
06643 /* Line 1806 of yacc.c  */
06644 #line 1880 "ripper.y"
06645     {
06646 #if 0
06647                         value_expr((yyvsp[(3) - (3)].val));
06648                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06649 #endif
06650                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06651 
06652                     }
06653     break;
06654 
06655   case 192:
06656 
06657 /* Line 1806 of yacc.c  */
06658 #line 1889 "ripper.y"
06659     {
06660 #if 0
06661                         value_expr((yyvsp[(3) - (5)].val));
06662                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06663                         (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06664 #endif
06665                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
06666 
06667                     }
06668     break;
06669 
06670   case 193:
06671 
06672 /* Line 1806 of yacc.c  */
06673 #line 1899 "ripper.y"
06674     {
06675 #if 0
06676                         value_expr((yyvsp[(3) - (3)].val));
06677                         if ((yyvsp[(1) - (3)].val)) {
06678                             ID vid = (yyvsp[(1) - (3)].val)->nd_vid;
06679                             if ((yyvsp[(2) - (3)].val) == tOROP) {
06680                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
06681                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].val));
06682                                 if (is_asgn_or_id(vid)) {
06683                                     (yyval.val)->nd_aid = vid;
06684                                 }
06685                             }
06686                             else if ((yyvsp[(2) - (3)].val) == tANDOP) {
06687                                 (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
06688                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].val));
06689                             }
06690                             else {
06691                                 (yyval.val) = (yyvsp[(1) - (3)].val);
06692                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].val), NEW_LIST((yyvsp[(3) - (3)].val)));
06693                             }
06694                         }
06695                         else {
06696                             (yyval.val) = NEW_BEGIN(0);
06697                         }
06698 #endif
06699                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06700 
06701                     }
06702     break;
06703 
06704   case 194:
06705 
06706 /* Line 1806 of yacc.c  */
06707 #line 1928 "ripper.y"
06708     {
06709 #if 0
06710                         value_expr((yyvsp[(3) - (5)].val));
06711                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06712                         if ((yyvsp[(1) - (5)].val)) {
06713                             ID vid = (yyvsp[(1) - (5)].val)->nd_vid;
06714                             if ((yyvsp[(2) - (5)].val) == tOROP) {
06715                                 (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
06716                                 (yyval.val) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (5)].val));
06717                                 if (is_asgn_or_id(vid)) {
06718                                     (yyval.val)->nd_aid = vid;
06719                                 }
06720                             }
06721                             else if ((yyvsp[(2) - (5)].val) == tANDOP) {
06722                                 (yyvsp[(1) - (5)].val)->nd_value = (yyvsp[(3) - (5)].val);
06723                                 (yyval.val) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (5)].val));
06724                             }
06725                             else {
06726                                 (yyval.val) = (yyvsp[(1) - (5)].val);
06727                                 (yyval.val)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (5)].val), NEW_LIST((yyvsp[(3) - (5)].val)));
06728                             }
06729                         }
06730                         else {
06731                             (yyval.val) = NEW_BEGIN(0);
06732                         }
06733 #endif
06734                         (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
06735                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
06736 
06737                     }
06738     break;
06739 
06740   case 195:
06741 
06742 /* Line 1806 of yacc.c  */
06743 #line 1959 "ripper.y"
06744     {
06745 #if 0
06746                         NODE *args;
06747 
06748                         value_expr((yyvsp[(6) - (6)].val));
06749                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
06750                         if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
06751                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06752                         }
06753                         else {
06754                             args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06755                         }
06756                         if ((yyvsp[(5) - (6)].val) == tOROP) {
06757                             (yyvsp[(5) - (6)].val) = 0;
06758                         }
06759                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
06760                             (yyvsp[(5) - (6)].val) = 1;
06761                         }
06762                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
06763                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
06764 #endif
06765                         (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
06766                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
06767 
06768                     }
06769     break;
06770 
06771   case 196:
06772 
06773 /* Line 1806 of yacc.c  */
06774 #line 1985 "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 197:
06794 
06795 /* Line 1806 of yacc.c  */
06796 #line 2002 "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_id2sym('.'), (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 198:
06816 
06817 /* Line 1806 of yacc.c  */
06818 #line 2019 "ripper.y"
06819     {
06820 #if 0
06821                         value_expr((yyvsp[(5) - (5)].val));
06822                         if ((yyvsp[(4) - (5)].val) == tOROP) {
06823                             (yyvsp[(4) - (5)].val) = 0;
06824                         }
06825                         else if ((yyvsp[(4) - (5)].val) == tANDOP) {
06826                             (yyvsp[(4) - (5)].val) = 1;
06827                         }
06828                         (yyval.val) = NEW_OP_ASGN2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06829                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
06830 #endif
06831                         (yyvsp[(1) - (5)].val) = dispatch3(field, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val));
06832                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06833 
06834                     }
06835     break;
06836 
06837   case 199:
06838 
06839 /* Line 1806 of yacc.c  */
06840 #line 2036 "ripper.y"
06841     {
06842 #if 0
06843                         yyerror("constant re-assignment");
06844                         (yyval.val) = NEW_BEGIN(0);
06845 #endif
06846                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06847                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06848                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06849 
06850                     }
06851     break;
06852 
06853   case 200:
06854 
06855 /* Line 1806 of yacc.c  */
06856 #line 2047 "ripper.y"
06857     {
06858 #if 0
06859                         yyerror("constant re-assignment");
06860                         (yyval.val) = NEW_BEGIN(0);
06861 #endif
06862                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
06863                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06864                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06865 
06866                     }
06867     break;
06868 
06869   case 201:
06870 
06871 /* Line 1806 of yacc.c  */
06872 #line 2058 "ripper.y"
06873     {
06874 #if 0
06875                         rb_backref_error((yyvsp[(1) - (3)].val));
06876                         (yyval.val) = NEW_BEGIN(0);
06877 #endif
06878                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
06879                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06880                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06881 
06882                     }
06883     break;
06884 
06885   case 202:
06886 
06887 /* Line 1806 of yacc.c  */
06888 #line 2069 "ripper.y"
06889     {
06890 #if 0
06891                         value_expr((yyvsp[(1) - (3)].val));
06892                         value_expr((yyvsp[(3) - (3)].val));
06893                         (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06894                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06895                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06896                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06897                         }
06898 #endif
06899                         (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06900 
06901                     }
06902     break;
06903 
06904   case 203:
06905 
06906 /* Line 1806 of yacc.c  */
06907 #line 2083 "ripper.y"
06908     {
06909 #if 0
06910                         value_expr((yyvsp[(1) - (3)].val));
06911                         value_expr((yyvsp[(3) - (3)].val));
06912                         (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06913                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06914                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06915                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06916                         }
06917 #endif
06918                         (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06919 
06920                     }
06921     break;
06922 
06923   case 204:
06924 
06925 /* Line 1806 of yacc.c  */
06926 #line 2097 "ripper.y"
06927     {
06928 #if 0
06929                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
06930 #endif
06931                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
06932 
06933                     }
06934     break;
06935 
06936   case 205:
06937 
06938 /* Line 1806 of yacc.c  */
06939 #line 2105 "ripper.y"
06940     {
06941 #if 0
06942                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
06943 #endif
06944                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
06945 
06946                     }
06947     break;
06948 
06949   case 206:
06950 
06951 /* Line 1806 of yacc.c  */
06952 #line 2113 "ripper.y"
06953     {
06954 #if 0
06955                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
06956 #endif
06957                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
06958 
06959                     }
06960     break;
06961 
06962   case 207:
06963 
06964 /* Line 1806 of yacc.c  */
06965 #line 2121 "ripper.y"
06966     {
06967 #if 0
06968                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
06969 #endif
06970                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
06971 
06972                     }
06973     break;
06974 
06975   case 208:
06976 
06977 /* Line 1806 of yacc.c  */
06978 #line 2129 "ripper.y"
06979     {
06980 #if 0
06981                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
06982 #endif
06983                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
06984 
06985                     }
06986     break;
06987 
06988   case 209:
06989 
06990 /* Line 1806 of yacc.c  */
06991 #line 2137 "ripper.y"
06992     {
06993 #if 0
06994                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
06995 #endif
06996                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
06997 
06998                     }
06999     break;
07000 
07001   case 210:
07002 
07003 /* Line 1806 of yacc.c  */
07004 #line 2145 "ripper.y"
07005     {
07006 #if 0
07007                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
07008 #endif
07009                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
07010                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
07011 
07012                     }
07013     break;
07014 
07015   case 211:
07016 
07017 /* Line 1806 of yacc.c  */
07018 #line 2154 "ripper.y"
07019     {
07020 #if 0
07021                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
07022 #endif
07023                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
07024                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
07025 
07026                     }
07027     break;
07028 
07029   case 212:
07030 
07031 /* Line 1806 of yacc.c  */
07032 #line 2163 "ripper.y"
07033     {
07034 #if 0
07035                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
07036 #endif
07037                         (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
07038 
07039                     }
07040     break;
07041 
07042   case 213:
07043 
07044 /* Line 1806 of yacc.c  */
07045 #line 2171 "ripper.y"
07046     {
07047 #if 0
07048                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
07049 #endif
07050                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
07051 
07052                     }
07053     break;
07054 
07055   case 214:
07056 
07057 /* Line 1806 of yacc.c  */
07058 #line 2179 "ripper.y"
07059     {
07060 #if 0
07061                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
07062 #endif
07063                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
07064 
07065                     }
07066     break;
07067 
07068   case 215:
07069 
07070 /* Line 1806 of yacc.c  */
07071 #line 2187 "ripper.y"
07072     {
07073 #if 0
07074                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
07075 #endif
07076                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
07077 
07078                     }
07079     break;
07080 
07081   case 216:
07082 
07083 /* Line 1806 of yacc.c  */
07084 #line 2195 "ripper.y"
07085     {
07086 #if 0
07087                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
07088 #endif
07089                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
07090 
07091                     }
07092     break;
07093 
07094   case 217:
07095 
07096 /* Line 1806 of yacc.c  */
07097 #line 2203 "ripper.y"
07098     {
07099 #if 0
07100                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
07101 #endif
07102                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
07103 
07104                     }
07105     break;
07106 
07107   case 218:
07108 
07109 /* Line 1806 of yacc.c  */
07110 #line 2211 "ripper.y"
07111     {
07112 #if 0
07113                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
07114 #endif
07115                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
07116 
07117                     }
07118     break;
07119 
07120   case 219:
07121 
07122 /* Line 1806 of yacc.c  */
07123 #line 2219 "ripper.y"
07124     {
07125 #if 0
07126                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
07127 #endif
07128                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
07129 
07130                     }
07131     break;
07132 
07133   case 220:
07134 
07135 /* Line 1806 of yacc.c  */
07136 #line 2227 "ripper.y"
07137     {
07138 #if 0
07139                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
07140 #endif
07141                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
07142 
07143                     }
07144     break;
07145 
07146   case 221:
07147 
07148 /* Line 1806 of yacc.c  */
07149 #line 2235 "ripper.y"
07150     {
07151 #if 0
07152                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
07153 #endif
07154                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
07155 
07156                     }
07157     break;
07158 
07159   case 222:
07160 
07161 /* Line 1806 of yacc.c  */
07162 #line 2243 "ripper.y"
07163     {
07164 #if 0
07165                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
07166 #endif
07167                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
07168 
07169                     }
07170     break;
07171 
07172   case 223:
07173 
07174 /* Line 1806 of yacc.c  */
07175 #line 2251 "ripper.y"
07176     {
07177 #if 0
07178                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
07179 #endif
07180                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
07181 
07182                     }
07183     break;
07184 
07185   case 224:
07186 
07187 /* Line 1806 of yacc.c  */
07188 #line 2259 "ripper.y"
07189     {
07190 #if 0
07191                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
07192 #endif
07193                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
07194 
07195                     }
07196     break;
07197 
07198   case 225:
07199 
07200 /* Line 1806 of yacc.c  */
07201 #line 2267 "ripper.y"
07202     {
07203 #if 0
07204                         (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07205                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && TYPE((yyvsp[(1) - (3)].val)->nd_lit) == T_REGEXP) {
07206                             (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
07207                         }
07208 #endif
07209                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
07210 
07211                     }
07212     break;
07213 
07214   case 226:
07215 
07216 /* Line 1806 of yacc.c  */
07217 #line 2278 "ripper.y"
07218     {
07219 #if 0
07220                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
07221 #endif
07222                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
07223 
07224                     }
07225     break;
07226 
07227   case 227:
07228 
07229 /* Line 1806 of yacc.c  */
07230 #line 2286 "ripper.y"
07231     {
07232 #if 0
07233                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
07234 #endif
07235                         (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
07236 
07237                     }
07238     break;
07239 
07240   case 228:
07241 
07242 /* Line 1806 of yacc.c  */
07243 #line 2294 "ripper.y"
07244     {
07245 #if 0
07246                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
07247 #endif
07248                         (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
07249 
07250                     }
07251     break;
07252 
07253   case 229:
07254 
07255 /* Line 1806 of yacc.c  */
07256 #line 2302 "ripper.y"
07257     {
07258 #if 0
07259                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
07260 #endif
07261                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
07262 
07263                     }
07264     break;
07265 
07266   case 230:
07267 
07268 /* Line 1806 of yacc.c  */
07269 #line 2310 "ripper.y"
07270     {
07271 #if 0
07272                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
07273 #endif
07274                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
07275 
07276                     }
07277     break;
07278 
07279   case 231:
07280 
07281 /* Line 1806 of yacc.c  */
07282 #line 2318 "ripper.y"
07283     {
07284 #if 0
07285                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07286 #endif
07287                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
07288 
07289                     }
07290     break;
07291 
07292   case 232:
07293 
07294 /* Line 1806 of yacc.c  */
07295 #line 2326 "ripper.y"
07296     {
07297 #if 0
07298                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07299 #endif
07300                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
07301 
07302                     }
07303     break;
07304 
07305   case 233:
07306 
07307 /* Line 1806 of yacc.c  */
07308 #line 2333 "ripper.y"
07309     {in_defined = 1;}
07310     break;
07311 
07312   case 234:
07313 
07314 /* Line 1806 of yacc.c  */
07315 #line 2334 "ripper.y"
07316     {
07317 #if 0
07318                         in_defined = 0;
07319                         (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
07320 #endif
07321                         in_defined = 0;
07322                         (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
07323 
07324                     }
07325     break;
07326 
07327   case 235:
07328 
07329 /* Line 1806 of yacc.c  */
07330 #line 2344 "ripper.y"
07331     {
07332 #if 0
07333                         value_expr((yyvsp[(1) - (6)].val));
07334                         (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07335                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
07336 #endif
07337                         (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07338 
07339                     }
07340     break;
07341 
07342   case 236:
07343 
07344 /* Line 1806 of yacc.c  */
07345 #line 2354 "ripper.y"
07346     {
07347                         (yyval.val) = (yyvsp[(1) - (1)].val);
07348                     }
07349     break;
07350 
07351   case 237:
07352 
07353 /* Line 1806 of yacc.c  */
07354 #line 2360 "ripper.y"
07355     {
07356 #if 0
07357                         value_expr((yyvsp[(1) - (1)].val));
07358                         (yyval.val) = (yyvsp[(1) - (1)].val);
07359                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
07360 #endif
07361                         (yyval.val) = (yyvsp[(1) - (1)].val);
07362 
07363                     }
07364     break;
07365 
07366   case 239:
07367 
07368 /* Line 1806 of yacc.c  */
07369 #line 2373 "ripper.y"
07370     {
07371                         (yyval.val) = (yyvsp[(1) - (2)].val);
07372                     }
07373     break;
07374 
07375   case 240:
07376 
07377 /* Line 1806 of yacc.c  */
07378 #line 2377 "ripper.y"
07379     {
07380 #if 0
07381                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07382 #endif
07383                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07384 
07385                     }
07386     break;
07387 
07388   case 241:
07389 
07390 /* Line 1806 of yacc.c  */
07391 #line 2385 "ripper.y"
07392     {
07393 #if 0
07394                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07395 #endif
07396                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07397 
07398                     }
07399     break;
07400 
07401   case 242:
07402 
07403 /* Line 1806 of yacc.c  */
07404 #line 2395 "ripper.y"
07405     {
07406 #if 0
07407                         (yyval.val) = (yyvsp[(2) - (3)].val);
07408 #endif
07409                         (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
07410 
07411                     }
07412     break;
07413 
07414   case 247:
07415 
07416 /* Line 1806 of yacc.c  */
07417 #line 2413 "ripper.y"
07418     {
07419 #if 0
07420                         value_expr((yyvsp[(1) - (1)].val));
07421                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07422 #endif
07423                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07424 
07425                     }
07426     break;
07427 
07428   case 248:
07429 
07430 /* Line 1806 of yacc.c  */
07431 #line 2422 "ripper.y"
07432     {
07433 #if 0
07434                         (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07435 #endif
07436                         (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07437 
07438                     }
07439     break;
07440 
07441   case 249:
07442 
07443 /* Line 1806 of yacc.c  */
07444 #line 2430 "ripper.y"
07445     {
07446 #if 0
07447                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07448                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
07449 #endif
07450                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07451                         (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
07452 
07453                     }
07454     break;
07455 
07456   case 250:
07457 
07458 /* Line 1806 of yacc.c  */
07459 #line 2440 "ripper.y"
07460     {
07461 #if 0
07462                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07463                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
07464 #endif
07465                         (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
07466 
07467                     }
07468     break;
07469 
07470   case 251:
07471 
07472 /* Line 1806 of yacc.c  */
07473 #line 2451 "ripper.y"
07474     {
07475                         (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
07476                     }
07477     break;
07478 
07479   case 252:
07480 
07481 /* Line 1806 of yacc.c  */
07482 #line 2457 "ripper.y"
07483     {
07484                         (yyval.val) = cmdarg_stack;
07485                         CMDARG_PUSH(1);
07486                     }
07487     break;
07488 
07489   case 253:
07490 
07491 /* Line 1806 of yacc.c  */
07492 #line 2462 "ripper.y"
07493     {
07494                         /* CMDARG_POP() */
07495                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07496                         (yyval.val) = (yyvsp[(2) - (2)].val);
07497                     }
07498     break;
07499 
07500   case 254:
07501 
07502 /* Line 1806 of yacc.c  */
07503 #line 2470 "ripper.y"
07504     {
07505 #if 0
07506                         (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
07507 #endif
07508                         (yyval.val) = (yyvsp[(2) - (2)].val);
07509 
07510                     }
07511     break;
07512 
07513   case 255:
07514 
07515 /* Line 1806 of yacc.c  */
07516 #line 2480 "ripper.y"
07517     {
07518                         (yyval.val) = (yyvsp[(2) - (2)].val);
07519                     }
07520     break;
07521 
07522   case 256:
07523 
07524 /* Line 1806 of yacc.c  */
07525 #line 2484 "ripper.y"
07526     {
07527                         (yyval.val) = 0;
07528                     }
07529     break;
07530 
07531   case 257:
07532 
07533 /* Line 1806 of yacc.c  */
07534 #line 2488 "ripper.y"
07535     {
07536                         (yyval.val) = 0;
07537                     }
07538     break;
07539 
07540   case 258:
07541 
07542 /* Line 1806 of yacc.c  */
07543 #line 2494 "ripper.y"
07544     {
07545 #if 0
07546                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07547 #endif
07548                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07549 
07550                     }
07551     break;
07552 
07553   case 259:
07554 
07555 /* Line 1806 of yacc.c  */
07556 #line 2502 "ripper.y"
07557     {
07558 #if 0
07559                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07560 #endif
07561                         (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
07562 
07563                     }
07564     break;
07565 
07566   case 260:
07567 
07568 /* Line 1806 of yacc.c  */
07569 #line 2510 "ripper.y"
07570     {
07571 #if 0
07572                         NODE *n1;
07573                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07574                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07575                         }
07576                         else {
07577                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07578                         }
07579 #endif
07580                         (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07581 
07582                     }
07583     break;
07584 
07585   case 261:
07586 
07587 /* Line 1806 of yacc.c  */
07588 #line 2524 "ripper.y"
07589     {
07590 #if 0
07591                         NODE *n1;
07592                         if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07593                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07594                         }
07595                         else {
07596                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07597                         }
07598 #endif
07599                         (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07600 
07601                     }
07602     break;
07603 
07604   case 262:
07605 
07606 /* Line 1806 of yacc.c  */
07607 #line 2540 "ripper.y"
07608     {
07609 #if 0
07610                         NODE *n1;
07611                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07612                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07613                         }
07614                         else {
07615                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07616                         }
07617 #endif
07618                         (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
07619 
07620                     }
07621     break;
07622 
07623   case 263:
07624 
07625 /* Line 1806 of yacc.c  */
07626 #line 2554 "ripper.y"
07627     {
07628 #if 0
07629                         NODE *n1;
07630                         if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
07631                             (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07632                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07633                         }
07634                         else {
07635                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07636                         }
07637 #endif
07638                         (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
07639 
07640                     }
07641     break;
07642 
07643   case 264:
07644 
07645 /* Line 1806 of yacc.c  */
07646 #line 2569 "ripper.y"
07647     {
07648 #if 0
07649                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07650 #endif
07651                         (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
07652 
07653                     }
07654     break;
07655 
07656   case 273:
07657 
07658 /* Line 1806 of yacc.c  */
07659 #line 2587 "ripper.y"
07660     {
07661 #if 0
07662                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
07663 #endif
07664                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
07665 
07666                     }
07667     break;
07668 
07669   case 274:
07670 
07671 /* Line 1806 of yacc.c  */
07672 #line 2595 "ripper.y"
07673     {
07674 #if 0
07675                         (yyval.num) = ruby_sourceline;
07676 #endif
07677 
07678                     }
07679     break;
07680 
07681   case 275:
07682 
07683 /* Line 1806 of yacc.c  */
07684 #line 2603 "ripper.y"
07685     {
07686 #if 0
07687                         if ((yyvsp[(3) - (4)].val) == NULL) {
07688                             (yyval.val) = NEW_NIL();
07689                         }
07690                         else {
07691                             if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
07692                                 nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
07693                                 nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
07694                             (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
07695                         }
07696                         nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
07697 #endif
07698                         (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
07699 
07700                     }
07701     break;
07702 
07703   case 276:
07704 
07705 /* Line 1806 of yacc.c  */
07706 #line 2619 "ripper.y"
07707     {lex_state = EXPR_ENDARG;}
07708     break;
07709 
07710   case 277:
07711 
07712 /* Line 1806 of yacc.c  */
07713 #line 2620 "ripper.y"
07714     {
07715                         rb_warning0("(...) interpreted as grouped expression");
07716 #if 0
07717                         (yyval.val) = (yyvsp[(2) - (4)].val);
07718 #endif
07719                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
07720 
07721                     }
07722     break;
07723 
07724   case 278:
07725 
07726 /* Line 1806 of yacc.c  */
07727 #line 2629 "ripper.y"
07728     {
07729 #if 0
07730                         (yyval.val) = (yyvsp[(2) - (3)].val);
07731 #endif
07732                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
07733 
07734                     }
07735     break;
07736 
07737   case 279:
07738 
07739 /* Line 1806 of yacc.c  */
07740 #line 2637 "ripper.y"
07741     {
07742 #if 0
07743                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07744 #endif
07745                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07746 
07747                     }
07748     break;
07749 
07750   case 280:
07751 
07752 /* Line 1806 of yacc.c  */
07753 #line 2645 "ripper.y"
07754     {
07755 #if 0
07756                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
07757 #endif
07758                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
07759 
07760                     }
07761     break;
07762 
07763   case 281:
07764 
07765 /* Line 1806 of yacc.c  */
07766 #line 2653 "ripper.y"
07767     {
07768 #if 0
07769                         if ((yyvsp[(2) - (3)].val) == 0) {
07770                             (yyval.val) = NEW_ZARRAY(); /* zero length array*/
07771                         }
07772                         else {
07773                             (yyval.val) = (yyvsp[(2) - (3)].val);
07774                         }
07775 #endif
07776                         (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
07777 
07778                     }
07779     break;
07780 
07781   case 282:
07782 
07783 /* Line 1806 of yacc.c  */
07784 #line 2666 "ripper.y"
07785     {
07786 #if 0
07787                         (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
07788 #endif
07789                         (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
07790 
07791                     }
07792     break;
07793 
07794   case 283:
07795 
07796 /* Line 1806 of yacc.c  */
07797 #line 2674 "ripper.y"
07798     {
07799 #if 0
07800                         (yyval.val) = NEW_RETURN(0);
07801 #endif
07802                         (yyval.val) = dispatch0(return0);
07803 
07804                     }
07805     break;
07806 
07807   case 284:
07808 
07809 /* Line 1806 of yacc.c  */
07810 #line 2682 "ripper.y"
07811     {
07812 #if 0
07813                         (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
07814 #endif
07815                         (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
07816 
07817                     }
07818     break;
07819 
07820   case 285:
07821 
07822 /* Line 1806 of yacc.c  */
07823 #line 2690 "ripper.y"
07824     {
07825 #if 0
07826                         (yyval.val) = NEW_YIELD(0, Qfalse);
07827 #endif
07828                         (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
07829 
07830                     }
07831     break;
07832 
07833   case 286:
07834 
07835 /* Line 1806 of yacc.c  */
07836 #line 2698 "ripper.y"
07837     {
07838 #if 0
07839                         (yyval.val) = NEW_YIELD(0, Qfalse);
07840 #endif
07841                         (yyval.val) = dispatch0(yield0);
07842 
07843                     }
07844     break;
07845 
07846   case 287:
07847 
07848 /* Line 1806 of yacc.c  */
07849 #line 2705 "ripper.y"
07850     {in_defined = 1;}
07851     break;
07852 
07853   case 288:
07854 
07855 /* Line 1806 of yacc.c  */
07856 #line 2706 "ripper.y"
07857     {
07858 #if 0
07859                         in_defined = 0;
07860                         (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
07861 #endif
07862                         in_defined = 0;
07863                         (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
07864 
07865                     }
07866     break;
07867 
07868   case 289:
07869 
07870 /* Line 1806 of yacc.c  */
07871 #line 2716 "ripper.y"
07872     {
07873 #if 0
07874                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
07875 #endif
07876                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
07877 
07878                     }
07879     break;
07880 
07881   case 290:
07882 
07883 /* Line 1806 of yacc.c  */
07884 #line 2724 "ripper.y"
07885     {
07886 #if 0
07887                         (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
07888 #endif
07889                         (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
07890 
07891                     }
07892     break;
07893 
07894   case 291:
07895 
07896 /* Line 1806 of yacc.c  */
07897 #line 2732 "ripper.y"
07898     {
07899 #if 0
07900                         (yyvsp[(2) - (2)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (2)].val), 0);
07901                         (yyval.val) = (yyvsp[(2) - (2)].val);
07902                         fixpos((yyvsp[(2) - (2)].val)->nd_iter, (yyvsp[(2) - (2)].val));
07903 #endif
07904                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
07905                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
07906 
07907                     }
07908     break;
07909 
07910   case 293:
07911 
07912 /* Line 1806 of yacc.c  */
07913 #line 2744 "ripper.y"
07914     {
07915 #if 0
07916                         block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
07917                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
07918                         (yyval.val) = (yyvsp[(2) - (2)].val);
07919                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
07920 #endif
07921                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07922 
07923                     }
07924     break;
07925 
07926   case 294:
07927 
07928 /* Line 1806 of yacc.c  */
07929 #line 2755 "ripper.y"
07930     {
07931                         (yyval.val) = (yyvsp[(2) - (2)].val);
07932                     }
07933     break;
07934 
07935   case 295:
07936 
07937 /* Line 1806 of yacc.c  */
07938 #line 2762 "ripper.y"
07939     {
07940 #if 0
07941                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07942                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07943 #endif
07944                         (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07945 
07946                     }
07947     break;
07948 
07949   case 296:
07950 
07951 /* Line 1806 of yacc.c  */
07952 #line 2774 "ripper.y"
07953     {
07954 #if 0
07955                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07956                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07957 #endif
07958                         (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07959 
07960                     }
07961     break;
07962 
07963   case 297:
07964 
07965 /* Line 1806 of yacc.c  */
07966 #line 2782 "ripper.y"
07967     {COND_PUSH(1);}
07968     break;
07969 
07970   case 298:
07971 
07972 /* Line 1806 of yacc.c  */
07973 #line 2782 "ripper.y"
07974     {COND_POP();}
07975     break;
07976 
07977   case 299:
07978 
07979 /* Line 1806 of yacc.c  */
07980 #line 2785 "ripper.y"
07981     {
07982 #if 0
07983                         (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
07984                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
07985 #endif
07986                         (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
07987 
07988                     }
07989     break;
07990 
07991   case 300:
07992 
07993 /* Line 1806 of yacc.c  */
07994 #line 2793 "ripper.y"
07995     {COND_PUSH(1);}
07996     break;
07997 
07998   case 301:
07999 
08000 /* Line 1806 of yacc.c  */
08001 #line 2793 "ripper.y"
08002     {COND_POP();}
08003     break;
08004 
08005   case 302:
08006 
08007 /* Line 1806 of yacc.c  */
08008 #line 2796 "ripper.y"
08009     {
08010 #if 0
08011                         (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
08012                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
08013 #endif
08014                         (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
08015 
08016                     }
08017     break;
08018 
08019   case 303:
08020 
08021 /* Line 1806 of yacc.c  */
08022 #line 2807 "ripper.y"
08023     {
08024 #if 0
08025                         (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08026                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08027 #endif
08028                         (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08029 
08030                     }
08031     break;
08032 
08033   case 304:
08034 
08035 /* Line 1806 of yacc.c  */
08036 #line 2816 "ripper.y"
08037     {
08038 #if 0
08039                         (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
08040 #endif
08041                         (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
08042 
08043                     }
08044     break;
08045 
08046   case 305:
08047 
08048 /* Line 1806 of yacc.c  */
08049 #line 2824 "ripper.y"
08050     {COND_PUSH(1);}
08051     break;
08052 
08053   case 306:
08054 
08055 /* Line 1806 of yacc.c  */
08056 #line 2826 "ripper.y"
08057     {COND_POP();}
08058     break;
08059 
08060   case 307:
08061 
08062 /* Line 1806 of yacc.c  */
08063 #line 2829 "ripper.y"
08064     {
08065 #if 0
08066                         /*
08067                          *  for a, b, c in e
08068                          *  #=>
08069                          *  e.each{|*x| a, b, c = x
08070                          *
08071                          *  for a in e
08072                          *  #=>
08073                          *  e.each{|x| a, = x}
08074                          */
08075                         ID id = internal_id();
08076                         ID *tbl = ALLOC_N(ID, 2);
08077                         NODE *m = NEW_ARGS_AUX(0, 0);
08078                         NODE *args, *scope;
08079 
08080                         if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
08081                             /* if args.length == 1 && args[0].kind_of?(Array)
08082                              *   args = args[0]
08083                              * end
08084                              */
08085                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
08086                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
08087                             m->nd_next = block_append(
08088                                 NEW_IF(
08089                                     NEW_NODE(NODE_AND,
08090                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("length"), 0),
08091                                                       rb_intern("=="), one),
08092                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero),
08093                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
08094                                              0),
08095                                     NEW_DASGN_CURR(id,
08096                                                    NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero)),
08097                                     0),
08098                                 node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
08099 
08100                             args = new_args(m, 0, id, 0, 0);
08101                         }
08102                         else {
08103                             if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
08104                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
08105                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
08106                                 (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
08107                                 m->nd_plen = 1;
08108                                 m->nd_next = (yyvsp[(2) - (9)].val);
08109                                 args = new_args(m, 0, 0, 0, 0);
08110                             }
08111                             else {
08112                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
08113                                 args = new_args(m, 0, id, 0, 0);
08114                             }
08115                         }
08116                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
08117                         tbl[0] = 1; tbl[1] = id;
08118                         (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
08119                         fixpos((yyval.val), (yyvsp[(2) - (9)].val));
08120 #endif
08121                         (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
08122 
08123                     }
08124     break;
08125 
08126   case 308:
08127 
08128 /* Line 1806 of yacc.c  */
08129 #line 2890 "ripper.y"
08130     {
08131                         if (in_def || in_single)
08132                             yyerror("class definition in method body");
08133                         local_push(0);
08134 #if 0
08135                         (yyval.num) = ruby_sourceline;
08136 #endif
08137 
08138                     }
08139     break;
08140 
08141   case 309:
08142 
08143 /* Line 1806 of yacc.c  */
08144 #line 2901 "ripper.y"
08145     {
08146 #if 0
08147                         (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
08148                         nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
08149 #endif
08150                         (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
08151 
08152                         local_pop();
08153                     }
08154     break;
08155 
08156   case 310:
08157 
08158 /* Line 1806 of yacc.c  */
08159 #line 2911 "ripper.y"
08160     {
08161                         (yyval.num) = in_def;
08162                         in_def = 0;
08163                     }
08164     break;
08165 
08166   case 311:
08167 
08168 /* Line 1806 of yacc.c  */
08169 #line 2916 "ripper.y"
08170     {
08171                         (yyval.num) = in_single;
08172                         in_single = 0;
08173                         local_push(0);
08174                     }
08175     break;
08176 
08177   case 312:
08178 
08179 /* Line 1806 of yacc.c  */
08180 #line 2923 "ripper.y"
08181     {
08182 #if 0
08183                         (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08184                         fixpos((yyval.val), (yyvsp[(3) - (8)].val));
08185 #endif
08186                         (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
08187 
08188                         local_pop();
08189                         in_def = (yyvsp[(4) - (8)].num);
08190                         in_single = (yyvsp[(6) - (8)].num);
08191                     }
08192     break;
08193 
08194   case 313:
08195 
08196 /* Line 1806 of yacc.c  */
08197 #line 2935 "ripper.y"
08198     {
08199                         if (in_def || in_single)
08200                             yyerror("module definition in method body");
08201                         local_push(0);
08202 #if 0
08203                         (yyval.num) = ruby_sourceline;
08204 #endif
08205 
08206                     }
08207     break;
08208 
08209   case 314:
08210 
08211 /* Line 1806 of yacc.c  */
08212 #line 2946 "ripper.y"
08213     {
08214 #if 0
08215                         (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08216                         nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
08217 #endif
08218                         (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08219 
08220                         local_pop();
08221                     }
08222     break;
08223 
08224   case 315:
08225 
08226 /* Line 1806 of yacc.c  */
08227 #line 2956 "ripper.y"
08228     {
08229                         (yyval.id) = cur_mid;
08230                         cur_mid = (yyvsp[(2) - (2)].val);
08231                         in_def++;
08232                         local_push(0);
08233                     }
08234     break;
08235 
08236   case 316:
08237 
08238 /* Line 1806 of yacc.c  */
08239 #line 2965 "ripper.y"
08240     {
08241 #if 0
08242                         NODE *body = remove_begin((yyvsp[(5) - (6)].val));
08243                         reduce_nodes(&body);
08244                         (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
08245                         nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
08246 #endif
08247                         (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08248 
08249                         local_pop();
08250                         in_def--;
08251                         cur_mid = (yyvsp[(3) - (6)].id);
08252                     }
08253     break;
08254 
08255   case 317:
08256 
08257 /* Line 1806 of yacc.c  */
08258 #line 2978 "ripper.y"
08259     {lex_state = EXPR_FNAME;}
08260     break;
08261 
08262   case 318:
08263 
08264 /* Line 1806 of yacc.c  */
08265 #line 2979 "ripper.y"
08266     {
08267                         in_single++;
08268                         lex_state = EXPR_ENDFN; /* force for args */
08269                         local_push(0);
08270                     }
08271     break;
08272 
08273   case 319:
08274 
08275 /* Line 1806 of yacc.c  */
08276 #line 2987 "ripper.y"
08277     {
08278 #if 0
08279                         NODE *body = remove_begin((yyvsp[(8) - (9)].val));
08280                         reduce_nodes(&body);
08281                         (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
08282                         nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
08283 #endif
08284                         (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
08285 
08286                         local_pop();
08287                         in_single--;
08288                     }
08289     break;
08290 
08291   case 320:
08292 
08293 /* Line 1806 of yacc.c  */
08294 #line 3000 "ripper.y"
08295     {
08296 #if 0
08297                         (yyval.val) = NEW_BREAK(0);
08298 #endif
08299                         (yyval.val) = dispatch1(break, arg_new());
08300 
08301                     }
08302     break;
08303 
08304   case 321:
08305 
08306 /* Line 1806 of yacc.c  */
08307 #line 3008 "ripper.y"
08308     {
08309 #if 0
08310                         (yyval.val) = NEW_NEXT(0);
08311 #endif
08312                         (yyval.val) = dispatch1(next, arg_new());
08313 
08314                     }
08315     break;
08316 
08317   case 322:
08318 
08319 /* Line 1806 of yacc.c  */
08320 #line 3016 "ripper.y"
08321     {
08322 #if 0
08323                         (yyval.val) = NEW_REDO();
08324 #endif
08325                         (yyval.val) = dispatch0(redo);
08326 
08327                     }
08328     break;
08329 
08330   case 323:
08331 
08332 /* Line 1806 of yacc.c  */
08333 #line 3024 "ripper.y"
08334     {
08335 #if 0
08336                         (yyval.val) = NEW_RETRY();
08337 #endif
08338                         (yyval.val) = dispatch0(retry);
08339 
08340                     }
08341     break;
08342 
08343   case 324:
08344 
08345 /* Line 1806 of yacc.c  */
08346 #line 3034 "ripper.y"
08347     {
08348 #if 0
08349                         value_expr((yyvsp[(1) - (1)].val));
08350                         (yyval.val) = (yyvsp[(1) - (1)].val);
08351                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
08352 #endif
08353                         (yyval.val) = (yyvsp[(1) - (1)].val);
08354 
08355                     }
08356     break;
08357 
08358   case 325:
08359 
08360 /* Line 1806 of yacc.c  */
08361 #line 3046 "ripper.y"
08362     {
08363                         token_info_push("begin");
08364                     }
08365     break;
08366 
08367   case 326:
08368 
08369 /* Line 1806 of yacc.c  */
08370 #line 3052 "ripper.y"
08371     {
08372                         token_info_push("if");
08373                     }
08374     break;
08375 
08376   case 327:
08377 
08378 /* Line 1806 of yacc.c  */
08379 #line 3058 "ripper.y"
08380     {
08381                         token_info_push("unless");
08382                     }
08383     break;
08384 
08385   case 328:
08386 
08387 /* Line 1806 of yacc.c  */
08388 #line 3064 "ripper.y"
08389     {
08390                         token_info_push("while");
08391                     }
08392     break;
08393 
08394   case 329:
08395 
08396 /* Line 1806 of yacc.c  */
08397 #line 3070 "ripper.y"
08398     {
08399                         token_info_push("until");
08400                     }
08401     break;
08402 
08403   case 330:
08404 
08405 /* Line 1806 of yacc.c  */
08406 #line 3076 "ripper.y"
08407     {
08408                         token_info_push("case");
08409                     }
08410     break;
08411 
08412   case 331:
08413 
08414 /* Line 1806 of yacc.c  */
08415 #line 3082 "ripper.y"
08416     {
08417                         token_info_push("for");
08418                     }
08419     break;
08420 
08421   case 332:
08422 
08423 /* Line 1806 of yacc.c  */
08424 #line 3088 "ripper.y"
08425     {
08426                         token_info_push("class");
08427                     }
08428     break;
08429 
08430   case 333:
08431 
08432 /* Line 1806 of yacc.c  */
08433 #line 3094 "ripper.y"
08434     {
08435                         token_info_push("module");
08436                     }
08437     break;
08438 
08439   case 334:
08440 
08441 /* Line 1806 of yacc.c  */
08442 #line 3100 "ripper.y"
08443     {
08444                         token_info_push("def");
08445 #if 0
08446                         (yyval.num) = ruby_sourceline;
08447 #endif
08448 
08449                     }
08450     break;
08451 
08452   case 335:
08453 
08454 /* Line 1806 of yacc.c  */
08455 #line 3110 "ripper.y"
08456     {
08457                         token_info_pop("end");
08458                     }
08459     break;
08460 
08461   case 336:
08462 
08463 /* Line 1806 of yacc.c  */
08464 #line 3118 "ripper.y"
08465     { (yyval.val) = Qnil; }
08466     break;
08467 
08468   case 338:
08469 
08470 /* Line 1806 of yacc.c  */
08471 #line 3124 "ripper.y"
08472     { (yyval.val) = (yyvsp[(2) - (2)].val); }
08473     break;
08474 
08475   case 339:
08476 
08477 /* Line 1806 of yacc.c  */
08478 #line 3131 "ripper.y"
08479     { (yyval.val) = Qnil; }
08480     break;
08481 
08482   case 342:
08483 
08484 /* Line 1806 of yacc.c  */
08485 #line 3140 "ripper.y"
08486     {
08487 #if 0
08488                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08489                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08490 #endif
08491                         (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
08492 
08493                     }
08494     break;
08495 
08496   case 344:
08497 
08498 /* Line 1806 of yacc.c  */
08499 #line 3152 "ripper.y"
08500     {
08501 #if 0
08502                         (yyval.val) = (yyvsp[(2) - (2)].val);
08503 #endif
08504                         (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
08505 
08506                     }
08507     break;
08508 
08509   case 347:
08510 
08511 /* Line 1806 of yacc.c  */
08512 #line 3166 "ripper.y"
08513     {
08514                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
08515 #if 0
08516 #endif
08517                         (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
08518 
08519                     }
08520     break;
08521 
08522   case 348:
08523 
08524 /* Line 1806 of yacc.c  */
08525 #line 3174 "ripper.y"
08526     {
08527 #if 0
08528                         (yyval.val) = (yyvsp[(2) - (3)].val);
08529 #endif
08530                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
08531 
08532                     }
08533     break;
08534 
08535   case 349:
08536 
08537 /* Line 1806 of yacc.c  */
08538 #line 3184 "ripper.y"
08539     {
08540 #if 0
08541                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
08542 #endif
08543                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
08544 
08545                     }
08546     break;
08547 
08548   case 350:
08549 
08550 /* Line 1806 of yacc.c  */
08551 #line 3192 "ripper.y"
08552     {
08553 #if 0
08554                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08555 #endif
08556                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08557 
08558                     }
08559     break;
08560 
08561   case 351:
08562 
08563 /* Line 1806 of yacc.c  */
08564 #line 3202 "ripper.y"
08565     {
08566 #if 0
08567                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
08568 #endif
08569                         (yyval.val) = (yyvsp[(1) - (1)].val);
08570 
08571                     }
08572     break;
08573 
08574   case 352:
08575 
08576 /* Line 1806 of yacc.c  */
08577 #line 3210 "ripper.y"
08578     {
08579                         (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
08580 #if 0
08581                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
08582 #endif
08583                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
08584 
08585                     }
08586     break;
08587 
08588   case 353:
08589 
08590 /* Line 1806 of yacc.c  */
08591 #line 3219 "ripper.y"
08592     {
08593                         (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
08594 #if 0
08595                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
08596 #endif
08597                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
08598 
08599                     }
08600     break;
08601 
08602   case 354:
08603 
08604 /* Line 1806 of yacc.c  */
08605 #line 3228 "ripper.y"
08606     {
08607 #if 0
08608                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
08609 #endif
08610                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
08611 
08612                     }
08613     break;
08614 
08615   case 355:
08616 
08617 /* Line 1806 of yacc.c  */
08618 #line 3236 "ripper.y"
08619     {
08620 #if 0
08621                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
08622 #endif
08623                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
08624 
08625                     }
08626     break;
08627 
08628   case 356:
08629 
08630 /* Line 1806 of yacc.c  */
08631 #line 3244 "ripper.y"
08632     {
08633                         (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
08634 #if 0
08635                         (yyval.val) = NEW_MASGN(0, (yyval.val));
08636 #endif
08637                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
08638 
08639                     }
08640     break;
08641 
08642   case 357:
08643 
08644 /* Line 1806 of yacc.c  */
08645 #line 3253 "ripper.y"
08646     {
08647                         (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
08648 #if 0
08649                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
08650 #endif
08651                       #if 0
08652                       TODO: Check me
08653                       #endif
08654                         (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
08655 
08656                     }
08657     break;
08658 
08659   case 358:
08660 
08661 /* Line 1806 of yacc.c  */
08662 #line 3265 "ripper.y"
08663     {
08664 #if 0
08665                         (yyval.val) = NEW_MASGN(0, -1);
08666 #endif
08667                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08668 
08669                     }
08670     break;
08671 
08672   case 359:
08673 
08674 /* Line 1806 of yacc.c  */
08675 #line 3273 "ripper.y"
08676     {
08677 #if 0
08678                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
08679 #endif
08680                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08681 
08682                     }
08683     break;
08684 
08685   case 360:
08686 
08687 /* Line 1806 of yacc.c  */
08688 #line 3283 "ripper.y"
08689     {
08690 #if 0
08691                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
08692 #endif
08693                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
08694 
08695                     }
08696     break;
08697 
08698   case 361:
08699 
08700 /* Line 1806 of yacc.c  */
08701 #line 3291 "ripper.y"
08702     {
08703 #if 0
08704                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
08705 #endif
08706                         (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)));
08707 
08708                     }
08709     break;
08710 
08711   case 362:
08712 
08713 /* Line 1806 of yacc.c  */
08714 #line 3299 "ripper.y"
08715     {
08716 #if 0
08717                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
08718 #endif
08719                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08720 
08721                     }
08722     break;
08723 
08724   case 363:
08725 
08726 /* Line 1806 of yacc.c  */
08727 #line 3307 "ripper.y"
08728     {
08729 #if 0
08730                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08731 #endif
08732                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08733 
08734                     }
08735     break;
08736 
08737   case 364:
08738 
08739 /* Line 1806 of yacc.c  */
08740 #line 3315 "ripper.y"
08741     {
08742 #if 0
08743                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
08744 #endif
08745                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08746 
08747                     }
08748     break;
08749 
08750   case 365:
08751 
08752 /* Line 1806 of yacc.c  */
08753 #line 3323 "ripper.y"
08754     {
08755 #if 0
08756                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 1, 0, 0);
08757 #endif
08758                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil, Qnil);
08759                         dispatch1(excessed_comma, (yyval.val));
08760 
08761                     }
08762     break;
08763 
08764   case 366:
08765 
08766 /* Line 1806 of yacc.c  */
08767 #line 3332 "ripper.y"
08768     {
08769 #if 0
08770                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08771 #endif
08772                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08773 
08774                     }
08775     break;
08776 
08777   case 367:
08778 
08779 /* Line 1806 of yacc.c  */
08780 #line 3340 "ripper.y"
08781     {
08782 #if 0
08783                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
08784 #endif
08785                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil,Qnil, Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
08786 
08787                     }
08788     break;
08789 
08790   case 368:
08791 
08792 /* Line 1806 of yacc.c  */
08793 #line 3348 "ripper.y"
08794     {
08795 #if 0
08796                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
08797 #endif
08798                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
08799 
08800                     }
08801     break;
08802 
08803   case 369:
08804 
08805 /* Line 1806 of yacc.c  */
08806 #line 3356 "ripper.y"
08807     {
08808 #if 0
08809                         (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08810 #endif
08811                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
08812 
08813                     }
08814     break;
08815 
08816   case 370:
08817 
08818 /* Line 1806 of yacc.c  */
08819 #line 3364 "ripper.y"
08820     {
08821 #if 0
08822                         (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
08823 #endif
08824                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
08825 
08826                     }
08827     break;
08828 
08829   case 371:
08830 
08831 /* Line 1806 of yacc.c  */
08832 #line 3372 "ripper.y"
08833     {
08834 #if 0
08835                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08836 #endif
08837                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
08838 
08839                     }
08840     break;
08841 
08842   case 372:
08843 
08844 /* Line 1806 of yacc.c  */
08845 #line 3380 "ripper.y"
08846     {
08847 #if 0
08848                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
08849 #endif
08850                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil, escape_Qundef((yyvsp[(2) - (2)].val)));
08851 
08852                     }
08853     break;
08854 
08855   case 373:
08856 
08857 /* Line 1806 of yacc.c  */
08858 #line 3388 "ripper.y"
08859     {
08860 #if 0
08861                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08862 #endif
08863                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
08864 
08865                     }
08866     break;
08867 
08868   case 374:
08869 
08870 /* Line 1806 of yacc.c  */
08871 #line 3396 "ripper.y"
08872     {
08873 #if 0
08874                         (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
08875 #endif
08876                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
08877 
08878                     }
08879     break;
08880 
08881   case 376:
08882 
08883 /* Line 1806 of yacc.c  */
08884 #line 3407 "ripper.y"
08885     {
08886                         command_start = TRUE;
08887                     }
08888     break;
08889 
08890   case 377:
08891 
08892 /* Line 1806 of yacc.c  */
08893 #line 3413 "ripper.y"
08894     {
08895 #if 0
08896                         (yyval.val) = 0;
08897 #endif
08898                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
08899                                           escape_Qundef((yyvsp[(2) - (3)].val)));
08900 
08901                     }
08902     break;
08903 
08904   case 378:
08905 
08906 /* Line 1806 of yacc.c  */
08907 #line 3422 "ripper.y"
08908     {
08909 #if 0
08910                         (yyval.val) = 0;
08911 #endif
08912                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
08913                                           Qnil);
08914 
08915                     }
08916     break;
08917 
08918   case 379:
08919 
08920 /* Line 1806 of yacc.c  */
08921 #line 3431 "ripper.y"
08922     {
08923 #if 0
08924                         (yyval.val) = (yyvsp[(2) - (4)].val);
08925 #endif
08926                         (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
08927 
08928                     }
08929     break;
08930 
08931   case 381:
08932 
08933 /* Line 1806 of yacc.c  */
08934 #line 3443 "ripper.y"
08935     {
08936 #if 0
08937                         (yyval.val) = 0;
08938 #endif
08939                         (yyval.val) = (yyvsp[(2) - (2)].val);
08940 
08941                     }
08942     break;
08943 
08944   case 382:
08945 
08946 /* Line 1806 of yacc.c  */
08947 #line 3455 "ripper.y"
08948     {
08949                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
08950                     }
08951     break;
08952 
08953   case 383:
08954 
08955 /* Line 1806 of yacc.c  */
08956 #line 3462 "ripper.y"
08957     {
08958                         rb_ary_push((yyval.val), (yyvsp[(3) - (3)].val));
08959                     }
08960     break;
08961 
08962   case 384:
08963 
08964 /* Line 1806 of yacc.c  */
08965 #line 3469 "ripper.y"
08966     {
08967                         new_bv(get_id((yyvsp[(1) - (1)].val)));
08968 #if 0
08969 #endif
08970                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
08971 
08972                     }
08973     break;
08974 
08975   case 385:
08976 
08977 /* Line 1806 of yacc.c  */
08978 #line 3477 "ripper.y"
08979     {
08980                         (yyval.val) = 0;
08981                     }
08982     break;
08983 
08984   case 386:
08985 
08986 /* Line 1806 of yacc.c  */
08987 #line 3482 "ripper.y"
08988     {
08989                         (yyval.vars) = dyna_push();
08990                     }
08991     break;
08992 
08993   case 387:
08994 
08995 /* Line 1806 of yacc.c  */
08996 #line 3485 "ripper.y"
08997     {
08998                         (yyval.num) = lpar_beg;
08999                         lpar_beg = ++paren_nest;
09000                     }
09001     break;
09002 
09003   case 388:
09004 
09005 /* Line 1806 of yacc.c  */
09006 #line 3491 "ripper.y"
09007     {
09008                         lpar_beg = (yyvsp[(2) - (4)].num);
09009 #if 0
09010                         (yyval.val) = (yyvsp[(3) - (4)].val);
09011                         (yyval.val)->nd_body = NEW_SCOPE((yyvsp[(3) - (4)].val)->nd_head, (yyvsp[(4) - (4)].val));
09012 #endif
09013                         (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09014 
09015                         dyna_pop((yyvsp[(1) - (4)].vars));
09016                     }
09017     break;
09018 
09019   case 389:
09020 
09021 /* Line 1806 of yacc.c  */
09022 #line 3504 "ripper.y"
09023     {
09024 #if 0
09025                         (yyval.val) = NEW_LAMBDA((yyvsp[(2) - (4)].val));
09026 #endif
09027                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
09028 
09029                     }
09030     break;
09031 
09032   case 390:
09033 
09034 /* Line 1806 of yacc.c  */
09035 #line 3512 "ripper.y"
09036     {
09037 #if 0
09038                         (yyval.val) = NEW_LAMBDA((yyvsp[(1) - (1)].val));
09039 #endif
09040                         (yyval.val) = (yyvsp[(1) - (1)].val);
09041 
09042                     }
09043     break;
09044 
09045   case 391:
09046 
09047 /* Line 1806 of yacc.c  */
09048 #line 3522 "ripper.y"
09049     {
09050                         (yyval.val) = (yyvsp[(2) - (3)].val);
09051                     }
09052     break;
09053 
09054   case 392:
09055 
09056 /* Line 1806 of yacc.c  */
09057 #line 3526 "ripper.y"
09058     {
09059                         (yyval.val) = (yyvsp[(2) - (3)].val);
09060                     }
09061     break;
09062 
09063   case 393:
09064 
09065 /* Line 1806 of yacc.c  */
09066 #line 3532 "ripper.y"
09067     {
09068                         (yyvsp[(1) - (1)].vars) = dyna_push();
09069 #if 0
09070                         (yyval.num) = ruby_sourceline;
09071 #endif
09072                     }
09073     break;
09074 
09075   case 394:
09076 
09077 /* Line 1806 of yacc.c  */
09078 #line 3541 "ripper.y"
09079     {
09080 #if 0
09081                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09082                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09083 #endif
09084                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09085 
09086                         dyna_pop((yyvsp[(1) - (5)].vars));
09087                     }
09088     break;
09089 
09090   case 395:
09091 
09092 /* Line 1806 of yacc.c  */
09093 #line 3553 "ripper.y"
09094     {
09095 #if 0
09096                         if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
09097                             compile_error(PARSER_ARG "block given to yield");
09098                         }
09099                         else {
09100                             block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
09101                         }
09102                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
09103                         (yyval.val) = (yyvsp[(2) - (2)].val);
09104                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
09105 #endif
09106                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09107 
09108                     }
09109     break;
09110 
09111   case 396:
09112 
09113 /* Line 1806 of yacc.c  */
09114 #line 3569 "ripper.y"
09115     {
09116 #if 0
09117                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09118 #endif
09119                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
09120                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09121 
09122                     }
09123     break;
09124 
09125   case 397:
09126 
09127 /* Line 1806 of yacc.c  */
09128 #line 3578 "ripper.y"
09129     {
09130 #if 0
09131                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09132 #endif
09133                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val));
09134                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09135 
09136                     }
09137     break;
09138 
09139   case 398:
09140 
09141 /* Line 1806 of yacc.c  */
09142 #line 3589 "ripper.y"
09143     {
09144 #if 0
09145                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09146                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
09147 #endif
09148                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
09149 
09150                     }
09151     break;
09152 
09153   case 399:
09154 
09155 /* Line 1806 of yacc.c  */
09156 #line 3598 "ripper.y"
09157     {
09158 #if 0
09159                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09160                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09161 #endif
09162                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
09163                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09164 
09165                     }
09166     break;
09167 
09168   case 400:
09169 
09170 /* Line 1806 of yacc.c  */
09171 #line 3608 "ripper.y"
09172     {
09173 #if 0
09174                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09175                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09176 #endif
09177                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val));
09178                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
09179 
09180                     }
09181     break;
09182 
09183   case 401:
09184 
09185 /* Line 1806 of yacc.c  */
09186 #line 3618 "ripper.y"
09187     {
09188 #if 0
09189                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
09190 #endif
09191                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
09192 
09193                     }
09194     break;
09195 
09196   case 402:
09197 
09198 /* Line 1806 of yacc.c  */
09199 #line 3626 "ripper.y"
09200     {
09201 #if 0
09202                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
09203                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
09204 #endif
09205                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_id2sym('.'),
09206                                        ripper_intern("call"));
09207                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
09208 
09209                     }
09210     break;
09211 
09212   case 403:
09213 
09214 /* Line 1806 of yacc.c  */
09215 #line 3637 "ripper.y"
09216     {
09217 #if 0
09218                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
09219                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
09220 #endif
09221                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"),
09222                                        ripper_intern("call"));
09223                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(3) - (3)].val));
09224 
09225                     }
09226     break;
09227 
09228   case 404:
09229 
09230 /* Line 1806 of yacc.c  */
09231 #line 3648 "ripper.y"
09232     {
09233 #if 0
09234                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
09235 #endif
09236                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
09237 
09238                     }
09239     break;
09240 
09241   case 405:
09242 
09243 /* Line 1806 of yacc.c  */
09244 #line 3656 "ripper.y"
09245     {
09246 #if 0
09247                         (yyval.val) = NEW_ZSUPER();
09248 #endif
09249                         (yyval.val) = dispatch0(zsuper);
09250 
09251                     }
09252     break;
09253 
09254   case 406:
09255 
09256 /* Line 1806 of yacc.c  */
09257 #line 3664 "ripper.y"
09258     {
09259 #if 0
09260                         if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
09261                             (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
09262                         else
09263                             (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
09264                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
09265 #endif
09266                         (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
09267 
09268                     }
09269     break;
09270 
09271   case 407:
09272 
09273 /* Line 1806 of yacc.c  */
09274 #line 3678 "ripper.y"
09275     {
09276                         (yyvsp[(1) - (1)].vars) = dyna_push();
09277 #if 0
09278                         (yyval.num) = ruby_sourceline;
09279 #endif
09280 
09281                     }
09282     break;
09283 
09284   case 408:
09285 
09286 /* Line 1806 of yacc.c  */
09287 #line 3687 "ripper.y"
09288     {
09289 #if 0
09290                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09291                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09292 #endif
09293                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09294 
09295                         dyna_pop((yyvsp[(1) - (5)].vars));
09296                     }
09297     break;
09298 
09299   case 409:
09300 
09301 /* Line 1806 of yacc.c  */
09302 #line 3697 "ripper.y"
09303     {
09304                         (yyvsp[(1) - (1)].vars) = dyna_push();
09305 #if 0
09306                         (yyval.num) = ruby_sourceline;
09307 #endif
09308 
09309                     }
09310     break;
09311 
09312   case 410:
09313 
09314 /* Line 1806 of yacc.c  */
09315 #line 3706 "ripper.y"
09316     {
09317 #if 0
09318                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
09319                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
09320 #endif
09321                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
09322 
09323                         dyna_pop((yyvsp[(1) - (5)].vars));
09324                     }
09325     break;
09326 
09327   case 411:
09328 
09329 /* Line 1806 of yacc.c  */
09330 #line 3720 "ripper.y"
09331     {
09332 #if 0
09333                         (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
09334 #endif
09335                         (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
09336 
09337                     }
09338     break;
09339 
09340   case 414:
09341 
09342 /* Line 1806 of yacc.c  */
09343 #line 3736 "ripper.y"
09344     {
09345 #if 0
09346                         if ((yyvsp[(3) - (6)].val)) {
09347                             (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
09348                             (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
09349                         }
09350                         (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09351                         fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
09352 #endif
09353                         (yyval.val) = dispatch4(rescue,
09354                                        escape_Qundef((yyvsp[(2) - (6)].val)),
09355                                        escape_Qundef((yyvsp[(3) - (6)].val)),
09356                                        escape_Qundef((yyvsp[(5) - (6)].val)),
09357                                        escape_Qundef((yyvsp[(6) - (6)].val)));
09358 
09359                     }
09360     break;
09361 
09362   case 416:
09363 
09364 /* Line 1806 of yacc.c  */
09365 #line 3756 "ripper.y"
09366     {
09367 #if 0
09368                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
09369 #endif
09370                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09371 
09372                     }
09373     break;
09374 
09375   case 417:
09376 
09377 /* Line 1806 of yacc.c  */
09378 #line 3764 "ripper.y"
09379     {
09380 #if 0
09381                         if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
09382 #endif
09383                         (yyval.val) = (yyvsp[(1) - (1)].val);
09384 
09385                     }
09386     break;
09387 
09388   case 419:
09389 
09390 /* Line 1806 of yacc.c  */
09391 #line 3775 "ripper.y"
09392     {
09393                         (yyval.val) = (yyvsp[(2) - (2)].val);
09394                     }
09395     break;
09396 
09397   case 421:
09398 
09399 /* Line 1806 of yacc.c  */
09400 #line 3782 "ripper.y"
09401     {
09402 #if 0
09403                         (yyval.val) = (yyvsp[(2) - (2)].val);
09404 #endif
09405                         (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
09406 
09407                     }
09408     break;
09409 
09410   case 424:
09411 
09412 /* Line 1806 of yacc.c  */
09413 #line 3794 "ripper.y"
09414     {
09415 #if 0
09416                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
09417 #endif
09418                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
09419 
09420                     }
09421     break;
09422 
09423   case 426:
09424 
09425 /* Line 1806 of yacc.c  */
09426 #line 3805 "ripper.y"
09427     {
09428 #if 0
09429                         NODE *node = (yyvsp[(1) - (1)].val);
09430                         if (!node) {
09431                             node = NEW_STR(STR_NEW0());
09432                         }
09433                         else {
09434                             node = evstr2dstr(node);
09435                         }
09436                         (yyval.val) = node;
09437 #endif
09438                         (yyval.val) = (yyvsp[(1) - (1)].val);
09439 
09440                     }
09441     break;
09442 
09443   case 429:
09444 
09445 /* Line 1806 of yacc.c  */
09446 #line 3824 "ripper.y"
09447     {
09448 #if 0
09449                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09450 #endif
09451                         (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09452 
09453                     }
09454     break;
09455 
09456   case 430:
09457 
09458 /* Line 1806 of yacc.c  */
09459 #line 3834 "ripper.y"
09460     {
09461 #if 0
09462                         (yyval.val) = (yyvsp[(2) - (3)].val);
09463 #endif
09464                         (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
09465 
09466                     }
09467     break;
09468 
09469   case 431:
09470 
09471 /* Line 1806 of yacc.c  */
09472 #line 3844 "ripper.y"
09473     {
09474 #if 0
09475                         NODE *node = (yyvsp[(2) - (3)].val);
09476                         if (!node) {
09477                             node = NEW_XSTR(STR_NEW0());
09478                         }
09479                         else {
09480                             switch (nd_type(node)) {
09481                               case NODE_STR:
09482                                 nd_set_type(node, NODE_XSTR);
09483                                 break;
09484                               case NODE_DSTR:
09485                                 nd_set_type(node, NODE_DXSTR);
09486                                 break;
09487                               default:
09488                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09489                                 break;
09490                             }
09491                         }
09492                         (yyval.val) = node;
09493 #endif
09494                         (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
09495 
09496                     }
09497     break;
09498 
09499   case 432:
09500 
09501 /* Line 1806 of yacc.c  */
09502 #line 3871 "ripper.y"
09503     {
09504 #if 0
09505                         int options = (yyvsp[(3) - (3)].val);
09506                         NODE *node = (yyvsp[(2) - (3)].val);
09507                         NODE *list, *prev;
09508                         if (!node) {
09509                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09510                         }
09511                         else switch (nd_type(node)) {
09512                           case NODE_STR:
09513                             {
09514                                 VALUE src = node->nd_lit;
09515                                 nd_set_type(node, NODE_LIT);
09516                                 node->nd_lit = reg_compile(src, options);
09517                             }
09518                             break;
09519                           default:
09520                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09521                           case NODE_DSTR:
09522                             if (options & RE_OPTION_ONCE) {
09523                                 nd_set_type(node, NODE_DREGX_ONCE);
09524                             }
09525                             else {
09526                                 nd_set_type(node, NODE_DREGX);
09527                             }
09528                             node->nd_cflag = options & RE_OPTION_MASK;
09529                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09530                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09531                                 if (nd_type(list->nd_head) == NODE_STR) {
09532                                     VALUE tail = list->nd_head->nd_lit;
09533                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09534                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09535                                         if (!literal_concat0(parser, lit, tail)) {
09536                                             node = 0;
09537                                             break;
09538                                         }
09539                                         rb_str_resize(tail, 0);
09540                                         prev->nd_next = list->nd_next;
09541                                         rb_gc_force_recycle((VALUE)list->nd_head);
09542                                         rb_gc_force_recycle((VALUE)list);
09543                                         list = prev;
09544                                     }
09545                                     else {
09546                                         prev = list;
09547                                     }
09548                                 }
09549                                 else {
09550                                     prev = 0;
09551                                 }
09552                             }
09553                             if (!node->nd_next) {
09554                                 VALUE src = node->nd_lit;
09555                                 nd_set_type(node, NODE_LIT);
09556                                 node->nd_lit = reg_compile(src, options);
09557                             }
09558                             break;
09559                         }
09560                         (yyval.val) = node;
09561 #endif
09562                         (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
09563 
09564                     }
09565     break;
09566 
09567   case 433:
09568 
09569 /* Line 1806 of yacc.c  */
09570 #line 3936 "ripper.y"
09571     {
09572 #if 0
09573                         (yyval.val) = NEW_ZARRAY();
09574 #endif
09575                         (yyval.val) = dispatch0(words_new);
09576                         (yyval.val) = dispatch1(array, (yyval.val));
09577 
09578                     }
09579     break;
09580 
09581   case 434:
09582 
09583 /* Line 1806 of yacc.c  */
09584 #line 3945 "ripper.y"
09585     {
09586 #if 0
09587                         (yyval.val) = (yyvsp[(2) - (3)].val);
09588 #endif
09589                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09590 
09591                     }
09592     break;
09593 
09594   case 435:
09595 
09596 /* Line 1806 of yacc.c  */
09597 #line 3955 "ripper.y"
09598     {
09599 #if 0
09600                         (yyval.val) = 0;
09601 #endif
09602                         (yyval.val) = dispatch0(words_new);
09603 
09604                     }
09605     break;
09606 
09607   case 436:
09608 
09609 /* Line 1806 of yacc.c  */
09610 #line 3963 "ripper.y"
09611     {
09612 #if 0
09613                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
09614 #endif
09615                         (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09616 
09617                     }
09618     break;
09619 
09620   case 437:
09621 
09622 /* Line 1806 of yacc.c  */
09623 #line 3975 "ripper.y"
09624     {
09625                         (yyval.val) = dispatch0(word_new);
09626                         (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
09627                     }
09628     break;
09629 
09630   case 438:
09631 
09632 /* Line 1806 of yacc.c  */
09633 #line 3981 "ripper.y"
09634     {
09635 #if 0
09636                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09637 #endif
09638                         (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09639 
09640                     }
09641     break;
09642 
09643   case 439:
09644 
09645 /* Line 1806 of yacc.c  */
09646 #line 3991 "ripper.y"
09647     {
09648 #if 0
09649                         (yyval.val) = NEW_ZARRAY();
09650 #endif
09651                         (yyval.val) = dispatch0(qwords_new);
09652                         (yyval.val) = dispatch1(array, (yyval.val));
09653 
09654                     }
09655     break;
09656 
09657   case 440:
09658 
09659 /* Line 1806 of yacc.c  */
09660 #line 4000 "ripper.y"
09661     {
09662 #if 0
09663                         (yyval.val) = (yyvsp[(2) - (3)].val);
09664 #endif
09665                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09666 
09667                     }
09668     break;
09669 
09670   case 441:
09671 
09672 /* Line 1806 of yacc.c  */
09673 #line 4010 "ripper.y"
09674     {
09675 #if 0
09676                         (yyval.val) = 0;
09677 #endif
09678                         (yyval.val) = dispatch0(qwords_new);
09679 
09680                     }
09681     break;
09682 
09683   case 442:
09684 
09685 /* Line 1806 of yacc.c  */
09686 #line 4018 "ripper.y"
09687     {
09688 #if 0
09689                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09690 #endif
09691                         (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09692 
09693                     }
09694     break;
09695 
09696   case 443:
09697 
09698 /* Line 1806 of yacc.c  */
09699 #line 4028 "ripper.y"
09700     {
09701 #if 0
09702                         (yyval.val) = 0;
09703 #endif
09704                         (yyval.val) = dispatch0(string_content);
09705 
09706                     }
09707     break;
09708 
09709   case 444:
09710 
09711 /* Line 1806 of yacc.c  */
09712 #line 4036 "ripper.y"
09713     {
09714 #if 0
09715                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09716 #endif
09717                         (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09718 
09719                     }
09720     break;
09721 
09722   case 445:
09723 
09724 /* Line 1806 of yacc.c  */
09725 #line 4046 "ripper.y"
09726     {
09727 #if 0
09728                         (yyval.val) = 0;
09729 #endif
09730                         (yyval.val) = dispatch0(xstring_new);
09731 
09732                     }
09733     break;
09734 
09735   case 446:
09736 
09737 /* Line 1806 of yacc.c  */
09738 #line 4054 "ripper.y"
09739     {
09740 #if 0
09741                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09742 #endif
09743                         (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09744 
09745                     }
09746     break;
09747 
09748   case 447:
09749 
09750 /* Line 1806 of yacc.c  */
09751 #line 4064 "ripper.y"
09752     {
09753 #if 0
09754                         (yyval.val) = 0;
09755 #endif
09756                         (yyval.val) = dispatch0(regexp_new);
09757 
09758                     }
09759     break;
09760 
09761   case 448:
09762 
09763 /* Line 1806 of yacc.c  */
09764 #line 4072 "ripper.y"
09765     {
09766 #if 0
09767                         NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
09768                         if (!head) {
09769                             (yyval.val) = tail;
09770                         }
09771                         else if (!tail) {
09772                             (yyval.val) = head;
09773                         }
09774                         else {
09775                             switch (nd_type(head)) {
09776                               case NODE_STR:
09777                                 nd_set_type(head, NODE_DSTR);
09778                                 break;
09779                               case NODE_DSTR:
09780                                 break;
09781                               default:
09782                                 head = list_append(NEW_DSTR(Qnil), head);
09783                                 break;
09784                             }
09785                             (yyval.val) = list_append(head, tail);
09786                         }
09787 #endif
09788                         (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09789 
09790                     }
09791     break;
09792 
09793   case 450:
09794 
09795 /* Line 1806 of yacc.c  */
09796 #line 4102 "ripper.y"
09797     {
09798                         (yyval.node) = lex_strterm;
09799                         lex_strterm = 0;
09800                         lex_state = EXPR_BEG;
09801                     }
09802     break;
09803 
09804   case 451:
09805 
09806 /* Line 1806 of yacc.c  */
09807 #line 4108 "ripper.y"
09808     {
09809 #if 0
09810                         lex_strterm = (yyvsp[(2) - (3)].node);
09811                         (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
09812 #endif
09813                         lex_strterm = (yyvsp[(2) - (3)].node);
09814                         (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
09815 
09816                     }
09817     break;
09818 
09819   case 452:
09820 
09821 /* Line 1806 of yacc.c  */
09822 #line 4118 "ripper.y"
09823     {
09824                         (yyvsp[(1) - (1)].val) = cond_stack;
09825                         (yyval.val) = cmdarg_stack;
09826                         cond_stack = 0;
09827                         cmdarg_stack = 0;
09828                     }
09829     break;
09830 
09831   case 453:
09832 
09833 /* Line 1806 of yacc.c  */
09834 #line 4124 "ripper.y"
09835     {
09836                         (yyval.node) = lex_strterm;
09837                         lex_strterm = 0;
09838                         lex_state = EXPR_BEG;
09839                     }
09840     break;
09841 
09842   case 454:
09843 
09844 /* Line 1806 of yacc.c  */
09845 #line 4130 "ripper.y"
09846     {
09847                         cond_stack = (yyvsp[(1) - (5)].val);
09848                         cmdarg_stack = (yyvsp[(2) - (5)].val);
09849                         lex_strterm = (yyvsp[(3) - (5)].node);
09850 #if 0
09851                         if ((yyvsp[(4) - (5)].val)) (yyvsp[(4) - (5)].val)->flags &= ~NODE_FL_NEWLINE;
09852                         (yyval.val) = new_evstr((yyvsp[(4) - (5)].val));
09853 #endif
09854                         (yyval.val) = dispatch1(string_embexpr, (yyvsp[(4) - (5)].val));
09855 
09856                     }
09857     break;
09858 
09859   case 455:
09860 
09861 /* Line 1806 of yacc.c  */
09862 #line 4144 "ripper.y"
09863     {
09864 #if 0
09865                         (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
09866 #endif
09867                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09868 
09869                     }
09870     break;
09871 
09872   case 456:
09873 
09874 /* Line 1806 of yacc.c  */
09875 #line 4152 "ripper.y"
09876     {
09877 #if 0
09878                         (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
09879 #endif
09880                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09881 
09882                     }
09883     break;
09884 
09885   case 457:
09886 
09887 /* Line 1806 of yacc.c  */
09888 #line 4160 "ripper.y"
09889     {
09890 #if 0
09891                         (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
09892 #endif
09893                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09894 
09895                     }
09896     break;
09897 
09898   case 459:
09899 
09900 /* Line 1806 of yacc.c  */
09901 #line 4171 "ripper.y"
09902     {
09903                         lex_state = EXPR_END;
09904 #if 0
09905                         (yyval.val) = (yyvsp[(2) - (2)].val);
09906 #endif
09907                         (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
09908 
09909                     }
09910     break;
09911 
09912   case 464:
09913 
09914 /* Line 1806 of yacc.c  */
09915 #line 4188 "ripper.y"
09916     {
09917                         lex_state = EXPR_END;
09918 #if 0
09919                         if (!((yyval.val) = (yyvsp[(2) - (3)].val))) {
09920                             (yyval.val) = NEW_LIT(ID2SYM(rb_intern("")));
09921                         }
09922                         else {
09923                             VALUE lit;
09924 
09925                             switch (nd_type((yyval.val))) {
09926                               case NODE_DSTR:
09927                                 nd_set_type((yyval.val), NODE_DSYM);
09928                                 break;
09929                               case NODE_STR:
09930                                 lit = (yyval.val)->nd_lit;
09931                                 (yyval.val)->nd_lit = ID2SYM(rb_intern_str(lit));
09932                                 nd_set_type((yyval.val), NODE_LIT);
09933                                 break;
09934                               default:
09935                                 (yyval.val) = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST((yyval.val)));
09936                                 break;
09937                             }
09938                         }
09939 #endif
09940                         (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
09941 
09942                     }
09943     break;
09944 
09945   case 467:
09946 
09947 /* Line 1806 of yacc.c  */
09948 #line 4220 "ripper.y"
09949     {
09950 #if 0
09951                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09952 #endif
09953                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09954 
09955                     }
09956     break;
09957 
09958   case 468:
09959 
09960 /* Line 1806 of yacc.c  */
09961 #line 4228 "ripper.y"
09962     {
09963 #if 0
09964                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09965 #endif
09966                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09967 
09968                     }
09969     break;
09970 
09971   case 474:
09972 
09973 /* Line 1806 of yacc.c  */
09974 #line 4242 "ripper.y"
09975     {ifndef_ripper((yyval.val) = keyword_nil);}
09976     break;
09977 
09978   case 475:
09979 
09980 /* Line 1806 of yacc.c  */
09981 #line 4243 "ripper.y"
09982     {ifndef_ripper((yyval.val) = keyword_self);}
09983     break;
09984 
09985   case 476:
09986 
09987 /* Line 1806 of yacc.c  */
09988 #line 4244 "ripper.y"
09989     {ifndef_ripper((yyval.val) = keyword_true);}
09990     break;
09991 
09992   case 477:
09993 
09994 /* Line 1806 of yacc.c  */
09995 #line 4245 "ripper.y"
09996     {ifndef_ripper((yyval.val) = keyword_false);}
09997     break;
09998 
09999   case 478:
10000 
10001 /* Line 1806 of yacc.c  */
10002 #line 4246 "ripper.y"
10003     {ifndef_ripper((yyval.val) = keyword__FILE__);}
10004     break;
10005 
10006   case 479:
10007 
10008 /* Line 1806 of yacc.c  */
10009 #line 4247 "ripper.y"
10010     {ifndef_ripper((yyval.val) = keyword__LINE__);}
10011     break;
10012 
10013   case 480:
10014 
10015 /* Line 1806 of yacc.c  */
10016 #line 4248 "ripper.y"
10017     {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10018     break;
10019 
10020   case 481:
10021 
10022 /* Line 1806 of yacc.c  */
10023 #line 4252 "ripper.y"
10024     {
10025 #if 0
10026                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10027 #endif
10028                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10029 
10030                     }
10031     break;
10032 
10033   case 482:
10034 
10035 /* Line 1806 of yacc.c  */
10036 #line 4262 "ripper.y"
10037     {
10038                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10039 #if 0
10040 #endif
10041                         (yyval.val) = dispatch1(var_field, (yyval.val));
10042 
10043                     }
10044     break;
10045 
10046   case 485:
10047 
10048 /* Line 1806 of yacc.c  */
10049 #line 4276 "ripper.y"
10050     {
10051 #if 0
10052                         (yyval.val) = 0;
10053 #endif
10054                         (yyval.val) = Qnil;
10055 
10056                     }
10057     break;
10058 
10059   case 486:
10060 
10061 /* Line 1806 of yacc.c  */
10062 #line 4284 "ripper.y"
10063     {
10064                         lex_state = EXPR_BEG;
10065                     }
10066     break;
10067 
10068   case 487:
10069 
10070 /* Line 1806 of yacc.c  */
10071 #line 4288 "ripper.y"
10072     {
10073                         (yyval.val) = (yyvsp[(3) - (4)].val);
10074                     }
10075     break;
10076 
10077   case 488:
10078 
10079 /* Line 1806 of yacc.c  */
10080 #line 4292 "ripper.y"
10081     {
10082 #if 0
10083                         yyerrok;
10084                         (yyval.val) = 0;
10085 #endif
10086                         yyerrok;
10087                         (yyval.val) = Qnil;
10088 
10089                     }
10090     break;
10091 
10092   case 489:
10093 
10094 /* Line 1806 of yacc.c  */
10095 #line 4304 "ripper.y"
10096     {
10097 #if 0
10098                         (yyval.val) = (yyvsp[(2) - (3)].val);
10099 #endif
10100                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10101 
10102                         lex_state = EXPR_BEG;
10103                         command_start = TRUE;
10104                     }
10105     break;
10106 
10107   case 490:
10108 
10109 /* Line 1806 of yacc.c  */
10110 #line 4314 "ripper.y"
10111     {
10112                         (yyval.val) = (yyvsp[(1) - (2)].val);
10113                     }
10114     break;
10115 
10116   case 491:
10117 
10118 /* Line 1806 of yacc.c  */
10119 #line 4320 "ripper.y"
10120     {
10121 #if 0
10122                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
10123 #endif
10124                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnil, escape_Qundef((yyvsp[(6) - (6)].val)));
10125 
10126                     }
10127     break;
10128 
10129   case 492:
10130 
10131 /* Line 1806 of yacc.c  */
10132 #line 4328 "ripper.y"
10133     {
10134 #if 0
10135                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10136 #endif
10137                         (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)));
10138 
10139                     }
10140     break;
10141 
10142   case 493:
10143 
10144 /* Line 1806 of yacc.c  */
10145 #line 4336 "ripper.y"
10146     {
10147 #if 0
10148                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
10149 #endif
10150                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10151 
10152                     }
10153     break;
10154 
10155   case 494:
10156 
10157 /* Line 1806 of yacc.c  */
10158 #line 4344 "ripper.y"
10159     {
10160 #if 0
10161                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10162 #endif
10163                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnil, (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10164 
10165                     }
10166     break;
10167 
10168   case 495:
10169 
10170 /* Line 1806 of yacc.c  */
10171 #line 4352 "ripper.y"
10172     {
10173 #if 0
10174                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10175 #endif
10176                         (yyval.val) = params_new((yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10177 
10178                     }
10179     break;
10180 
10181   case 496:
10182 
10183 /* Line 1806 of yacc.c  */
10184 #line 4360 "ripper.y"
10185     {
10186 #if 0
10187                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10188 #endif
10189                         (yyval.val) = params_new((yyvsp[(1) - (6)].val), Qnil, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10190 
10191                     }
10192     break;
10193 
10194   case 497:
10195 
10196 /* Line 1806 of yacc.c  */
10197 #line 4368 "ripper.y"
10198     {
10199 #if 0
10200                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
10201 #endif
10202                         (yyval.val) = params_new((yyvsp[(1) - (2)].val), Qnil, Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10203 
10204                     }
10205     break;
10206 
10207   case 498:
10208 
10209 /* Line 1806 of yacc.c  */
10210 #line 4376 "ripper.y"
10211     {
10212 #if 0
10213                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10214 #endif
10215                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnil, escape_Qundef((yyvsp[(4) - (4)].val)));
10216 
10217                     }
10218     break;
10219 
10220   case 499:
10221 
10222 /* Line 1806 of yacc.c  */
10223 #line 4384 "ripper.y"
10224     {
10225 #if 0
10226                         (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10227 #endif
10228                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), escape_Qundef((yyvsp[(6) - (6)].val)));
10229 
10230                     }
10231     break;
10232 
10233   case 500:
10234 
10235 /* Line 1806 of yacc.c  */
10236 #line 4392 "ripper.y"
10237     {
10238 #if 0
10239                         (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
10240 #endif
10241                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (2)].val), Qnil, Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10242 
10243                     }
10244     break;
10245 
10246   case 501:
10247 
10248 /* Line 1806 of yacc.c  */
10249 #line 4400 "ripper.y"
10250     {
10251 #if 0
10252                         (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10253 #endif
10254                         (yyval.val) = params_new(Qnil, (yyvsp[(1) - (4)].val), Qnil, (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10255 
10256                     }
10257     break;
10258 
10259   case 502:
10260 
10261 /* Line 1806 of yacc.c  */
10262 #line 4408 "ripper.y"
10263     {
10264 #if 0
10265                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
10266 #endif
10267                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (2)].val), Qnil,escape_Qundef((yyvsp[(2) - (2)].val)));
10268 
10269                     }
10270     break;
10271 
10272   case 503:
10273 
10274 /* Line 1806 of yacc.c  */
10275 #line 4416 "ripper.y"
10276     {
10277 #if 0
10278                         (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10279 #endif
10280                         (yyval.val) = params_new(Qnil, Qnil, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), escape_Qundef((yyvsp[(4) - (4)].val)));
10281 
10282                     }
10283     break;
10284 
10285   case 504:
10286 
10287 /* Line 1806 of yacc.c  */
10288 #line 4424 "ripper.y"
10289     {
10290 #if 0
10291                         (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
10292 #endif
10293                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, (yyvsp[(1) - (1)].val));
10294 
10295                     }
10296     break;
10297 
10298   case 505:
10299 
10300 /* Line 1806 of yacc.c  */
10301 #line 4432 "ripper.y"
10302     {
10303 #if 0
10304                         (yyval.val) = new_args(0, 0, 0, 0, 0);
10305 #endif
10306                         (yyval.val) = params_new(Qnil, Qnil, Qnil, Qnil, Qnil);
10307 
10308                     }
10309     break;
10310 
10311   case 506:
10312 
10313 /* Line 1806 of yacc.c  */
10314 #line 4442 "ripper.y"
10315     {
10316 #if 0
10317                         yyerror("formal argument cannot be a constant");
10318                         (yyval.val) = 0;
10319 #endif
10320                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10321 
10322                     }
10323     break;
10324 
10325   case 507:
10326 
10327 /* Line 1806 of yacc.c  */
10328 #line 4451 "ripper.y"
10329     {
10330 #if 0
10331                         yyerror("formal argument cannot be an instance variable");
10332                         (yyval.val) = 0;
10333 #endif
10334                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10335 
10336                     }
10337     break;
10338 
10339   case 508:
10340 
10341 /* Line 1806 of yacc.c  */
10342 #line 4460 "ripper.y"
10343     {
10344 #if 0
10345                         yyerror("formal argument cannot be a global variable");
10346                         (yyval.val) = 0;
10347 #endif
10348                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10349 
10350                     }
10351     break;
10352 
10353   case 509:
10354 
10355 /* Line 1806 of yacc.c  */
10356 #line 4469 "ripper.y"
10357     {
10358 #if 0
10359                         yyerror("formal argument cannot be a class variable");
10360                         (yyval.val) = 0;
10361 #endif
10362                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10363 
10364                     }
10365     break;
10366 
10367   case 511:
10368 
10369 /* Line 1806 of yacc.c  */
10370 #line 4481 "ripper.y"
10371     {
10372                         formal_argument(get_id((yyvsp[(1) - (1)].val)));
10373                         (yyval.val) = (yyvsp[(1) - (1)].val);
10374                     }
10375     break;
10376 
10377   case 512:
10378 
10379 /* Line 1806 of yacc.c  */
10380 #line 4488 "ripper.y"
10381     {
10382                         arg_var(get_id((yyvsp[(1) - (1)].val)));
10383 #if 0
10384                         (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10385 #endif
10386                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10387 
10388                     }
10389     break;
10390 
10391   case 513:
10392 
10393 /* Line 1806 of yacc.c  */
10394 #line 4497 "ripper.y"
10395     {
10396                         ID tid = internal_id();
10397                         arg_var(tid);
10398 #if 0
10399                         if (dyna_in_block()) {
10400                             (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10401                         }
10402                         else {
10403                             (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10404                         }
10405                         (yyval.val) = NEW_ARGS_AUX(tid, 1);
10406                         (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10407 #endif
10408                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10409 
10410                     }
10411     break;
10412 
10413   case 514:
10414 
10415 /* Line 1806 of yacc.c  */
10416 #line 4518 "ripper.y"
10417     {
10418                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10419                     }
10420     break;
10421 
10422   case 515:
10423 
10424 /* Line 1806 of yacc.c  */
10425 #line 4523 "ripper.y"
10426     {
10427 #if 0
10428                         (yyval.val) = (yyvsp[(1) - (3)].val);
10429                         (yyval.val)->nd_plen++;
10430                         (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10431                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10432 #endif
10433                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10434 
10435                     }
10436     break;
10437 
10438   case 516:
10439 
10440 /* Line 1806 of yacc.c  */
10441 #line 4536 "ripper.y"
10442     {
10443                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10444                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10445 #if 0
10446                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10447 #endif
10448                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10449 
10450                     }
10451     break;
10452 
10453   case 517:
10454 
10455 /* Line 1806 of yacc.c  */
10456 #line 4548 "ripper.y"
10457     {
10458                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10459                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10460 #if 0
10461                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10462 #endif
10463                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10464 
10465                     }
10466     break;
10467 
10468   case 518:
10469 
10470 /* Line 1806 of yacc.c  */
10471 #line 4560 "ripper.y"
10472     {
10473 #if 0
10474                         (yyval.val) = (yyvsp[(1) - (1)].val);
10475 #endif
10476                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10477 
10478                     }
10479     break;
10480 
10481   case 519:
10482 
10483 /* Line 1806 of yacc.c  */
10484 #line 4568 "ripper.y"
10485     {
10486 #if 0
10487                         NODE *opts = (yyvsp[(1) - (3)].val);
10488 
10489                         while (opts->nd_next) {
10490                             opts = opts->nd_next;
10491                         }
10492                         opts->nd_next = (yyvsp[(3) - (3)].val);
10493                         (yyval.val) = (yyvsp[(1) - (3)].val);
10494 #endif
10495                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10496 
10497                     }
10498     break;
10499 
10500   case 520:
10501 
10502 /* Line 1806 of yacc.c  */
10503 #line 4584 "ripper.y"
10504     {
10505 #if 0
10506                         (yyval.val) = (yyvsp[(1) - (1)].val);
10507 #endif
10508                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10509 
10510                     }
10511     break;
10512 
10513   case 521:
10514 
10515 /* Line 1806 of yacc.c  */
10516 #line 4592 "ripper.y"
10517     {
10518 #if 0
10519                         NODE *opts = (yyvsp[(1) - (3)].val);
10520 
10521                         while (opts->nd_next) {
10522                             opts = opts->nd_next;
10523                         }
10524                         opts->nd_next = (yyvsp[(3) - (3)].val);
10525                         (yyval.val) = (yyvsp[(1) - (3)].val);
10526 #endif
10527                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10528 
10529                     }
10530     break;
10531 
10532   case 524:
10533 
10534 /* Line 1806 of yacc.c  */
10535 #line 4612 "ripper.y"
10536     {
10537 #if 0
10538                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10539                             yyerror("rest argument must be local variable");
10540 #endif
10541                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10542 #if 0
10543                         (yyval.val) = (yyvsp[(2) - (2)].val);
10544 #endif
10545                         (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
10546 
10547                     }
10548     break;
10549 
10550   case 525:
10551 
10552 /* Line 1806 of yacc.c  */
10553 #line 4625 "ripper.y"
10554     {
10555 #if 0
10556                         (yyval.val) = internal_id();
10557                         arg_var((yyval.val));
10558 #endif
10559                         (yyval.val) = dispatch1(rest_param, Qnil);
10560 
10561                     }
10562     break;
10563 
10564   case 528:
10565 
10566 /* Line 1806 of yacc.c  */
10567 #line 4640 "ripper.y"
10568     {
10569 #if 0
10570                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10571                             yyerror("block argument must be local variable");
10572                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
10573                             yyerror("duplicated block argument name");
10574 #endif
10575                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10576 #if 0
10577                         (yyval.val) = (yyvsp[(2) - (2)].val);
10578 #endif
10579                         (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
10580 
10581                     }
10582     break;
10583 
10584   case 529:
10585 
10586 /* Line 1806 of yacc.c  */
10587 #line 4657 "ripper.y"
10588     {
10589                         (yyval.val) = (yyvsp[(2) - (2)].val);
10590                     }
10591     break;
10592 
10593   case 530:
10594 
10595 /* Line 1806 of yacc.c  */
10596 #line 4661 "ripper.y"
10597     {
10598 #if 0
10599                         (yyval.val) = 0;
10600 #endif
10601                         (yyval.val) = Qundef;
10602 
10603                     }
10604     break;
10605 
10606   case 531:
10607 
10608 /* Line 1806 of yacc.c  */
10609 #line 4671 "ripper.y"
10610     {
10611 #if 0
10612                         value_expr((yyvsp[(1) - (1)].val));
10613                         (yyval.val) = (yyvsp[(1) - (1)].val);
10614                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
10615 #endif
10616                         (yyval.val) = (yyvsp[(1) - (1)].val);
10617 
10618                     }
10619     break;
10620 
10621   case 532:
10622 
10623 /* Line 1806 of yacc.c  */
10624 #line 4680 "ripper.y"
10625     {lex_state = EXPR_BEG;}
10626     break;
10627 
10628   case 533:
10629 
10630 /* Line 1806 of yacc.c  */
10631 #line 4681 "ripper.y"
10632     {
10633 #if 0
10634                         if ((yyvsp[(3) - (4)].val) == 0) {
10635                             yyerror("can't define singleton method for ().");
10636                         }
10637                         else {
10638                             switch (nd_type((yyvsp[(3) - (4)].val))) {
10639                               case NODE_STR:
10640                               case NODE_DSTR:
10641                               case NODE_XSTR:
10642                               case NODE_DXSTR:
10643                               case NODE_DREGX:
10644                               case NODE_LIT:
10645                               case NODE_ARRAY:
10646                               case NODE_ZARRAY:
10647                                 yyerror("can't define singleton method for literals");
10648                               default:
10649                                 value_expr((yyvsp[(3) - (4)].val));
10650                                 break;
10651                             }
10652                         }
10653                         (yyval.val) = (yyvsp[(3) - (4)].val);
10654 #endif
10655                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
10656 
10657                     }
10658     break;
10659 
10660   case 535:
10661 
10662 /* Line 1806 of yacc.c  */
10663 #line 4711 "ripper.y"
10664     {
10665 #if 0
10666                         (yyval.val) = (yyvsp[(1) - (2)].val);
10667 #endif
10668                         (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
10669 
10670                     }
10671     break;
10672 
10673   case 536:
10674 
10675 /* Line 1806 of yacc.c  */
10676 #line 4723 "ripper.y"
10677     {
10678                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10679                     }
10680     break;
10681 
10682   case 537:
10683 
10684 /* Line 1806 of yacc.c  */
10685 #line 4728 "ripper.y"
10686     {
10687 #if 0
10688                         (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10689 #endif
10690                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10691 
10692                     }
10693     break;
10694 
10695   case 538:
10696 
10697 /* Line 1806 of yacc.c  */
10698 #line 4738 "ripper.y"
10699     {
10700 #if 0
10701                         (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
10702 #endif
10703                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10704 
10705                     }
10706     break;
10707 
10708   case 539:
10709 
10710 /* Line 1806 of yacc.c  */
10711 #line 4746 "ripper.y"
10712     {
10713 #if 0
10714                         (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
10715 #endif
10716                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10717 
10718                     }
10719     break;
10720 
10721   case 550:
10722 
10723 /* Line 1806 of yacc.c  */
10724 #line 4774 "ripper.y"
10725     { (yyval.val) = (yyvsp[(1) - (1)].val); }
10726     break;
10727 
10728   case 551:
10729 
10730 /* Line 1806 of yacc.c  */
10731 #line 4779 "ripper.y"
10732     { (yyval.val) = (yyvsp[(1) - (1)].val); }
10733     break;
10734 
10735   case 561:
10736 
10737 /* Line 1806 of yacc.c  */
10738 #line 4802 "ripper.y"
10739     {yyerrok;}
10740     break;
10741 
10742   case 564:
10743 
10744 /* Line 1806 of yacc.c  */
10745 #line 4807 "ripper.y"
10746     {yyerrok;}
10747     break;
10748 
10749   case 565:
10750 
10751 /* Line 1806 of yacc.c  */
10752 #line 4811 "ripper.y"
10753     {
10754 #if 0
10755                         (yyval.val) = 0;
10756 #endif
10757                         (yyval.val) = Qundef;
10758 
10759                     }
10760     break;
10761 
10762 
10763 
10764 /* Line 1806 of yacc.c  */
10765 #line 10764 "parse.c"
10766       default: break;
10767     }
10768   /* User semantic actions sometimes alter yychar, and that requires
10769      that yytoken be updated with the new translation.  We take the
10770      approach of translating immediately before every use of yytoken.
10771      One alternative is translating here after every semantic action,
10772      but that translation would be missed if the semantic action invokes
10773      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10774      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
10775      incorrect destructor might then be invoked immediately.  In the
10776      case of YYERROR or YYBACKUP, subsequent parser actions might lead
10777      to an incorrect destructor call or verbose syntax error message
10778      before the lookahead is translated.  */
10779   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10780 
10781   YYPOPSTACK (yylen);
10782   yylen = 0;
10783   YY_STACK_PRINT (yyss, yyssp);
10784 
10785   *++yyvsp = yyval;
10786 
10787   /* Now `shift' the result of the reduction.  Determine what state
10788      that goes to, based on the state we popped back to and the rule
10789      number reduced by.  */
10790 
10791   yyn = yyr1[yyn];
10792 
10793   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10794   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10795     yystate = yytable[yystate];
10796   else
10797     yystate = yydefgoto[yyn - YYNTOKENS];
10798 
10799   goto yynewstate;
10800 
10801 
10802 /*------------------------------------.
10803 | yyerrlab -- here on detecting error |
10804 `------------------------------------*/
10805 yyerrlab:
10806   /* Make sure we have latest lookahead translation.  See comments at
10807      user semantic actions for why this is necessary.  */
10808   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
10809 
10810   /* If not already recovering from an error, report this error.  */
10811   if (!yyerrstatus)
10812     {
10813       ++yynerrs;
10814 #if ! YYERROR_VERBOSE
10815       parser_yyerror (parser, YY_("syntax error"));
10816 #else
10817 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
10818                                         yyssp, yytoken)
10819       {
10820         char const *yymsgp = YY_("syntax error");
10821         int yysyntax_error_status;
10822         yysyntax_error_status = YYSYNTAX_ERROR;
10823         if (yysyntax_error_status == 0)
10824           yymsgp = yymsg;
10825         else if (yysyntax_error_status == 1)
10826           {
10827             if (yymsg != yymsgbuf)
10828               YYSTACK_FREE (yymsg);
10829             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
10830             if (!yymsg)
10831               {
10832                 yymsg = yymsgbuf;
10833                 yymsg_alloc = sizeof yymsgbuf;
10834                 yysyntax_error_status = 2;
10835               }
10836             else
10837               {
10838                 yysyntax_error_status = YYSYNTAX_ERROR;
10839                 yymsgp = yymsg;
10840               }
10841           }
10842         parser_yyerror (parser, yymsgp);
10843         if (yysyntax_error_status == 2)
10844           goto yyexhaustedlab;
10845       }
10846 # undef YYSYNTAX_ERROR
10847 #endif
10848     }
10849 
10850 
10851 
10852   if (yyerrstatus == 3)
10853     {
10854       /* If just tried and failed to reuse lookahead token after an
10855          error, discard it.  */
10856 
10857       if (yychar <= YYEOF)
10858         {
10859           /* Return failure if at end of input.  */
10860           if (yychar == YYEOF)
10861             YYABORT;
10862         }
10863       else
10864         {
10865           yydestruct ("Error: discarding",
10866                       yytoken, &yylval, parser);
10867           yychar = YYEMPTY;
10868         }
10869     }
10870 
10871   /* Else will try to reuse lookahead token after shifting the error
10872      token.  */
10873   goto yyerrlab1;
10874 
10875 
10876 /*---------------------------------------------------.
10877 | yyerrorlab -- error raised explicitly by YYERROR.  |
10878 `---------------------------------------------------*/
10879 yyerrorlab:
10880 
10881   /* Pacify compilers like GCC when the user code never invokes
10882      YYERROR and the label yyerrorlab therefore never appears in user
10883      code.  */
10884   if (/*CONSTCOND*/ 0)
10885      goto yyerrorlab;
10886 
10887   /* Do not reclaim the symbols of the rule which action triggered
10888      this YYERROR.  */
10889   YYPOPSTACK (yylen);
10890   yylen = 0;
10891   YY_STACK_PRINT (yyss, yyssp);
10892   yystate = *yyssp;
10893   goto yyerrlab1;
10894 
10895 
10896 /*-------------------------------------------------------------.
10897 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
10898 `-------------------------------------------------------------*/
10899 yyerrlab1:
10900   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
10901 
10902   for (;;)
10903     {
10904       yyn = yypact[yystate];
10905       if (!yypact_value_is_default (yyn))
10906         {
10907           yyn += YYTERROR;
10908           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10909             {
10910               yyn = yytable[yyn];
10911               if (0 < yyn)
10912                 break;
10913             }
10914         }
10915 
10916       /* Pop the current state because it cannot handle the error token.  */
10917       if (yyssp == yyss)
10918         YYABORT;
10919 
10920 
10921       yydestruct ("Error: popping",
10922                   yystos[yystate], yyvsp, parser);
10923       YYPOPSTACK (1);
10924       yystate = *yyssp;
10925       YY_STACK_PRINT (yyss, yyssp);
10926     }
10927 
10928   *++yyvsp = yylval;
10929 
10930 
10931   /* Shift the error token.  */
10932   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
10933 
10934   yystate = yyn;
10935   goto yynewstate;
10936 
10937 
10938 /*-------------------------------------.
10939 | yyacceptlab -- YYACCEPT comes here.  |
10940 `-------------------------------------*/
10941 yyacceptlab:
10942   yyresult = 0;
10943   goto yyreturn;
10944 
10945 /*-----------------------------------.
10946 | yyabortlab -- YYABORT comes here.  |
10947 `-----------------------------------*/
10948 yyabortlab:
10949   yyresult = 1;
10950   goto yyreturn;
10951 
10952 #if !defined(yyoverflow) || YYERROR_VERBOSE
10953 /*-------------------------------------------------.
10954 | yyexhaustedlab -- memory exhaustion comes here.  |
10955 `-------------------------------------------------*/
10956 yyexhaustedlab:
10957   parser_yyerror (parser, YY_("memory exhausted"));
10958   yyresult = 2;
10959   /* Fall through.  */
10960 #endif
10961 
10962 yyreturn:
10963   if (yychar != YYEMPTY)
10964     {
10965       /* Make sure we have latest lookahead translation.  See comments at
10966          user semantic actions for why this is necessary.  */
10967       yytoken = YYTRANSLATE (yychar);
10968       yydestruct ("Cleanup: discarding lookahead",
10969                   yytoken, &yylval, parser);
10970     }
10971   /* Do not reclaim the symbols of the rule which action triggered
10972      this YYABORT or YYACCEPT.  */
10973   YYPOPSTACK (yylen);
10974   YY_STACK_PRINT (yyss, yyssp);
10975   while (yyssp != yyss)
10976     {
10977       yydestruct ("Cleanup: popping",
10978                   yystos[*yyssp], yyvsp, parser);
10979       YYPOPSTACK (1);
10980     }
10981 #ifndef yyoverflow
10982   if (yyss != yyssa)
10983     YYSTACK_FREE (yyss);
10984 #endif
10985 #if YYERROR_VERBOSE
10986   if (yymsg != yymsgbuf)
10987     YYSTACK_FREE (yymsg);
10988 #endif
10989   /* Make sure YYID is used.  */
10990   return YYID (yyresult);
10991 }
10992 
10993 
10994 
10995 /* Line 2067 of yacc.c  */
10996 #line 4819 "ripper.y"
10997 
10998 # undef parser
10999 # undef yylex
11000 # undef yylval
11001 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
11002 
11003 static int parser_regx_options(struct parser_params*);
11004 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11005 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11006 static int parser_parse_string(struct parser_params*,NODE*);
11007 static int parser_here_document(struct parser_params*,NODE*);
11008 
11009 
11010 # define nextc()                   parser_nextc(parser)
11011 # define pushback(c)               parser_pushback(parser, c)
11012 # define newtok()                  parser_newtok(parser)
11013 # define tokspace(n)               parser_tokspace(parser, n)
11014 # define tokadd(c)                 parser_tokadd(parser, c)
11015 # define tok_hex(numlen)           parser_tok_hex(parser, numlen)
11016 # define read_escape(flags,e)      parser_read_escape(parser, flags, e)
11017 # define tokadd_escape(e)          parser_tokadd_escape(parser, e)
11018 # define regx_options()            parser_regx_options(parser)
11019 # define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser,f,t,p,n,e)
11020 # define parse_string(n)           parser_parse_string(parser,n)
11021 # define tokaddmbc(c, enc)         parser_tokaddmbc(parser, c, enc)
11022 # define here_document(n)          parser_here_document(parser,n)
11023 # define heredoc_identifier()      parser_heredoc_identifier(parser)
11024 # define heredoc_restore(n)        parser_heredoc_restore(parser,n)
11025 # define whole_match_p(e,l,i)      parser_whole_match_p(parser,e,l,i)
11026 
11027 #ifndef RIPPER
11028 # define set_yylval_str(x) yylval.node = NEW_STR(x)
11029 # define set_yylval_num(x) yylval.num = x
11030 # define set_yylval_id(x)  yylval.id = x
11031 # define set_yylval_name(x)  yylval.id = x
11032 # define set_yylval_literal(x) yylval.node = NEW_LIT(x)
11033 # define set_yylval_node(x) yylval.node = x
11034 # define yylval_id() yylval.id
11035 #else
11036 static inline VALUE
11037 ripper_yylval_id(ID x)
11038 {
11039     return (VALUE)NEW_LASGN(x, ID2SYM(x));
11040 }
11041 # define set_yylval_str(x) (void)(x)
11042 # define set_yylval_num(x) (void)(x)
11043 # define set_yylval_id(x)  (void)(x)
11044 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11045 # define set_yylval_literal(x) (void)(x)
11046 # define set_yylval_node(x) (void)(x)
11047 # define yylval_id() yylval.id
11048 #endif
11049 
11050 #ifndef RIPPER
11051 #define ripper_flush(p) (void)(p)
11052 #else
11053 #define ripper_flush(p) (p->tokp = p->parser_lex_p)
11054 
11055 #define yylval_rval *(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val)
11056 
11057 static int
11058 ripper_has_scan_event(struct parser_params *parser)
11059 {
11060 
11061     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11062     return lex_p > parser->tokp;
11063 }
11064 
11065 static VALUE
11066 ripper_scan_event_val(struct parser_params *parser, int t)
11067 {
11068     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11069     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11070     ripper_flush(parser);
11071     return rval;
11072 }
11073 
11074 static void
11075 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11076 {
11077     if (!ripper_has_scan_event(parser)) return;
11078     yylval_rval = ripper_scan_event_val(parser, t);
11079 }
11080 
11081 static void
11082 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11083 {
11084     if (!ripper_has_scan_event(parser)) return;
11085     (void)ripper_scan_event_val(parser, t);
11086 }
11087 
11088 static void
11089 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11090 {
11091     int saved_line = ruby_sourceline;
11092     const char *saved_tokp = parser->tokp;
11093 
11094     ruby_sourceline = parser->delayed_line;
11095     parser->tokp = lex_pbeg + parser->delayed_col;
11096     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11097     parser->delayed = Qnil;
11098     ruby_sourceline = saved_line;
11099     parser->tokp = saved_tokp;
11100 }
11101 #endif /* RIPPER */
11102 
11103 #include "ruby/regex.h"
11104 #include "ruby/util.h"
11105 
11106 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11107    since ours (we hope) works properly with all combinations of
11108    machines, compilers, `char' and `unsigned char' argument types.
11109    (Per Bothner suggested the basic approach.)  */
11110 #undef SIGN_EXTEND_CHAR
11111 #if __STDC__
11112 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11113 #else  /* not __STDC__ */
11114 /* As in Harbison and Steele.  */
11115 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11116 #endif
11117 
11118 #define parser_encoding_name()  (parser->enc->name)
11119 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,parser->enc)
11120 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,parser->enc)
11121 #define is_identchar(p,e,enc) (rb_enc_isalnum(*p,enc) || (*p) == '_' || !ISASCII(*p))
11122 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,parser->enc))
11123 
11124 #define parser_isascii() ISASCII(*(lex_p-1))
11125 
11126 #ifndef RIPPER
11127 static int
11128 token_info_get_column(struct parser_params *parser, const char *token)
11129 {
11130     int column = 1;
11131     const char *p, *pend = lex_p - strlen(token);
11132     for (p = lex_pbeg; p < pend; p++) {
11133         if (*p == '\t') {
11134             column = (((column - 1) / 8) + 1) * 8;
11135         }
11136         column++;
11137     }
11138     return column;
11139 }
11140 
11141 static int
11142 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11143 {
11144     const char *p, *pend = lex_p - strlen(token);
11145     for (p = lex_pbeg; p < pend; p++) {
11146         if (*p != ' ' && *p != '\t') {
11147             return 1;
11148         }
11149     }
11150     return 0;
11151 }
11152 
11153 #undef token_info_push
11154 static void
11155 token_info_push(struct parser_params *parser, const char *token)
11156 {
11157     token_info *ptinfo;
11158 
11159     if (compile_for_eval) return;
11160     ptinfo = ALLOC(token_info);
11161     ptinfo->token = token;
11162     ptinfo->linenum = ruby_sourceline;
11163     ptinfo->column = token_info_get_column(parser, token);
11164     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11165     ptinfo->next = parser->parser_token_info;
11166 
11167     parser->parser_token_info = ptinfo;
11168 }
11169 
11170 #undef token_info_pop
11171 static void
11172 token_info_pop(struct parser_params *parser, const char *token)
11173 {
11174     int linenum;
11175     token_info *ptinfo = parser->parser_token_info;
11176 
11177     if (!ptinfo) return;
11178     parser->parser_token_info = ptinfo->next;
11179     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11180         goto finish;
11181     }
11182     linenum = ruby_sourceline;
11183     if (linenum == ptinfo->linenum) { /* SKIP */
11184         goto finish;
11185     }
11186     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11187         goto finish;
11188     }
11189     rb_compile_warning(ruby_sourcefile, linenum,
11190                "mismatched indentations at '%s' with '%s' at %d",
11191                token, ptinfo->token, ptinfo->linenum);
11192 
11193   finish:
11194     xfree(ptinfo);
11195 }
11196 #endif  /* RIPPER */
11197 
11198 static int
11199 parser_yyerror(struct parser_params *parser, const char *msg)
11200 {
11201 #ifndef RIPPER
11202     const int max_line_margin = 30;
11203     const char *p, *pe;
11204     char *buf;
11205     long len;
11206     int i;
11207 
11208     compile_error(PARSER_ARG "%s", msg);
11209     p = lex_p;
11210     while (lex_pbeg <= p) {
11211         if (*p == '\n') break;
11212         p--;
11213     }
11214     p++;
11215 
11216     pe = lex_p;
11217     while (pe < lex_pend) {
11218         if (*pe == '\n') break;
11219         pe++;
11220     }
11221 
11222     len = pe - p;
11223     if (len > 4) {
11224         char *p2;
11225         const char *pre = "", *post = "";
11226 
11227         if (len > max_line_margin * 2 + 10) {
11228             if (lex_p - p > max_line_margin) {
11229                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11230                 pre = "...";
11231             }
11232             if (pe - lex_p > max_line_margin) {
11233                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11234                 post = "...";
11235             }
11236             len = pe - p;
11237         }
11238         buf = ALLOCA_N(char, len+2);
11239         MEMCPY(buf, p, char, len);
11240         buf[len] = '\0';
11241         rb_compile_error_append("%s%s%s", pre, buf, post);
11242 
11243         i = (int)(lex_p - p);
11244         p2 = buf; pe = buf + len;
11245 
11246         while (p2 < pe) {
11247             if (*p2 != '\t') *p2 = ' ';
11248             p2++;
11249         }
11250         buf[i] = '^';
11251         buf[i+1] = '\0';
11252         rb_compile_error_append("%s%s", pre, buf);
11253     }
11254 #else
11255     dispatch1(parse_error, STR_NEW2(msg));
11256 #endif /* !RIPPER */
11257     return 0;
11258 }
11259 
11260 static void parser_prepare(struct parser_params *parser);
11261 
11262 #ifndef RIPPER
11263 VALUE ruby_suppress_tracing(VALUE (*func)(VALUE, int), VALUE arg, int always);
11264 
11265 static VALUE
11266 debug_lines(const char *f)
11267 {
11268     ID script_lines;
11269     CONST_ID(script_lines, "SCRIPT_LINES__");
11270     if (rb_const_defined_at(rb_cObject, script_lines)) {
11271         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11272         if (TYPE(hash) == T_HASH) {
11273             VALUE fname = rb_str_new2(f);
11274             VALUE lines = rb_ary_new();
11275             rb_hash_aset(hash, fname, lines);
11276             return lines;
11277         }
11278     }
11279     return 0;
11280 }
11281 
11282 static VALUE
11283 coverage(const char *f, int n)
11284 {
11285     extern VALUE rb_get_coverages(void);
11286     VALUE coverages = rb_get_coverages();
11287     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11288         VALUE fname = rb_str_new2(f);
11289         VALUE lines = rb_ary_new2(n);
11290         int i;
11291         RBASIC(lines)->klass = 0;
11292         for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11293         RARRAY(lines)->as.heap.len = n;
11294         rb_hash_aset(coverages, fname, lines);
11295         return lines;
11296     }
11297     return 0;
11298 }
11299 
11300 static int
11301 e_option_supplied(struct parser_params *parser)
11302 {
11303     return strcmp(ruby_sourcefile, "-e") == 0;
11304 }
11305 
11306 static VALUE
11307 yycompile0(VALUE arg, int tracing)
11308 {
11309     int n;
11310     NODE *tree;
11311     struct parser_params *parser = (struct parser_params *)arg;
11312 
11313     if (!compile_for_eval && rb_safe_level() == 0) {
11314         ruby_debug_lines = debug_lines(ruby_sourcefile);
11315         if (ruby_debug_lines && ruby_sourceline > 0) {
11316             VALUE str = STR_NEW0();
11317             n = ruby_sourceline;
11318             do {
11319                 rb_ary_push(ruby_debug_lines, str);
11320             } while (--n);
11321         }
11322 
11323         if (!e_option_supplied(parser)) {
11324             ruby_coverage = coverage(ruby_sourcefile, ruby_sourceline);
11325         }
11326     }
11327 
11328     parser_prepare(parser);
11329     deferred_nodes = 0;
11330     n = yyparse((void*)parser);
11331     ruby_debug_lines = 0;
11332     ruby_coverage = 0;
11333     compile_for_eval = 0;
11334 
11335     lex_strterm = 0;
11336     lex_p = lex_pbeg = lex_pend = 0;
11337     lex_lastline = lex_nextline = 0;
11338     if (parser->nerr) {
11339         return 0;
11340     }
11341     tree = ruby_eval_tree;
11342     if (!tree) {
11343         tree = NEW_NIL();
11344     }
11345     else if (ruby_eval_tree_begin) {
11346         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11347     }
11348     return (VALUE)tree;
11349 }
11350 
11351 static NODE*
11352 yycompile(struct parser_params *parser, const char *f, int line)
11353 {
11354     ruby_sourcefile = ruby_strdup(f);
11355     ruby_sourceline = line - 1;
11356     return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
11357 }
11358 #endif /* !RIPPER */
11359 
11360 static rb_encoding *
11361 must_be_ascii_compatible(VALUE s)
11362 {
11363     rb_encoding *enc = rb_enc_get(s);
11364     if (!rb_enc_asciicompat(enc)) {
11365         rb_raise(rb_eArgError, "invalid source encoding");
11366     }
11367     return enc;
11368 }
11369 
11370 static VALUE
11371 lex_get_str(struct parser_params *parser, VALUE s)
11372 {
11373     char *beg, *end, *pend;
11374     rb_encoding *enc = must_be_ascii_compatible(s);
11375 
11376     beg = RSTRING_PTR(s);
11377     if (lex_gets_ptr) {
11378         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11379         beg += lex_gets_ptr;
11380     }
11381     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11382     end = beg;
11383     while (end < pend) {
11384         if (*end++ == '\n') break;
11385     }
11386     lex_gets_ptr = end - RSTRING_PTR(s);
11387     return rb_enc_str_new(beg, end - beg, enc);
11388 }
11389 
11390 static VALUE
11391 lex_getline(struct parser_params *parser)
11392 {
11393     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11394     if (NIL_P(line)) return line;
11395     must_be_ascii_compatible(line);
11396 #ifndef RIPPER
11397     if (ruby_debug_lines) {
11398         rb_enc_associate(line, parser->enc);
11399         rb_ary_push(ruby_debug_lines, line);
11400     }
11401     if (ruby_coverage) {
11402         rb_ary_push(ruby_coverage, Qnil);
11403     }
11404 #endif
11405     return line;
11406 }
11407 
11408 static const rb_data_type_t parser_data_type;
11409 
11410 #ifndef RIPPER
11411 static NODE*
11412 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11413 {
11414     struct parser_params *parser;
11415     NODE *node;
11416     volatile VALUE tmp;
11417 
11418     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11419     lex_gets = lex_get_str;
11420     lex_gets_ptr = 0;
11421     lex_input = s;
11422     lex_pbeg = lex_p = lex_pend = 0;
11423     compile_for_eval = rb_parse_in_eval();
11424 
11425     node = yycompile(parser, f, line);
11426     tmp = vparser; /* prohibit tail call optimization */
11427 
11428     return node;
11429 }
11430 
11431 NODE*
11432 rb_compile_string(const char *f, VALUE s, int line)
11433 {
11434     must_be_ascii_compatible(s);
11435     return parser_compile_string(rb_parser_new(), f, s, line);
11436 }
11437 
11438 NODE*
11439 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11440 {
11441     must_be_ascii_compatible(s);
11442     return parser_compile_string(vparser, f, s, line);
11443 }
11444 
11445 NODE*
11446 rb_compile_cstr(const char *f, const char *s, int len, int line)
11447 {
11448     VALUE str = rb_str_new(s, len);
11449     return parser_compile_string(rb_parser_new(), f, str, line);
11450 }
11451 
11452 NODE*
11453 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11454 {
11455     VALUE str = rb_str_new(s, len);
11456     return parser_compile_string(vparser, f, str, line);
11457 }
11458 
11459 static VALUE
11460 lex_io_gets(struct parser_params *parser, VALUE io)
11461 {
11462     return rb_io_gets(io);
11463 }
11464 
11465 NODE*
11466 rb_compile_file(const char *f, VALUE file, int start)
11467 {
11468     VALUE volatile vparser = rb_parser_new();
11469 
11470     return rb_parser_compile_file(vparser, f, file, start);
11471 }
11472 
11473 NODE*
11474 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11475 {
11476     struct parser_params *parser;
11477     volatile VALUE tmp;
11478     NODE *node;
11479 
11480     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11481     lex_gets = lex_io_gets;
11482     lex_input = file;
11483     lex_pbeg = lex_p = lex_pend = 0;
11484     compile_for_eval = rb_parse_in_eval();
11485 
11486     node = yycompile(parser, f, start);
11487     tmp = vparser; /* prohibit tail call optimization */
11488 
11489     return node;
11490 }
11491 #endif  /* !RIPPER */
11492 
11493 #define STR_FUNC_ESCAPE 0x01
11494 #define STR_FUNC_EXPAND 0x02
11495 #define STR_FUNC_REGEXP 0x04
11496 #define STR_FUNC_QWORDS 0x08
11497 #define STR_FUNC_SYMBOL 0x10
11498 #define STR_FUNC_INDENT 0x20
11499 
11500 enum string_type {
11501     str_squote = (0),
11502     str_dquote = (STR_FUNC_EXPAND),
11503     str_xquote = (STR_FUNC_EXPAND),
11504     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
11505     str_sword  = (STR_FUNC_QWORDS),
11506     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
11507     str_ssym   = (STR_FUNC_SYMBOL),
11508     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
11509 };
11510 
11511 static VALUE
11512 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11513 {
11514     VALUE str;
11515 
11516     str = rb_enc_str_new(p, n, enc);
11517     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11518         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
11519         }
11520         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11521             rb_enc_associate(str, rb_ascii8bit_encoding());
11522         }
11523     }
11524 
11525     return str;
11526 }
11527 
11528 #define lex_goto_eol(parser) (parser->parser_lex_p = parser->parser_lex_pend)
11529 #define peek(c) (lex_p < lex_pend && (c) == *lex_p)
11530 
11531 static inline int
11532 parser_nextc(struct parser_params *parser)
11533 {
11534     int c;
11535 
11536     if (lex_p == lex_pend) {
11537         VALUE v = lex_nextline;
11538         lex_nextline = 0;
11539         if (!v) {
11540             if (parser->eofp)
11541                 return -1;
11542 
11543             if (!lex_input || NIL_P(v = lex_getline(parser))) {
11544                 parser->eofp = Qtrue;
11545                 lex_goto_eol(parser);
11546                 return -1;
11547             }
11548         }
11549         {
11550 #ifdef RIPPER
11551             if (parser->tokp < lex_pend) {
11552                 if (NIL_P(parser->delayed)) {
11553                     parser->delayed = rb_str_buf_new(1024);
11554                     rb_str_buf_cat(parser->delayed,
11555                                    parser->tokp, lex_pend - parser->tokp);
11556                     parser->delayed_line = ruby_sourceline;
11557                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11558                 }
11559                 else {
11560                     rb_str_buf_cat(parser->delayed,
11561                                    parser->tokp, lex_pend - parser->tokp);
11562                 }
11563             }
11564 #endif
11565             if (heredoc_end > 0) {
11566                 ruby_sourceline = heredoc_end;
11567                 heredoc_end = 0;
11568             }
11569             ruby_sourceline++;
11570             parser->line_count++;
11571             lex_pbeg = lex_p = RSTRING_PTR(v);
11572             lex_pend = lex_p + RSTRING_LEN(v);
11573             ripper_flush(parser);
11574             lex_lastline = v;
11575         }
11576     }
11577     c = (unsigned char)*lex_p++;
11578     if (c == '\r' && peek('\n')) {
11579         lex_p++;
11580         c = '\n';
11581     }
11582 
11583     return c;
11584 }
11585 
11586 static void
11587 parser_pushback(struct parser_params *parser, int c)
11588 {
11589     if (c == -1) return;
11590     lex_p--;
11591     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11592         lex_p--;
11593     }
11594 }
11595 
11596 #define was_bol() (lex_p == lex_pbeg + 1)
11597 
11598 #define tokfix() (tokenbuf[tokidx]='\0')
11599 #define tok() tokenbuf
11600 #define toklen() tokidx
11601 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11602 
11603 static char*
11604 parser_newtok(struct parser_params *parser)
11605 {
11606     tokidx = 0;
11607     if (!tokenbuf) {
11608         toksiz = 60;
11609         tokenbuf = ALLOC_N(char, 60);
11610     }
11611     if (toksiz > 4096) {
11612         toksiz = 60;
11613         REALLOC_N(tokenbuf, char, 60);
11614     }
11615     return tokenbuf;
11616 }
11617 
11618 static char *
11619 parser_tokspace(struct parser_params *parser, int n)
11620 {
11621     tokidx += n;
11622 
11623     if (tokidx >= toksiz) {
11624         do {toksiz *= 2;} while (toksiz < tokidx);
11625         REALLOC_N(tokenbuf, char, toksiz);
11626     }
11627     return &tokenbuf[tokidx-n];
11628 }
11629 
11630 static void
11631 parser_tokadd(struct parser_params *parser, int c)
11632 {
11633     tokenbuf[tokidx++] = (char)c;
11634     if (tokidx >= toksiz) {
11635         toksiz *= 2;
11636         REALLOC_N(tokenbuf, char, toksiz);
11637     }
11638 }
11639 
11640 static int
11641 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11642 {
11643     int c;
11644 
11645     c = scan_hex(lex_p, 2, numlen);
11646     if (!*numlen) {
11647         yyerror("invalid hex escape");
11648         return 0;
11649     }
11650     lex_p += *numlen;
11651     return c;
11652 }
11653 
11654 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11655 
11656 static int
11657 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
11658                    int string_literal, int symbol_literal, int regexp_literal)
11659 {
11660     /*
11661      * If string_literal is true, then we allow multiple codepoints
11662      * in \u{}, and add the codepoints to the current token.
11663      * Otherwise we're parsing a character literal and return a single
11664      * codepoint without adding it
11665      */
11666 
11667     int codepoint;
11668     size_t numlen;
11669 
11670     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11671 
11672     if (peek('{')) {  /* handle \u{...} form */
11673         do {
11674             if (regexp_literal) { tokadd(*lex_p); }
11675             nextc();
11676             codepoint = scan_hex(lex_p, 6, &numlen);
11677             if (numlen == 0)  {
11678                 yyerror("invalid Unicode escape");
11679                 return 0;
11680             }
11681             if (codepoint > 0x10ffff) {
11682                 yyerror("invalid Unicode codepoint (too large)");
11683                 return 0;
11684             }
11685             lex_p += numlen;
11686             if (regexp_literal) {
11687                 tokcopy((int)numlen);
11688             }
11689             else if (codepoint >= 0x80) {
11690                 *encp = UTF8_ENC();
11691                 if (string_literal) tokaddmbc(codepoint, *encp);
11692             }
11693             else if (string_literal) {
11694                 tokadd(codepoint);
11695             }
11696         } while (string_literal && (peek(' ') || peek('\t')));
11697 
11698         if (!peek('}')) {
11699             yyerror("unterminated Unicode escape");
11700             return 0;
11701         }
11702 
11703         if (regexp_literal) { tokadd('}'); }
11704         nextc();
11705     }
11706     else {                      /* handle \uxxxx form */
11707         codepoint = scan_hex(lex_p, 4, &numlen);
11708         if (numlen < 4) {
11709             yyerror("invalid Unicode escape");
11710             return 0;
11711         }
11712         lex_p += 4;
11713         if (regexp_literal) {
11714             tokcopy(4);
11715         }
11716         else if (codepoint >= 0x80) {
11717             *encp = UTF8_ENC();
11718             if (string_literal) tokaddmbc(codepoint, *encp);
11719         }
11720         else if (string_literal) {
11721             tokadd(codepoint);
11722         }
11723     }
11724 
11725     return codepoint;
11726 }
11727 
11728 #define ESCAPE_CONTROL 1
11729 #define ESCAPE_META    2
11730 
11731 static int
11732 parser_read_escape(struct parser_params *parser, int flags,
11733                    rb_encoding **encp)
11734 {
11735     int c;
11736     size_t numlen;
11737 
11738     switch (c = nextc()) {
11739       case '\\':        /* Backslash */
11740         return c;
11741 
11742       case 'n': /* newline */
11743         return '\n';
11744 
11745       case 't': /* horizontal tab */
11746         return '\t';
11747 
11748       case 'r': /* carriage-return */
11749         return '\r';
11750 
11751       case 'f': /* form-feed */
11752         return '\f';
11753 
11754       case 'v': /* vertical tab */
11755         return '\13';
11756 
11757       case 'a': /* alarm(bell) */
11758         return '\007';
11759 
11760       case 'e': /* escape */
11761         return 033;
11762 
11763       case '0': case '1': case '2': case '3': /* octal constant */
11764       case '4': case '5': case '6': case '7':
11765         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11766         pushback(c);
11767         c = scan_oct(lex_p, 3, &numlen);
11768         lex_p += numlen;
11769         return c;
11770 
11771       case 'x': /* hex constant */
11772         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11773         c = tok_hex(&numlen);
11774         if (numlen == 0) return 0;
11775         return c;
11776 
11777       case 'b': /* backspace */
11778         return '\010';
11779 
11780       case 's': /* space */
11781         return ' ';
11782 
11783       case 'M':
11784         if (flags & ESCAPE_META) goto eof;
11785         if ((c = nextc()) != '-') {
11786             pushback(c);
11787             goto eof;
11788         }
11789         if ((c = nextc()) == '\\') {
11790             if (peek('u')) goto eof;
11791             return read_escape(flags|ESCAPE_META, encp) | 0x80;
11792         }
11793         else if (c == -1 || !ISASCII(c)) goto eof;
11794         else {
11795             return ((c & 0xff) | 0x80);
11796         }
11797 
11798       case 'C':
11799         if ((c = nextc()) != '-') {
11800             pushback(c);
11801             goto eof;
11802         }
11803       case 'c':
11804         if (flags & ESCAPE_CONTROL) goto eof;
11805         if ((c = nextc())== '\\') {
11806             if (peek('u')) goto eof;
11807             c = read_escape(flags|ESCAPE_CONTROL, encp);
11808         }
11809         else if (c == '?')
11810             return 0177;
11811         else if (c == -1 || !ISASCII(c)) goto eof;
11812         return c & 0x9f;
11813 
11814       eof:
11815       case -1:
11816         yyerror("Invalid escape character syntax");
11817         return '\0';
11818 
11819       default:
11820         return c;
11821     }
11822 }
11823 
11824 static void
11825 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
11826 {
11827     int len = rb_enc_codelen(c, enc);
11828     rb_enc_mbcput(c, tokspace(len), enc);
11829 }
11830 
11831 static int
11832 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
11833 {
11834     int c;
11835     int flags = 0;
11836     size_t numlen;
11837 
11838   first:
11839     switch (c = nextc()) {
11840       case '\n':
11841         return 0;               /* just ignore */
11842 
11843       case '0': case '1': case '2': case '3': /* octal constant */
11844       case '4': case '5': case '6': case '7':
11845         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11846         {
11847             ruby_scan_oct(--lex_p, 3, &numlen);
11848             if (numlen == 0) goto eof;
11849             lex_p += numlen;
11850             tokcopy((int)numlen + 1);
11851         }
11852         return 0;
11853 
11854       case 'x': /* hex constant */
11855         if (flags & (ESCAPE_CONTROL|ESCAPE_META)) goto eof;
11856         {
11857             tok_hex(&numlen);
11858             if (numlen == 0) goto eof;
11859             tokcopy((int)numlen + 2);
11860         }
11861         return 0;
11862 
11863       case 'M':
11864         if (flags & ESCAPE_META) goto eof;
11865         if ((c = nextc()) != '-') {
11866             pushback(c);
11867             goto eof;
11868         }
11869         tokcopy(3);
11870         flags |= ESCAPE_META;
11871         goto escaped;
11872 
11873       case 'C':
11874         if (flags & ESCAPE_CONTROL) goto eof;
11875         if ((c = nextc()) != '-') {
11876             pushback(c);
11877             goto eof;
11878         }
11879         tokcopy(3);
11880         goto escaped;
11881 
11882       case 'c':
11883         if (flags & ESCAPE_CONTROL) goto eof;
11884         tokcopy(2);
11885         flags |= ESCAPE_CONTROL;
11886       escaped:
11887         if ((c = nextc()) == '\\') {
11888             goto first;
11889         }
11890         else if (c == -1) goto eof;
11891         tokadd(c);
11892         return 0;
11893 
11894       eof:
11895       case -1:
11896         yyerror("Invalid escape character syntax");
11897         return -1;
11898 
11899       default:
11900         tokadd('\\');
11901         tokadd(c);
11902     }
11903     return 0;
11904 }
11905 
11906 extern int rb_char_to_option_kcode(int c, int *option, int *kcode);
11907 
11908 static int
11909 parser_regx_options(struct parser_params *parser)
11910 {
11911     int kcode = 0;
11912     int kopt = 0;
11913     int options = 0;
11914     int c, opt, kc;
11915 
11916     newtok();
11917     while (c = nextc(), ISALPHA(c)) {
11918         if (c == 'o') {
11919             options |= RE_OPTION_ONCE;
11920         }
11921         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
11922             if (kc >= 0) {
11923                 if (kc != rb_ascii8bit_encindex()) kcode = c;
11924                 kopt = opt;
11925             }
11926             else {
11927                 options |= opt;
11928             }
11929         }
11930         else {
11931             tokadd(c);
11932         }
11933     }
11934     options |= kopt;
11935     pushback(c);
11936     if (toklen()) {
11937         tokfix();
11938         compile_error(PARSER_ARG "unknown regexp option%s - %s",
11939                       toklen() > 1 ? "s" : "", tok());
11940     }
11941     return options | RE_OPTION_ENCODING(kcode);
11942 }
11943 
11944 static void
11945 dispose_string(VALUE str)
11946 {
11947     /* TODO: should use another API? */
11948     if (RBASIC(str)->flags & RSTRING_NOEMBED)
11949         xfree(RSTRING_PTR(str));
11950     rb_gc_force_recycle(str);
11951 }
11952 
11953 static int
11954 parser_tokadd_mbchar(struct parser_params *parser, int c)
11955 {
11956     int len = parser_precise_mbclen();
11957     if (!MBCLEN_CHARFOUND_P(len)) {
11958         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
11959         return -1;
11960     }
11961     tokadd(c);
11962     lex_p += --len;
11963     if (len > 0) tokcopy(len);
11964     return c;
11965 }
11966 
11967 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, c)
11968 
11969 static int
11970 parser_tokadd_string(struct parser_params *parser,
11971                      int func, int term, int paren, long *nest,
11972                      rb_encoding **encp)
11973 {
11974     int c;
11975     int has_nonascii = 0;
11976     rb_encoding *enc = *encp;
11977     char *errbuf = 0;
11978     static const char mixed_msg[] = "%s mixed within %s source";
11979 
11980 #define mixed_error(enc1, enc2) if (!errbuf) {  \
11981         size_t len = sizeof(mixed_msg) - 4;     \
11982         len += strlen(rb_enc_name(enc1));       \
11983         len += strlen(rb_enc_name(enc2));       \
11984         errbuf = ALLOCA_N(char, len);           \
11985         snprintf(errbuf, len, mixed_msg,        \
11986                  rb_enc_name(enc1),             \
11987                  rb_enc_name(enc2));            \
11988         yyerror(errbuf);                        \
11989     }
11990 #define mixed_escape(beg, enc1, enc2) do {      \
11991         const char *pos = lex_p;                \
11992         lex_p = beg;                            \
11993         mixed_error(enc1, enc2);                \
11994         lex_p = pos;                            \
11995     } while (0)
11996 
11997     while ((c = nextc()) != -1) {
11998         if (paren && c == paren) {
11999             ++*nest;
12000         }
12001         else if (c == term) {
12002             if (!nest || !*nest) {
12003                 pushback(c);
12004                 break;
12005             }
12006             --*nest;
12007         }
12008         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12009             int c2 = *lex_p;
12010             if (c2 == '$' || c2 == '@' || c2 == '{') {
12011                 pushback(c);
12012                 break;
12013             }
12014         }
12015         else if (c == '\\') {
12016             const char *beg = lex_p - 1;
12017             c = nextc();
12018             switch (c) {
12019               case '\n':
12020                 if (func & STR_FUNC_QWORDS) break;
12021                 if (func & STR_FUNC_EXPAND) continue;
12022                 tokadd('\\');
12023                 break;
12024 
12025               case '\\':
12026                 if (func & STR_FUNC_ESCAPE) tokadd(c);
12027                 break;
12028 
12029               case 'u':
12030                 if ((func & STR_FUNC_EXPAND) == 0) {
12031                     tokadd('\\');
12032                     break;
12033                 }
12034                 parser_tokadd_utf8(parser, &enc, 1,
12035                                    func & STR_FUNC_SYMBOL,
12036                                    func & STR_FUNC_REGEXP);
12037                 if (has_nonascii && enc != *encp) {
12038                     mixed_escape(beg, enc, *encp);
12039                 }
12040                 continue;
12041 
12042               default:
12043                 if (func & STR_FUNC_REGEXP) {
12044                     pushback(c);
12045                     if ((c = tokadd_escape(&enc)) < 0)
12046                         return -1;
12047                     if (has_nonascii && enc != *encp) {
12048                         mixed_escape(beg, enc, *encp);
12049                     }
12050                     continue;
12051                 }
12052                 else if (func & STR_FUNC_EXPAND) {
12053                     pushback(c);
12054                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
12055                     c = read_escape(0, &enc);
12056                 }
12057                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12058                     /* ignore backslashed spaces in %w */
12059                 }
12060                 else if (c != term && !(paren && c == paren)) {
12061                     tokadd('\\');
12062                     pushback(c);
12063                     continue;
12064                 }
12065             }
12066         }
12067         else if (!parser_isascii()) {
12068             has_nonascii = 1;
12069             if (enc != *encp) {
12070                 mixed_error(enc, *encp);
12071                 continue;
12072             }
12073             if (tokadd_mbchar(c) == -1) return -1;
12074             continue;
12075         }
12076         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12077             pushback(c);
12078             break;
12079         }
12080         if (c & 0x80) {
12081             has_nonascii = 1;
12082             if (enc != *encp) {
12083                 mixed_error(enc, *encp);
12084                 continue;
12085             }
12086         }
12087         tokadd(c);
12088     }
12089     *encp = enc;
12090     return c;
12091 }
12092 
12093 #define NEW_STRTERM(func, term, paren) \
12094         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12095 
12096 static int
12097 parser_parse_string(struct parser_params *parser, NODE *quote)
12098 {
12099     int func = (int)quote->nd_func;
12100     int term = nd_term(quote);
12101     int paren = nd_paren(quote);
12102     int c, space = 0;
12103     rb_encoding *enc = parser->enc;
12104 
12105     if (func == -1) return tSTRING_END;
12106     c = nextc();
12107     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12108         do {c = nextc();} while (ISSPACE(c));
12109         space = 1;
12110     }
12111     if (c == term && !quote->nd_nest) {
12112         if (func & STR_FUNC_QWORDS) {
12113             quote->nd_func = -1;
12114             return ' ';
12115         }
12116         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12117         set_yylval_num(regx_options());
12118         return tREGEXP_END;
12119     }
12120     if (space) {
12121         pushback(c);
12122         return ' ';
12123     }
12124     newtok();
12125     if ((func & STR_FUNC_EXPAND) && c == '#') {
12126         switch (c = nextc()) {
12127           case '$':
12128           case '@':
12129             pushback(c);
12130             return tSTRING_DVAR;
12131           case '{':
12132             return tSTRING_DBEG;
12133         }
12134         tokadd('#');
12135     }
12136     pushback(c);
12137     if (tokadd_string(func, term, paren, &quote->nd_nest,
12138                       &enc) == -1) {
12139         ruby_sourceline = nd_line(quote);
12140         if (func & STR_FUNC_REGEXP) {
12141             if (parser->eofp)
12142                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
12143             return tREGEXP_END;
12144         }
12145         else {
12146             if (parser->eofp)
12147                 compile_error(PARSER_ARG "unterminated string meets end of file");
12148             return tSTRING_END;
12149         }
12150     }
12151 
12152     tokfix();
12153     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12154 
12155 #ifdef RIPPER
12156     if (!NIL_P(parser->delayed)){
12157         ptrdiff_t len = lex_p - parser->tokp;
12158         if (len > 0) {
12159             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12160         }
12161         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12162         parser->tokp = lex_p;
12163     }
12164 #endif
12165 
12166     return tSTRING_CONTENT;
12167 }
12168 
12169 static int
12170 parser_heredoc_identifier(struct parser_params *parser)
12171 {
12172     int c = nextc(), term, func = 0;
12173     long len;
12174 
12175     if (c == '-') {
12176         c = nextc();
12177         func = STR_FUNC_INDENT;
12178     }
12179     switch (c) {
12180       case '\'':
12181         func |= str_squote; goto quoted;
12182       case '"':
12183         func |= str_dquote; goto quoted;
12184       case '`':
12185         func |= str_xquote;
12186       quoted:
12187         newtok();
12188         tokadd(func);
12189         term = c;
12190         while ((c = nextc()) != -1 && c != term) {
12191             if (tokadd_mbchar(c) == -1) return 0;
12192         }
12193         if (c == -1) {
12194             compile_error(PARSER_ARG "unterminated here document identifier");
12195             return 0;
12196         }
12197         break;
12198 
12199       default:
12200         if (!parser_is_identchar()) {
12201             pushback(c);
12202             if (func & STR_FUNC_INDENT) {
12203                 pushback('-');
12204             }
12205             return 0;
12206         }
12207         newtok();
12208         term = '"';
12209         tokadd(func |= str_dquote);
12210         do {
12211             if (tokadd_mbchar(c) == -1) return 0;
12212         } while ((c = nextc()) != -1 && parser_is_identchar());
12213         pushback(c);
12214         break;
12215     }
12216 
12217     tokfix();
12218 #ifdef RIPPER
12219     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12220 #endif
12221     len = lex_p - lex_pbeg;
12222     lex_goto_eol(parser);
12223     lex_strterm = rb_node_newnode(NODE_HEREDOC,
12224                                   STR_NEW(tok(), toklen()),     /* nd_lit */
12225                                   len,                          /* nd_nth */
12226                                   lex_lastline);                /* nd_orig */
12227     nd_set_line(lex_strterm, ruby_sourceline);
12228     ripper_flush(parser);
12229     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12230 }
12231 
12232 static void
12233 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12234 {
12235     VALUE line;
12236 
12237     line = here->nd_orig;
12238     lex_lastline = line;
12239     lex_pbeg = RSTRING_PTR(line);
12240     lex_pend = lex_pbeg + RSTRING_LEN(line);
12241     lex_p = lex_pbeg + here->nd_nth;
12242     heredoc_end = ruby_sourceline;
12243     ruby_sourceline = nd_line(here);
12244     dispose_string(here->nd_lit);
12245     rb_gc_force_recycle((VALUE)here);
12246     ripper_flush(parser);
12247 }
12248 
12249 static int
12250 parser_whole_match_p(struct parser_params *parser,
12251     const char *eos, long len, int indent)
12252 {
12253     const char *p = lex_pbeg;
12254     long n;
12255 
12256     if (indent) {
12257         while (*p && ISSPACE(*p)) p++;
12258     }
12259     n = lex_pend - (p + len);
12260     if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12261     return strncmp(eos, p, len) == 0;
12262 }
12263 
12264 static int
12265 parser_here_document(struct parser_params *parser, NODE *here)
12266 {
12267     int c, func, indent = 0;
12268     const char *eos, *p, *pend;
12269     long len;
12270     VALUE str = 0;
12271     rb_encoding *enc = parser->enc;
12272 
12273     eos = RSTRING_PTR(here->nd_lit);
12274     len = RSTRING_LEN(here->nd_lit) - 1;
12275     indent = (func = *eos++) & STR_FUNC_INDENT;
12276 
12277     if ((c = nextc()) == -1) {
12278       error:
12279         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12280 #ifdef RIPPER
12281         if (NIL_P(parser->delayed)) {
12282             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12283         }
12284         else {
12285             if (str ||
12286                 ((len = lex_p - parser->tokp) > 0 &&
12287                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12288                 rb_str_append(parser->delayed, str);
12289             }
12290             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12291         }
12292         lex_goto_eol(parser);
12293 #endif
12294       restore:
12295         heredoc_restore(lex_strterm);
12296         lex_strterm = 0;
12297         return 0;
12298     }
12299     if (was_bol() && whole_match_p(eos, len, indent)) {
12300         heredoc_restore(lex_strterm);
12301         return tSTRING_END;
12302     }
12303 
12304     if (!(func & STR_FUNC_EXPAND)) {
12305         do {
12306             p = RSTRING_PTR(lex_lastline);
12307             pend = lex_pend;
12308             if (pend > p) {
12309                 switch (pend[-1]) {
12310                   case '\n':
12311                     if (--pend == p || pend[-1] != '\r') {
12312                         pend++;
12313                         break;
12314                     }
12315                   case '\r':
12316                     --pend;
12317                 }
12318             }
12319             if (str)
12320                 rb_str_cat(str, p, pend - p);
12321             else
12322                 str = STR_NEW(p, pend - p);
12323             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12324             lex_goto_eol(parser);
12325             if (nextc() == -1) {
12326                 if (str) dispose_string(str);
12327                 goto error;
12328             }
12329         } while (!whole_match_p(eos, len, indent));
12330     }
12331     else {
12332         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12333         newtok();
12334         if (c == '#') {
12335             switch (c = nextc()) {
12336               case '$':
12337               case '@':
12338                 pushback(c);
12339                 return tSTRING_DVAR;
12340               case '{':
12341                 return tSTRING_DBEG;
12342             }
12343             tokadd('#');
12344         }
12345         do {
12346             pushback(c);
12347             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12348                 if (parser->eofp) goto error;
12349                 goto restore;
12350             }
12351             if (c != '\n') {
12352                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12353                 return tSTRING_CONTENT;
12354             }
12355             tokadd(nextc());
12356             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12357             if ((c = nextc()) == -1) goto error;
12358         } while (!whole_match_p(eos, len, indent));
12359         str = STR_NEW3(tok(), toklen(), enc, func);
12360     }
12361 #ifdef RIPPER
12362     if (!NIL_P(parser->delayed))
12363         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12364     lex_goto_eol(parser);
12365     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12366 #endif
12367     heredoc_restore(lex_strterm);
12368     lex_strterm = NEW_STRTERM(-1, 0, 0);
12369     set_yylval_str(str);
12370     return tSTRING_CONTENT;
12371 }
12372 
12373 #include "lex.c"
12374 
12375 static void
12376 arg_ambiguous_gen(struct parser_params *parser)
12377 {
12378 #ifndef RIPPER
12379     rb_warning0("ambiguous first argument; put parentheses or even spaces");
12380 #else
12381     dispatch0(arg_ambiguous);
12382 #endif
12383 }
12384 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12385 
12386 static ID
12387 formal_argument_gen(struct parser_params *parser, ID lhs)
12388 {
12389 #ifndef RIPPER
12390     if (!is_local_id(lhs))
12391         yyerror("formal argument must be local variable");
12392 #endif
12393     shadowing_lvar(lhs);
12394     return lhs;
12395 }
12396 
12397 static int
12398 lvar_defined_gen(struct parser_params *parser, ID id)
12399 {
12400     return (dyna_in_block() && dvar_defined(id)) || local_id(id);
12401 }
12402 
12403 /* emacsen -*- hack */
12404 static long
12405 parser_encode_length(struct parser_params *parser, const char *name, long len)
12406 {
12407     long nlen;
12408 
12409     if (len > 5 && name[nlen = len - 5] == '-') {
12410         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12411             return nlen;
12412     }
12413     if (len > 4 && name[nlen = len - 4] == '-') {
12414         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12415             return nlen;
12416         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12417             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12418             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12419             return nlen;
12420     }
12421     return len;
12422 }
12423 
12424 static void
12425 parser_set_encode(struct parser_params *parser, const char *name)
12426 {
12427     int idx = rb_enc_find_index(name);
12428     rb_encoding *enc;
12429     VALUE excargs[3];
12430 
12431     if (idx < 0) {
12432         VALUE rb_make_backtrace(void);
12433         VALUE rb_make_exception(int, VALUE*);
12434 
12435         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12436       error:
12437         excargs[0] = rb_eArgError;
12438         excargs[2] = rb_make_backtrace();
12439         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12440         rb_exc_raise(rb_make_exception(3, excargs));
12441     }
12442     enc = rb_enc_from_index(idx);
12443     if (!rb_enc_asciicompat(enc)) {
12444         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
12445         goto error;
12446     }
12447     parser->enc = enc;
12448 #ifndef RIPPER
12449     if (ruby_debug_lines) {
12450         long i, n = RARRAY_LEN(ruby_debug_lines);
12451         const VALUE *p = RARRAY_PTR(ruby_debug_lines);
12452         for (i = 0; i < n; ++i) {
12453             rb_enc_associate_index(*p, idx);
12454         }
12455     }
12456 #endif
12457 }
12458 
12459 static int
12460 comment_at_top(struct parser_params *parser)
12461 {
12462     const char *p = lex_pbeg, *pend = lex_p - 1;
12463     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
12464     while (p < pend) {
12465         if (!ISSPACE(*p)) return 0;
12466         p++;
12467     }
12468     return 1;
12469 }
12470 
12471 #ifndef RIPPER
12472 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
12473 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
12474 
12475 static void
12476 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
12477 {
12478     if (!comment_at_top(parser)) {
12479         return;
12480     }
12481     parser_set_encode(parser, val);
12482 }
12483 
12484 struct magic_comment {
12485     const char *name;
12486     rb_magic_comment_setter_t func;
12487     rb_magic_comment_length_t length;
12488 };
12489 
12490 static const struct magic_comment magic_comments[] = {
12491     {"coding", magic_comment_encoding, parser_encode_length},
12492     {"encoding", magic_comment_encoding, parser_encode_length},
12493 };
12494 #endif
12495 
12496 static const char *
12497 magic_comment_marker(const char *str, long len)
12498 {
12499     long i = 2;
12500 
12501     while (i < len) {
12502         switch (str[i]) {
12503           case '-':
12504             if (str[i-1] == '*' && str[i-2] == '-') {
12505                 return str + i + 1;
12506             }
12507             i += 2;
12508             break;
12509           case '*':
12510             if (i + 1 >= len) return 0;
12511             if (str[i+1] != '-') {
12512                 i += 4;
12513             }
12514             else if (str[i-1] != '-') {
12515                 i += 2;
12516             }
12517             else {
12518                 return str + i + 2;
12519             }
12520             break;
12521           default:
12522             i += 3;
12523             break;
12524         }
12525     }
12526     return 0;
12527 }
12528 
12529 static int
12530 parser_magic_comment(struct parser_params *parser, const char *str, long len)
12531 {
12532     VALUE name = 0, val = 0;
12533     const char *beg, *end, *vbeg, *vend;
12534 #define str_copy(_s, _p, _n) ((_s) \
12535         ? (rb_str_resize((_s), (_n)), \
12536            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
12537         : ((_s) = STR_NEW((_p), (_n))))
12538 
12539     if (len <= 7) return FALSE;
12540     if (!(beg = magic_comment_marker(str, len))) return FALSE;
12541     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
12542     str = beg;
12543     len = end - beg - 3;
12544 
12545     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
12546     while (len > 0) {
12547 #ifndef RIPPER
12548         const struct magic_comment *p = magic_comments;
12549 #endif
12550         char *s;
12551         int i;
12552         long n = 0;
12553 
12554         for (; len > 0 && *str; str++, --len) {
12555             switch (*str) {
12556               case '\'': case '"': case ':': case ';':
12557                 continue;
12558             }
12559             if (!ISSPACE(*str)) break;
12560         }
12561         for (beg = str; len > 0; str++, --len) {
12562             switch (*str) {
12563               case '\'': case '"': case ':': case ';':
12564                 break;
12565               default:
12566                 if (ISSPACE(*str)) break;
12567                 continue;
12568             }
12569             break;
12570         }
12571         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
12572         if (!len) break;
12573         if (*str != ':') continue;
12574 
12575         do str++; while (--len > 0 && ISSPACE(*str));
12576         if (!len) break;
12577         if (*str == '"') {
12578             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
12579                 if (*str == '\\') {
12580                     --len;
12581                     ++str;
12582                 }
12583             }
12584             vend = str;
12585             if (len) {
12586                 --len;
12587                 ++str;
12588             }
12589         }
12590         else {
12591             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
12592             vend = str;
12593         }
12594         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
12595 
12596         n = end - beg;
12597         str_copy(name, beg, n);
12598         s = RSTRING_PTR(name);
12599         for (i = 0; i < n; ++i) {
12600             if (s[i] == '-') s[i] = '_';
12601         }
12602 #ifndef RIPPER
12603         do {
12604             if (STRNCASECMP(p->name, s, n) == 0) {
12605                 n = vend - vbeg;
12606                 if (p->length) {
12607                     n = (*p->length)(parser, vbeg, n);
12608                 }
12609                 str_copy(val, vbeg, n);
12610                 (*p->func)(parser, s, RSTRING_PTR(val));
12611                 break;
12612             }
12613         } while (++p < magic_comments + numberof(magic_comments));
12614 #else
12615         dispatch2(magic_comment, name, val);
12616 #endif
12617     }
12618 
12619     return TRUE;
12620 }
12621 
12622 static void
12623 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
12624 {
12625     int sep = 0;
12626     const char *beg = str;
12627     VALUE s;
12628 
12629     for (;;) {
12630         if (send - str <= 6) return;
12631         switch (str[6]) {
12632           case 'C': case 'c': str += 6; continue;
12633           case 'O': case 'o': str += 5; continue;
12634           case 'D': case 'd': str += 4; continue;
12635           case 'I': case 'i': str += 3; continue;
12636           case 'N': case 'n': str += 2; continue;
12637           case 'G': case 'g': str += 1; continue;
12638           case '=': case ':':
12639             sep = 1;
12640             str += 6;
12641             break;
12642           default:
12643             str += 6;
12644             if (ISSPACE(*str)) break;
12645             continue;
12646         }
12647         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
12648     }
12649     for (;;) {
12650         do {
12651             if (++str >= send) return;
12652         } while (ISSPACE(*str));
12653         if (sep) break;
12654         if (*str != '=' && *str != ':') return;
12655         sep = 1;
12656         str++;
12657     }
12658     beg = str;
12659     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
12660     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
12661     parser_set_encode(parser, RSTRING_PTR(s));
12662     rb_str_resize(s, 0);
12663 }
12664 
12665 static void
12666 parser_prepare(struct parser_params *parser)
12667 {
12668     int c = nextc();
12669     switch (c) {
12670       case '#':
12671         if (peek('!')) parser->has_shebang = 1;
12672         break;
12673       case 0xef:                /* UTF-8 BOM marker */
12674         if (lex_pend - lex_p >= 2 &&
12675             (unsigned char)lex_p[0] == 0xbb &&
12676             (unsigned char)lex_p[1] == 0xbf) {
12677             parser->enc = rb_utf8_encoding();
12678             lex_p += 2;
12679             lex_pbeg = lex_p;
12680             return;
12681         }
12682         break;
12683       case EOF:
12684         return;
12685     }
12686     pushback(c);
12687     parser->enc = rb_enc_get(lex_lastline);
12688 }
12689 
12690 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
12691 #define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
12692 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
12693 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12694 
12695 #ifndef RIPPER
12696 #define ambiguous_operator(op, syn) ( \
12697     rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
12698     rb_warning0("even though it seems like "syn""))
12699 #else
12700 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
12701 #endif
12702 #define warn_balanced(op, syn) \
12703     (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
12704      last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
12705      last_state != EXPR_ENDARG && \
12706      space_seen && !ISSPACE(c) && \
12707      (ambiguous_operator(op, syn), 0))
12708 
12709 static int
12710 parser_yylex(struct parser_params *parser)
12711 {
12712     register int c;
12713     int space_seen = 0;
12714     int cmd_state;
12715     enum lex_state_e last_state;
12716     rb_encoding *enc;
12717     int mb;
12718 #ifdef RIPPER
12719     int fallthru = FALSE;
12720 #endif
12721 
12722     if (lex_strterm) {
12723         int token;
12724         if (nd_type(lex_strterm) == NODE_HEREDOC) {
12725             token = here_document(lex_strterm);
12726             if (token == tSTRING_END) {
12727                 lex_strterm = 0;
12728                 lex_state = EXPR_END;
12729             }
12730         }
12731         else {
12732             token = parse_string(lex_strterm);
12733             if (token == tSTRING_END || token == tREGEXP_END) {
12734                 rb_gc_force_recycle((VALUE)lex_strterm);
12735                 lex_strterm = 0;
12736                 lex_state = EXPR_END;
12737             }
12738         }
12739         return token;
12740     }
12741     cmd_state = command_start;
12742     command_start = FALSE;
12743   retry:
12744     last_state = lex_state;
12745     switch (c = nextc()) {
12746       case '\0':                /* NUL */
12747       case '\004':              /* ^D */
12748       case '\032':              /* ^Z */
12749       case -1:                  /* end of script. */
12750         return 0;
12751 
12752         /* white spaces */
12753       case ' ': case '\t': case '\f': case '\r':
12754       case '\13': /* '\v' */
12755         space_seen = 1;
12756 #ifdef RIPPER
12757         while ((c = nextc())) {
12758             switch (c) {
12759               case ' ': case '\t': case '\f': case '\r':
12760               case '\13': /* '\v' */
12761                 break;
12762               default:
12763                 goto outofloop;
12764             }
12765         }
12766       outofloop:
12767         pushback(c);
12768         ripper_dispatch_scan_event(parser, tSP);
12769 #endif
12770         goto retry;
12771 
12772       case '#':         /* it's a comment */
12773         /* no magic_comment in shebang line */
12774         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
12775             if (comment_at_top(parser)) {
12776                 set_file_encoding(parser, lex_p, lex_pend);
12777             }
12778         }
12779         lex_p = lex_pend;
12780 #ifdef RIPPER
12781         ripper_dispatch_scan_event(parser, tCOMMENT);
12782         fallthru = TRUE;
12783 #endif
12784         /* fall through */
12785       case '\n':
12786         switch (lex_state) {
12787           case EXPR_BEG:
12788           case EXPR_FNAME:
12789           case EXPR_DOT:
12790           case EXPR_CLASS:
12791           case EXPR_VALUE:
12792 #ifdef RIPPER
12793             if (!fallthru) {
12794                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
12795             }
12796             fallthru = FALSE;
12797 #endif
12798             goto retry;
12799           default:
12800             break;
12801         }
12802         while ((c = nextc())) {
12803             switch (c) {
12804               case ' ': case '\t': case '\f': case '\r':
12805               case '\13': /* '\v' */
12806                 space_seen = 1;
12807                 break;
12808               case '.': {
12809                   if ((c = nextc()) != '.') {
12810                       pushback(c);
12811                       pushback('.');
12812                       goto retry;
12813                   }
12814               }
12815               default:
12816                 --ruby_sourceline;
12817                 lex_nextline = lex_lastline;
12818               case -1:          /* EOF no decrement*/
12819                 lex_goto_eol(parser);
12820 #ifdef RIPPER
12821                 if (c != -1) {
12822                     parser->tokp = lex_p;
12823                 }
12824 #endif
12825                 goto normal_newline;
12826             }
12827         }
12828       normal_newline:
12829         command_start = TRUE;
12830         lex_state = EXPR_BEG;
12831         return '\n';
12832 
12833       case '*':
12834         if ((c = nextc()) == '*') {
12835             if ((c = nextc()) == '=') {
12836                 set_yylval_id(tPOW);
12837                 lex_state = EXPR_BEG;
12838                 return tOP_ASGN;
12839             }
12840             pushback(c);
12841             c = tPOW;
12842         }
12843         else {
12844             if (c == '=') {
12845                 set_yylval_id('*');
12846                 lex_state = EXPR_BEG;
12847                 return tOP_ASGN;
12848             }
12849             pushback(c);
12850             if (IS_SPCARG(c)) {
12851                 rb_warning0("`*' interpreted as argument prefix");
12852                 c = tSTAR;
12853             }
12854             else if (IS_BEG()) {
12855                 c = tSTAR;
12856             }
12857             else {
12858                 warn_balanced("*", "argument prefix");
12859                 c = '*';
12860             }
12861         }
12862         switch (lex_state) {
12863           case EXPR_FNAME: case EXPR_DOT:
12864             lex_state = EXPR_ARG; break;
12865           default:
12866             lex_state = EXPR_BEG; break;
12867         }
12868         return c;
12869 
12870       case '!':
12871         c = nextc();
12872         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
12873             lex_state = EXPR_ARG;
12874             if (c == '@') {
12875                 return '!';
12876             }
12877         }
12878         else {
12879             lex_state = EXPR_BEG;
12880         }
12881         if (c == '=') {
12882             return tNEQ;
12883         }
12884         if (c == '~') {
12885             return tNMATCH;
12886         }
12887         pushback(c);
12888         return '!';
12889 
12890       case '=':
12891         if (was_bol()) {
12892             /* skip embedded rd document */
12893             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
12894 #ifdef RIPPER
12895                 int first_p = TRUE;
12896 
12897                 lex_goto_eol(parser);
12898                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
12899 #endif
12900                 for (;;) {
12901                     lex_goto_eol(parser);
12902 #ifdef RIPPER
12903                     if (!first_p) {
12904                         ripper_dispatch_scan_event(parser, tEMBDOC);
12905                     }
12906                     first_p = FALSE;
12907 #endif
12908                     c = nextc();
12909                     if (c == -1) {
12910                         compile_error(PARSER_ARG "embedded document meets end of file");
12911                         return 0;
12912                     }
12913                     if (c != '=') continue;
12914                     if (strncmp(lex_p, "end", 3) == 0 &&
12915                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
12916                         break;
12917                     }
12918                 }
12919                 lex_goto_eol(parser);
12920 #ifdef RIPPER
12921                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
12922 #endif
12923                 goto retry;
12924             }
12925         }
12926 
12927         switch (lex_state) {
12928           case EXPR_FNAME: case EXPR_DOT:
12929             lex_state = EXPR_ARG; break;
12930           default:
12931             lex_state = EXPR_BEG; break;
12932         }
12933         if ((c = nextc()) == '=') {
12934             if ((c = nextc()) == '=') {
12935                 return tEQQ;
12936             }
12937             pushback(c);
12938             return tEQ;
12939         }
12940         if (c == '~') {
12941             return tMATCH;
12942         }
12943         else if (c == '>') {
12944             return tASSOC;
12945         }
12946         pushback(c);
12947         return '=';
12948 
12949       case '<':
12950         last_state = lex_state;
12951         c = nextc();
12952         if (c == '<' &&
12953             lex_state != EXPR_DOT &&
12954             lex_state != EXPR_CLASS &&
12955             !IS_END() &&
12956             (!IS_ARG() || space_seen)) {
12957             int token = heredoc_identifier();
12958             if (token) return token;
12959         }
12960         switch (lex_state) {
12961           case EXPR_FNAME: case EXPR_DOT:
12962             lex_state = EXPR_ARG; break;
12963           default:
12964             lex_state = EXPR_BEG; break;
12965         }
12966         if (c == '=') {
12967             if ((c = nextc()) == '>') {
12968                 return tCMP;
12969             }
12970             pushback(c);
12971             return tLEQ;
12972         }
12973         if (c == '<') {
12974             if ((c = nextc()) == '=') {
12975                 set_yylval_id(tLSHFT);
12976                 lex_state = EXPR_BEG;
12977                 return tOP_ASGN;
12978             }
12979             pushback(c);
12980             warn_balanced("<<", "here document");
12981             return tLSHFT;
12982         }
12983         pushback(c);
12984         return '<';
12985 
12986       case '>':
12987         switch (lex_state) {
12988           case EXPR_FNAME: case EXPR_DOT:
12989             lex_state = EXPR_ARG; break;
12990           default:
12991             lex_state = EXPR_BEG; break;
12992         }
12993         if ((c = nextc()) == '=') {
12994             return tGEQ;
12995         }
12996         if (c == '>') {
12997             if ((c = nextc()) == '=') {
12998                 set_yylval_id(tRSHFT);
12999                 lex_state = EXPR_BEG;
13000                 return tOP_ASGN;
13001             }
13002             pushback(c);
13003             return tRSHFT;
13004         }
13005         pushback(c);
13006         return '>';
13007 
13008       case '"':
13009         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13010         return tSTRING_BEG;
13011 
13012       case '`':
13013         if (lex_state == EXPR_FNAME) {
13014             lex_state = EXPR_ENDFN;
13015             return c;
13016         }
13017         if (lex_state == EXPR_DOT) {
13018             if (cmd_state)
13019                 lex_state = EXPR_CMDARG;
13020             else
13021                 lex_state = EXPR_ARG;
13022             return c;
13023         }
13024         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13025         return tXSTRING_BEG;
13026 
13027       case '\'':
13028         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13029         return tSTRING_BEG;
13030 
13031       case '?':
13032         if (IS_END()) {
13033             lex_state = EXPR_VALUE;
13034             return '?';
13035         }
13036         c = nextc();
13037         if (c == -1) {
13038             compile_error(PARSER_ARG "incomplete character syntax");
13039             return 0;
13040         }
13041         if (rb_enc_isspace(c, parser->enc)) {
13042             if (!IS_ARG()) {
13043                 int c2 = 0;
13044                 switch (c) {
13045                   case ' ':
13046                     c2 = 's';
13047                     break;
13048                   case '\n':
13049                     c2 = 'n';
13050                     break;
13051                   case '\t':
13052                     c2 = 't';
13053                     break;
13054                   case '\v':
13055                     c2 = 'v';
13056                     break;
13057                   case '\r':
13058                     c2 = 'r';
13059                     break;
13060                   case '\f':
13061                     c2 = 'f';
13062                     break;
13063                 }
13064                 if (c2) {
13065                     rb_warnI("invalid character syntax; use ?\\%c", c2);
13066                 }
13067             }
13068           ternary:
13069             pushback(c);
13070             lex_state = EXPR_VALUE;
13071             return '?';
13072         }
13073         newtok();
13074         enc = parser->enc;
13075         if (!parser_isascii()) {
13076             if (tokadd_mbchar(c) == -1) return 0;
13077         }
13078         else if ((rb_enc_isalnum(c, parser->enc) || c == '_') &&
13079                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, parser->enc)) {
13080             goto ternary;
13081         }
13082         else if (c == '\\') {
13083             if (peek('u')) {
13084                 nextc();
13085                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13086                 if (0x80 <= c) {
13087                     tokaddmbc(c, enc);
13088                 }
13089                 else {
13090                     tokadd(c);
13091                 }
13092             }
13093             else {
13094                 c = read_escape(0, &enc);
13095                 tokadd(c);
13096             }
13097         }
13098         else {
13099             tokadd(c);
13100         }
13101         tokfix();
13102         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13103         lex_state = EXPR_END;
13104         return tCHAR;
13105 
13106       case '&':
13107         if ((c = nextc()) == '&') {
13108             lex_state = EXPR_BEG;
13109             if ((c = nextc()) == '=') {
13110                 set_yylval_id(tANDOP);
13111                 lex_state = EXPR_BEG;
13112                 return tOP_ASGN;
13113             }
13114             pushback(c);
13115             return tANDOP;
13116         }
13117         else if (c == '=') {
13118             set_yylval_id('&');
13119             lex_state = EXPR_BEG;
13120             return tOP_ASGN;
13121         }
13122         pushback(c);
13123         if (IS_SPCARG(c)) {
13124             rb_warning0("`&' interpreted as argument prefix");
13125             c = tAMPER;
13126         }
13127         else if (IS_BEG()) {
13128             c = tAMPER;
13129         }
13130         else {
13131             warn_balanced("&", "argument prefix");
13132             c = '&';
13133         }
13134         switch (lex_state) {
13135           case EXPR_FNAME: case EXPR_DOT:
13136             lex_state = EXPR_ARG; break;
13137           default:
13138             lex_state = EXPR_BEG;
13139         }
13140         return c;
13141 
13142       case '|':
13143         if ((c = nextc()) == '|') {
13144             lex_state = EXPR_BEG;
13145             if ((c = nextc()) == '=') {
13146                 set_yylval_id(tOROP);
13147                 lex_state = EXPR_BEG;
13148                 return tOP_ASGN;
13149             }
13150             pushback(c);
13151             return tOROP;
13152         }
13153         if (c == '=') {
13154             set_yylval_id('|');
13155             lex_state = EXPR_BEG;
13156             return tOP_ASGN;
13157         }
13158         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13159             lex_state = EXPR_ARG;
13160         }
13161         else {
13162             lex_state = EXPR_BEG;
13163         }
13164         pushback(c);
13165         return '|';
13166 
13167       case '+':
13168         c = nextc();
13169         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13170             lex_state = EXPR_ARG;
13171             if (c == '@') {
13172                 return tUPLUS;
13173             }
13174             pushback(c);
13175             return '+';
13176         }
13177         if (c == '=') {
13178             set_yylval_id('+');
13179             lex_state = EXPR_BEG;
13180             return tOP_ASGN;
13181         }
13182         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13183             lex_state = EXPR_BEG;
13184             pushback(c);
13185             if (c != -1 && ISDIGIT(c)) {
13186                 c = '+';
13187                 goto start_num;
13188             }
13189             return tUPLUS;
13190         }
13191         lex_state = EXPR_BEG;
13192         pushback(c);
13193         warn_balanced("+", "unary operator");
13194         return '+';
13195 
13196       case '-':
13197         c = nextc();
13198         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13199             lex_state = EXPR_ARG;
13200             if (c == '@') {
13201                 return tUMINUS;
13202             }
13203             pushback(c);
13204             return '-';
13205         }
13206         if (c == '=') {
13207             set_yylval_id('-');
13208             lex_state = EXPR_BEG;
13209             return tOP_ASGN;
13210         }
13211         if (c == '>') {
13212             lex_state = EXPR_ARG;
13213             return tLAMBDA;
13214         }
13215         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13216             lex_state = EXPR_BEG;
13217             pushback(c);
13218             if (c != -1 && ISDIGIT(c)) {
13219                 return tUMINUS_NUM;
13220             }
13221             return tUMINUS;
13222         }
13223         lex_state = EXPR_BEG;
13224         pushback(c);
13225         warn_balanced("-", "unary operator");
13226         return '-';
13227 
13228       case '.':
13229         lex_state = EXPR_BEG;
13230         if ((c = nextc()) == '.') {
13231             if ((c = nextc()) == '.') {
13232                 return tDOT3;
13233             }
13234             pushback(c);
13235             return tDOT2;
13236         }
13237         pushback(c);
13238         if (c != -1 && ISDIGIT(c)) {
13239             yyerror("no .<digit> floating literal anymore; put 0 before dot");
13240         }
13241         lex_state = EXPR_DOT;
13242         return '.';
13243 
13244       start_num:
13245       case '0': case '1': case '2': case '3': case '4':
13246       case '5': case '6': case '7': case '8': case '9':
13247         {
13248             int is_float, seen_point, seen_e, nondigit;
13249 
13250             is_float = seen_point = seen_e = nondigit = 0;
13251             lex_state = EXPR_END;
13252             newtok();
13253             if (c == '-' || c == '+') {
13254                 tokadd(c);
13255                 c = nextc();
13256             }
13257             if (c == '0') {
13258 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13259                 int start = toklen();
13260                 c = nextc();
13261                 if (c == 'x' || c == 'X') {
13262                     /* hexadecimal */
13263                     c = nextc();
13264                     if (c != -1 && ISXDIGIT(c)) {
13265                         do {
13266                             if (c == '_') {
13267                                 if (nondigit) break;
13268                                 nondigit = c;
13269                                 continue;
13270                             }
13271                             if (!ISXDIGIT(c)) break;
13272                             nondigit = 0;
13273                             tokadd(c);
13274                         } while ((c = nextc()) != -1);
13275                     }
13276                     pushback(c);
13277                     tokfix();
13278                     if (toklen() == start) {
13279                         no_digits();
13280                     }
13281                     else if (nondigit) goto trailing_uc;
13282                     set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
13283                     return tINTEGER;
13284                 }
13285                 if (c == 'b' || c == 'B') {
13286                     /* binary */
13287                     c = nextc();
13288                     if (c == '0' || c == '1') {
13289                         do {
13290                             if (c == '_') {
13291                                 if (nondigit) break;
13292                                 nondigit = c;
13293                                 continue;
13294                             }
13295                             if (c != '0' && c != '1') break;
13296                             nondigit = 0;
13297                             tokadd(c);
13298                         } while ((c = nextc()) != -1);
13299                     }
13300                     pushback(c);
13301                     tokfix();
13302                     if (toklen() == start) {
13303                         no_digits();
13304                     }
13305                     else if (nondigit) goto trailing_uc;
13306                     set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
13307                     return tINTEGER;
13308                 }
13309                 if (c == 'd' || c == 'D') {
13310                     /* decimal */
13311                     c = nextc();
13312                     if (c != -1 && ISDIGIT(c)) {
13313                         do {
13314                             if (c == '_') {
13315                                 if (nondigit) break;
13316                                 nondigit = c;
13317                                 continue;
13318                             }
13319                             if (!ISDIGIT(c)) break;
13320                             nondigit = 0;
13321                             tokadd(c);
13322                         } while ((c = nextc()) != -1);
13323                     }
13324                     pushback(c);
13325                     tokfix();
13326                     if (toklen() == start) {
13327                         no_digits();
13328                     }
13329                     else if (nondigit) goto trailing_uc;
13330                     set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13331                     return tINTEGER;
13332                 }
13333                 if (c == '_') {
13334                     /* 0_0 */
13335                     goto octal_number;
13336                 }
13337                 if (c == 'o' || c == 'O') {
13338                     /* prefixed octal */
13339                     c = nextc();
13340                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
13341                         no_digits();
13342                     }
13343                 }
13344                 if (c >= '0' && c <= '7') {
13345                     /* octal */
13346                   octal_number:
13347                     do {
13348                         if (c == '_') {
13349                             if (nondigit) break;
13350                             nondigit = c;
13351                             continue;
13352                         }
13353                         if (c < '0' || c > '9') break;
13354                         if (c > '7') goto invalid_octal;
13355                         nondigit = 0;
13356                         tokadd(c);
13357                     } while ((c = nextc()) != -1);
13358                     if (toklen() > start) {
13359                         pushback(c);
13360                         tokfix();
13361                         if (nondigit) goto trailing_uc;
13362                         set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
13363                         return tINTEGER;
13364                     }
13365                     if (nondigit) {
13366                         pushback(c);
13367                         goto trailing_uc;
13368                     }
13369                 }
13370                 if (c > '7' && c <= '9') {
13371                   invalid_octal:
13372                     yyerror("Invalid octal digit");
13373                 }
13374                 else if (c == '.' || c == 'e' || c == 'E') {
13375                     tokadd('0');
13376                 }
13377                 else {
13378                     pushback(c);
13379                     set_yylval_literal(INT2FIX(0));
13380                     return tINTEGER;
13381                 }
13382             }
13383 
13384             for (;;) {
13385                 switch (c) {
13386                   case '0': case '1': case '2': case '3': case '4':
13387                   case '5': case '6': case '7': case '8': case '9':
13388                     nondigit = 0;
13389                     tokadd(c);
13390                     break;
13391 
13392                   case '.':
13393                     if (nondigit) goto trailing_uc;
13394                     if (seen_point || seen_e) {
13395                         goto decode_num;
13396                     }
13397                     else {
13398                         int c0 = nextc();
13399                         if (c0 == -1 || !ISDIGIT(c0)) {
13400                             pushback(c0);
13401                             goto decode_num;
13402                         }
13403                         c = c0;
13404                     }
13405                     tokadd('.');
13406                     tokadd(c);
13407                     is_float++;
13408                     seen_point++;
13409                     nondigit = 0;
13410                     break;
13411 
13412                   case 'e':
13413                   case 'E':
13414                     if (nondigit) {
13415                         pushback(c);
13416                         c = nondigit;
13417                         goto decode_num;
13418                     }
13419                     if (seen_e) {
13420                         goto decode_num;
13421                     }
13422                     tokadd(c);
13423                     seen_e++;
13424                     is_float++;
13425                     nondigit = c;
13426                     c = nextc();
13427                     if (c != '-' && c != '+') continue;
13428                     tokadd(c);
13429                     nondigit = c;
13430                     break;
13431 
13432                   case '_':     /* `_' in number just ignored */
13433                     if (nondigit) goto decode_num;
13434                     nondigit = c;
13435                     break;
13436 
13437                   default:
13438                     goto decode_num;
13439                 }
13440                 c = nextc();
13441             }
13442 
13443           decode_num:
13444             pushback(c);
13445             if (nondigit) {
13446                 char tmp[30];
13447               trailing_uc:
13448                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13449                 yyerror(tmp);
13450             }
13451             tokfix();
13452             if (is_float) {
13453                 double d = strtod(tok(), 0);
13454                 if (errno == ERANGE) {
13455                     rb_warningS("Float %s out of range", tok());
13456                     errno = 0;
13457                 }
13458                 set_yylval_literal(DBL2NUM(d));
13459                 return tFLOAT;
13460             }
13461             set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13462             return tINTEGER;
13463         }
13464 
13465       case ')':
13466       case ']':
13467         paren_nest--;
13468       case '}':
13469         COND_LEXPOP();
13470         CMDARG_LEXPOP();
13471         if (c == ')')
13472             lex_state = EXPR_ENDFN;
13473         else
13474             lex_state = EXPR_ENDARG;
13475         return c;
13476 
13477       case ':':
13478         c = nextc();
13479         if (c == ':') {
13480             if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
13481                 lex_state = EXPR_BEG;
13482                 return tCOLON3;
13483             }
13484             lex_state = EXPR_DOT;
13485             return tCOLON2;
13486         }
13487         if (IS_END() || ISSPACE(c)) {
13488             pushback(c);
13489             warn_balanced(":", "symbol literal");
13490             lex_state = EXPR_BEG;
13491             return ':';
13492         }
13493         switch (c) {
13494           case '\'':
13495             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
13496             break;
13497           case '"':
13498             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
13499             break;
13500           default:
13501             pushback(c);
13502             break;
13503         }
13504         lex_state = EXPR_FNAME;
13505         return tSYMBEG;
13506 
13507       case '/':
13508         if (IS_BEG()) {
13509             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13510             return tREGEXP_BEG;
13511         }
13512         if ((c = nextc()) == '=') {
13513             set_yylval_id('/');
13514             lex_state = EXPR_BEG;
13515             return tOP_ASGN;
13516         }
13517         pushback(c);
13518         if (IS_SPCARG(c)) {
13519             arg_ambiguous();
13520             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13521             return tREGEXP_BEG;
13522         }
13523         switch (lex_state) {
13524           case EXPR_FNAME: case EXPR_DOT:
13525             lex_state = EXPR_ARG; break;
13526           default:
13527             lex_state = EXPR_BEG; break;
13528         }
13529         warn_balanced("/", "regexp literal");
13530         return '/';
13531 
13532       case '^':
13533         if ((c = nextc()) == '=') {
13534             set_yylval_id('^');
13535             lex_state = EXPR_BEG;
13536             return tOP_ASGN;
13537         }
13538         switch (lex_state) {
13539           case EXPR_FNAME: case EXPR_DOT:
13540             lex_state = EXPR_ARG; break;
13541           default:
13542             lex_state = EXPR_BEG; break;
13543         }
13544         pushback(c);
13545         return '^';
13546 
13547       case ';':
13548         lex_state = EXPR_BEG;
13549         command_start = TRUE;
13550         return ';';
13551 
13552       case ',':
13553         lex_state = EXPR_BEG;
13554         return ',';
13555 
13556       case '~':
13557         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13558             if ((c = nextc()) != '@') {
13559                 pushback(c);
13560             }
13561             lex_state = EXPR_ARG;
13562         }
13563         else {
13564             lex_state = EXPR_BEG;
13565         }
13566         return '~';
13567 
13568       case '(':
13569         if (IS_BEG()) {
13570             c = tLPAREN;
13571         }
13572         else if (IS_SPCARG(-1)) {
13573             c = tLPAREN_ARG;
13574         }
13575         paren_nest++;
13576         COND_PUSH(0);
13577         CMDARG_PUSH(0);
13578         lex_state = EXPR_BEG;
13579         return c;
13580 
13581       case '[':
13582         paren_nest++;
13583         if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13584             lex_state = EXPR_ARG;
13585             if ((c = nextc()) == ']') {
13586                 if ((c = nextc()) == '=') {
13587                     return tASET;
13588                 }
13589                 pushback(c);
13590                 return tAREF;
13591             }
13592             pushback(c);
13593             return '[';
13594         }
13595         else if (IS_BEG()) {
13596             c = tLBRACK;
13597         }
13598         else if (IS_ARG() && space_seen) {
13599             c = tLBRACK;
13600         }
13601         lex_state = EXPR_BEG;
13602         COND_PUSH(0);
13603         CMDARG_PUSH(0);
13604         return c;
13605 
13606       case '{':
13607         if (lpar_beg && lpar_beg == paren_nest) {
13608             lex_state = EXPR_BEG;
13609             lpar_beg = 0;
13610             --paren_nest;
13611             COND_PUSH(0);
13612             CMDARG_PUSH(0);
13613             return tLAMBEG;
13614         }
13615         if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
13616             c = '{';          /* block (primary) */
13617         else if (lex_state == EXPR_ENDARG)
13618             c = tLBRACE_ARG;  /* block (expr) */
13619         else
13620             c = tLBRACE;      /* hash */
13621         COND_PUSH(0);
13622         CMDARG_PUSH(0);
13623         lex_state = EXPR_BEG;
13624         if (c != tLBRACE) command_start = TRUE;
13625         return c;
13626 
13627       case '\\':
13628         c = nextc();
13629         if (c == '\n') {
13630             space_seen = 1;
13631 #ifdef RIPPER
13632             ripper_dispatch_scan_event(parser, tSP);
13633 #endif
13634             goto retry; /* skip \\n */
13635         }
13636         pushback(c);
13637         return '\\';
13638 
13639       case '%':
13640         if (IS_BEG()) {
13641             int term;
13642             int paren;
13643 
13644             c = nextc();
13645           quotation:
13646             if (c == -1 || !ISALNUM(c)) {
13647                 term = c;
13648                 c = 'Q';
13649             }
13650             else {
13651                 term = nextc();
13652                 if (rb_enc_isalnum(term, parser->enc) || !parser_isascii()) {
13653                     yyerror("unknown type of %string");
13654                     return 0;
13655                 }
13656             }
13657             if (c == -1 || term == -1) {
13658                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13659                 return 0;
13660             }
13661             paren = term;
13662             if (term == '(') term = ')';
13663             else if (term == '[') term = ']';
13664             else if (term == '{') term = '}';
13665             else if (term == '<') term = '>';
13666             else paren = 0;
13667 
13668             switch (c) {
13669               case 'Q':
13670                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13671                 return tSTRING_BEG;
13672 
13673               case 'q':
13674                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
13675                 return tSTRING_BEG;
13676 
13677               case 'W':
13678                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
13679                 do {c = nextc();} while (ISSPACE(c));
13680                 pushback(c);
13681                 return tWORDS_BEG;
13682 
13683               case 'w':
13684                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
13685                 do {c = nextc();} while (ISSPACE(c));
13686                 pushback(c);
13687                 return tQWORDS_BEG;
13688 
13689               case 'x':
13690                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13691                 return tXSTRING_BEG;
13692 
13693               case 'r':
13694                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13695                 return tREGEXP_BEG;
13696 
13697               case 's':
13698                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13699                 lex_state = EXPR_FNAME;
13700                 return tSYMBEG;
13701 
13702               default:
13703                 yyerror("unknown type of %string");
13704                 return 0;
13705             }
13706         }
13707         if ((c = nextc()) == '=') {
13708             set_yylval_id('%');
13709             lex_state = EXPR_BEG;
13710             return tOP_ASGN;
13711         }
13712         if (IS_SPCARG(c)) {
13713             goto quotation;
13714         }
13715         switch (lex_state) {
13716           case EXPR_FNAME: case EXPR_DOT:
13717             lex_state = EXPR_ARG; break;
13718           default:
13719             lex_state = EXPR_BEG; break;
13720         }
13721         pushback(c);
13722         warn_balanced("%%", "string literal");
13723         return '%';
13724 
13725       case '$':
13726         lex_state = EXPR_END;
13727         newtok();
13728         c = nextc();
13729         switch (c) {
13730           case '_':             /* $_: last read line string */
13731             c = nextc();
13732             if (parser_is_identchar()) {
13733                 tokadd('$');
13734                 tokadd('_');
13735                 break;
13736             }
13737             pushback(c);
13738             c = '_';
13739             /* fall through */
13740           case '~':             /* $~: match-data */
13741           case '*':             /* $*: argv */
13742           case '$':             /* $$: pid */
13743           case '?':             /* $?: last status */
13744           case '!':             /* $!: error string */
13745           case '@':             /* $@: error position */
13746           case '/':             /* $/: input record separator */
13747           case '\\':            /* $\: output record separator */
13748           case ';':             /* $;: field separator */
13749           case ',':             /* $,: output field separator */
13750           case '.':             /* $.: last read line number */
13751           case '=':             /* $=: ignorecase */
13752           case ':':             /* $:: load path */
13753           case '<':             /* $<: reading filename */
13754           case '>':             /* $>: default output handle */
13755           case '\"':            /* $": already loaded files */
13756             tokadd('$');
13757             tokadd(c);
13758             tokfix();
13759             set_yylval_name(rb_intern(tok()));
13760             return tGVAR;
13761 
13762           case '-':
13763             tokadd('$');
13764             tokadd(c);
13765             c = nextc();
13766             if (parser_is_identchar()) {
13767                 if (tokadd_mbchar(c) == -1) return 0;
13768             }
13769             else {
13770                 pushback(c);
13771             }
13772           gvar:
13773             tokfix();
13774             set_yylval_name(rb_intern(tok()));
13775             return tGVAR;
13776 
13777           case '&':             /* $&: last match */
13778           case '`':             /* $`: string before last match */
13779           case '\'':            /* $': string after last match */
13780           case '+':             /* $+: string matches last paren. */
13781             if (last_state == EXPR_FNAME) {
13782                 tokadd('$');
13783                 tokadd(c);
13784                 goto gvar;
13785             }
13786             set_yylval_node(NEW_BACK_REF(c));
13787             return tBACK_REF;
13788 
13789           case '1': case '2': case '3':
13790           case '4': case '5': case '6':
13791           case '7': case '8': case '9':
13792             tokadd('$');
13793             do {
13794                 tokadd(c);
13795                 c = nextc();
13796             } while (c != -1 && ISDIGIT(c));
13797             pushback(c);
13798             if (last_state == EXPR_FNAME) goto gvar;
13799             tokfix();
13800             set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
13801             return tNTH_REF;
13802 
13803           default:
13804             if (!parser_is_identchar()) {
13805                 pushback(c);
13806                 return '$';
13807             }
13808           case '0':
13809             tokadd('$');
13810         }
13811         break;
13812 
13813       case '@':
13814         c = nextc();
13815         newtok();
13816         tokadd('@');
13817         if (c == '@') {
13818             tokadd('@');
13819             c = nextc();
13820         }
13821         if (c != -1 && ISDIGIT(c)) {
13822             if (tokidx == 1) {
13823                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
13824             }
13825             else {
13826                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
13827             }
13828             return 0;
13829         }
13830         if (!parser_is_identchar()) {
13831             pushback(c);
13832             return '@';
13833         }
13834         break;
13835 
13836       case '_':
13837         if (was_bol() && whole_match_p("__END__", 7, 0)) {
13838             ruby__end__seen = 1;
13839             parser->eofp = Qtrue;
13840 #ifndef RIPPER
13841             return -1;
13842 #else
13843             lex_goto_eol(parser);
13844             ripper_dispatch_scan_event(parser, k__END__);
13845             return 0;
13846 #endif
13847         }
13848         newtok();
13849         break;
13850 
13851       default:
13852         if (!parser_is_identchar()) {
13853             rb_compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
13854             goto retry;
13855         }
13856 
13857         newtok();
13858         break;
13859     }
13860 
13861     mb = ENC_CODERANGE_7BIT;
13862     do {
13863         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
13864         if (tokadd_mbchar(c) == -1) return 0;
13865         c = nextc();
13866     } while (parser_is_identchar());
13867     switch (tok()[0]) {
13868       case '@': case '$':
13869         pushback(c);
13870         break;
13871       default:
13872         if ((c == '!' || c == '?') && !peek('=')) {
13873             tokadd(c);
13874         }
13875         else {
13876             pushback(c);
13877         }
13878     }
13879     tokfix();
13880 
13881     {
13882         int result = 0;
13883 
13884         last_state = lex_state;
13885         switch (tok()[0]) {
13886           case '$':
13887             lex_state = EXPR_END;
13888             result = tGVAR;
13889             break;
13890           case '@':
13891             lex_state = EXPR_END;
13892             if (tok()[1] == '@')
13893                 result = tCVAR;
13894             else
13895                 result = tIVAR;
13896             break;
13897 
13898           default:
13899             if (toklast() == '!' || toklast() == '?') {
13900                 result = tFID;
13901             }
13902             else {
13903                 if (lex_state == EXPR_FNAME) {
13904                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
13905                         (!peek('=') || (lex_p + 1 < lex_pend && lex_p[1] == '>'))) {
13906                         result = tIDENTIFIER;
13907                         tokadd(c);
13908                         tokfix();
13909                     }
13910                     else {
13911                         pushback(c);
13912                     }
13913                 }
13914                 if (result == 0 && ISUPPER(tok()[0])) {
13915                     result = tCONSTANT;
13916                 }
13917                 else {
13918                     result = tIDENTIFIER;
13919                 }
13920             }
13921 
13922             if ((lex_state == EXPR_BEG && !cmd_state) ||
13923                 IS_ARG()) {
13924                 if (peek(':') && !(lex_p + 1 < lex_pend && lex_p[1] == ':')) {
13925                     lex_state = EXPR_BEG;
13926                     nextc();
13927                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
13928                     return tLABEL;
13929                 }
13930             }
13931             if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
13932                 const struct kwtable *kw;
13933 
13934                 /* See if it is a reserved word.  */
13935                 kw = rb_reserved_word(tok(), toklen());
13936                 if (kw) {
13937                     enum lex_state_e state = lex_state;
13938                     lex_state = kw->state;
13939                     if (state == EXPR_FNAME) {
13940                         set_yylval_name(rb_intern(kw->name));
13941                         return kw->id[0];
13942                     }
13943                     if (kw->id[0] == keyword_do) {
13944                         command_start = TRUE;
13945                         if (lpar_beg && lpar_beg == paren_nest) {
13946                             lpar_beg = 0;
13947                             --paren_nest;
13948                             return keyword_do_LAMBDA;
13949                         }
13950                         if (COND_P()) return keyword_do_cond;
13951                         if (CMDARG_P() && state != EXPR_CMDARG)
13952                             return keyword_do_block;
13953                         if (state == EXPR_ENDARG || state == EXPR_BEG)
13954                             return keyword_do_block;
13955                         return keyword_do;
13956                     }
13957                     if (state == EXPR_BEG || state == EXPR_VALUE)
13958                         return kw->id[0];
13959                     else {
13960                         if (kw->id[0] != kw->id[1])
13961                             lex_state = EXPR_BEG;
13962                         return kw->id[1];
13963                     }
13964                 }
13965             }
13966 
13967             if (IS_BEG() ||
13968                 lex_state == EXPR_DOT ||
13969                 IS_ARG()) {
13970                 if (cmd_state) {
13971                     lex_state = EXPR_CMDARG;
13972                 }
13973                 else {
13974                     lex_state = EXPR_ARG;
13975                 }
13976             }
13977             else if (lex_state == EXPR_FNAME) {
13978                 lex_state = EXPR_ENDFN;
13979             }
13980             else {
13981                 lex_state = EXPR_END;
13982             }
13983         }
13984         {
13985             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
13986 
13987             set_yylval_name(ident);
13988             if (last_state != EXPR_DOT && is_local_id(ident) && lvar_defined(ident)) {
13989                 lex_state = EXPR_END;
13990             }
13991         }
13992         return result;
13993     }
13994 }
13995 
13996 #if YYPURE
13997 static int
13998 yylex(void *lval, void *p)
13999 #else
14000 yylex(void *p)
14001 #endif
14002 {
14003     struct parser_params *parser = (struct parser_params*)p;
14004     int t;
14005 
14006 #if YYPURE
14007     parser->parser_yylval = lval;
14008     parser->parser_yylval->val = Qundef;
14009 #endif
14010     t = parser_yylex(parser);
14011 #ifdef RIPPER
14012     if (!NIL_P(parser->delayed)) {
14013         ripper_dispatch_delayed_token(parser, t);
14014         return t;
14015     }
14016     if (t != 0)
14017         ripper_dispatch_scan_event(parser, t);
14018 #endif
14019 
14020     return t;
14021 }
14022 
14023 #ifndef RIPPER
14024 static NODE*
14025 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14026 {
14027     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14028     nd_set_line(n, ruby_sourceline);
14029     return n;
14030 }
14031 
14032 enum node_type
14033 nodetype(NODE *node)                    /* for debug */
14034 {
14035     return (enum node_type)nd_type(node);
14036 }
14037 
14038 int
14039 nodeline(NODE *node)
14040 {
14041     return nd_line(node);
14042 }
14043 
14044 static NODE*
14045 newline_node(NODE *node)
14046 {
14047     if (node) {
14048         node = remove_begin(node);
14049         node->flags |= NODE_FL_NEWLINE;
14050     }
14051     return node;
14052 }
14053 
14054 static void
14055 fixpos(NODE *node, NODE *orig)
14056 {
14057     if (!node) return;
14058     if (!orig) return;
14059     if (orig == (NODE*)1) return;
14060     nd_set_line(node, nd_line(orig));
14061 }
14062 
14063 static void
14064 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14065 {
14066     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14067 }
14068 #define parser_warning(node, mesg) parser_warning(parser, node, mesg)
14069 
14070 static void
14071 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14072 {
14073     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14074 }
14075 #define parser_warn(node, mesg) parser_warn(parser, node, mesg)
14076 
14077 static NODE*
14078 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14079 {
14080     NODE *end, *h = head, *nd;
14081 
14082     if (tail == 0) return head;
14083 
14084     if (h == 0) return tail;
14085     switch (nd_type(h)) {
14086       case NODE_LIT:
14087       case NODE_STR:
14088       case NODE_SELF:
14089       case NODE_TRUE:
14090       case NODE_FALSE:
14091       case NODE_NIL:
14092         parser_warning(h, "unused literal ignored");
14093         return tail;
14094       default:
14095         h = end = NEW_BLOCK(head);
14096         end->nd_end = end;
14097         fixpos(end, head);
14098         head = end;
14099         break;
14100       case NODE_BLOCK:
14101         end = h->nd_end;
14102         break;
14103     }
14104 
14105     nd = end->nd_head;
14106     switch (nd_type(nd)) {
14107       case NODE_RETURN:
14108       case NODE_BREAK:
14109       case NODE_NEXT:
14110       case NODE_REDO:
14111       case NODE_RETRY:
14112         if (RTEST(ruby_verbose)) {
14113             parser_warning(nd, "statement not reached");
14114         }
14115         break;
14116 
14117       default:
14118         break;
14119     }
14120 
14121     if (nd_type(tail) != NODE_BLOCK) {
14122         tail = NEW_BLOCK(tail);
14123         tail->nd_end = tail;
14124     }
14125     end->nd_next = tail;
14126     h->nd_end = tail->nd_end;
14127     return head;
14128 }
14129 
14130 /* append item to the list */
14131 static NODE*
14132 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14133 {
14134     NODE *last;
14135 
14136     if (list == 0) return NEW_LIST(item);
14137     if (list->nd_next) {
14138         last = list->nd_next->nd_end;
14139     }
14140     else {
14141         last = list;
14142     }
14143 
14144     list->nd_alen += 1;
14145     last->nd_next = NEW_LIST(item);
14146     list->nd_next->nd_end = last->nd_next;
14147     return list;
14148 }
14149 
14150 /* concat two lists */
14151 static NODE*
14152 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14153 {
14154     NODE *last;
14155 
14156     if (head->nd_next) {
14157         last = head->nd_next->nd_end;
14158     }
14159     else {
14160         last = head;
14161     }
14162 
14163     head->nd_alen += tail->nd_alen;
14164     last->nd_next = tail;
14165     if (tail->nd_next) {
14166         head->nd_next->nd_end = tail->nd_next->nd_end;
14167     }
14168     else {
14169         head->nd_next->nd_end = tail;
14170     }
14171 
14172     return head;
14173 }
14174 
14175 static int
14176 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14177 {
14178     if (NIL_P(tail)) return 1;
14179     if (!rb_enc_compatible(head, tail)) {
14180         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14181                       rb_enc_name(rb_enc_get(head)),
14182                       rb_enc_name(rb_enc_get(tail)));
14183         rb_str_resize(head, 0);
14184         rb_str_resize(tail, 0);
14185         return 0;
14186     }
14187     rb_str_buf_append(head, tail);
14188     return 1;
14189 }
14190 
14191 /* concat two string literals */
14192 static NODE *
14193 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14194 {
14195     enum node_type htype;
14196 
14197     if (!head) return tail;
14198     if (!tail) return head;
14199 
14200     htype = nd_type(head);
14201     if (htype == NODE_EVSTR) {
14202         NODE *node = NEW_DSTR(Qnil);
14203         head = list_append(node, head);
14204     }
14205     switch (nd_type(tail)) {
14206       case NODE_STR:
14207         if (htype == NODE_STR) {
14208             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) {
14209               error:
14210                 rb_gc_force_recycle((VALUE)head);
14211                 rb_gc_force_recycle((VALUE)tail);
14212                 return 0;
14213             }
14214             rb_gc_force_recycle((VALUE)tail);
14215         }
14216         else {
14217             list_append(head, tail);
14218         }
14219         break;
14220 
14221       case NODE_DSTR:
14222         if (htype == NODE_STR) {
14223             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14224                 goto error;
14225             tail->nd_lit = head->nd_lit;
14226             rb_gc_force_recycle((VALUE)head);
14227             head = tail;
14228         }
14229         else if (NIL_P(tail->nd_lit)) {
14230             head->nd_alen += tail->nd_alen - 1;
14231             head->nd_next->nd_end->nd_next = tail->nd_next;
14232             head->nd_next->nd_end = tail->nd_next->nd_end;
14233             rb_gc_force_recycle((VALUE)tail);
14234         }
14235         else {
14236             nd_set_type(tail, NODE_ARRAY);
14237             tail->nd_head = NEW_STR(tail->nd_lit);
14238             list_concat(head, tail);
14239         }
14240         break;
14241 
14242       case NODE_EVSTR:
14243         if (htype == NODE_STR) {
14244             nd_set_type(head, NODE_DSTR);
14245             head->nd_alen = 1;
14246         }
14247         list_append(head, tail);
14248         break;
14249     }
14250     return head;
14251 }
14252 
14253 static NODE *
14254 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14255 {
14256     if (nd_type(node) == NODE_EVSTR) {
14257         node = list_append(NEW_DSTR(Qnil), node);
14258     }
14259     return node;
14260 }
14261 
14262 static NODE *
14263 new_evstr_gen(struct parser_params *parser, NODE *node)
14264 {
14265     NODE *head = node;
14266 
14267     if (node) {
14268         switch (nd_type(node)) {
14269           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14270             return node;
14271         }
14272     }
14273     return NEW_EVSTR(head);
14274 }
14275 
14276 static NODE *
14277 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14278 {
14279     value_expr(recv);
14280     value_expr(arg1);
14281     return NEW_CALL(recv, id, NEW_LIST(arg1));
14282 }
14283 
14284 static NODE *
14285 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14286 {
14287     value_expr(recv);
14288     return NEW_CALL(recv, id, 0);
14289 }
14290 
14291 static NODE*
14292 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14293 {
14294     value_expr(node1);
14295     value_expr(node2);
14296     if (node1) {
14297         switch (nd_type(node1)) {
14298           case NODE_DREGX:
14299           case NODE_DREGX_ONCE:
14300             return NEW_MATCH2(node1, node2);
14301 
14302           case NODE_LIT:
14303             if (TYPE(node1->nd_lit) == T_REGEXP) {
14304                 return NEW_MATCH2(node1, node2);
14305             }
14306         }
14307     }
14308 
14309     if (node2) {
14310         switch (nd_type(node2)) {
14311           case NODE_DREGX:
14312           case NODE_DREGX_ONCE:
14313             return NEW_MATCH3(node2, node1);
14314 
14315           case NODE_LIT:
14316             if (TYPE(node2->nd_lit) == T_REGEXP) {
14317                 return NEW_MATCH3(node2, node1);
14318             }
14319         }
14320     }
14321 
14322     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14323 }
14324 
14325 static NODE*
14326 gettable_gen(struct parser_params *parser, ID id)
14327 {
14328     if (id == keyword_self) {
14329         return NEW_SELF();
14330     }
14331     else if (id == keyword_nil) {
14332         return NEW_NIL();
14333     }
14334     else if (id == keyword_true) {
14335         return NEW_TRUE();
14336     }
14337     else if (id == keyword_false) {
14338         return NEW_FALSE();
14339     }
14340     else if (id == keyword__FILE__) {
14341         return NEW_STR(rb_external_str_new_with_enc(ruby_sourcefile, strlen(ruby_sourcefile),
14342                                                     rb_filesystem_encoding()));
14343     }
14344     else if (id == keyword__LINE__) {
14345         return NEW_LIT(INT2FIX(ruby_sourceline));
14346     }
14347     else if (id == keyword__ENCODING__) {
14348         return NEW_LIT(rb_enc_from_encoding(parser->enc));
14349     }
14350     else if (is_local_id(id)) {
14351         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14352         if (local_id(id)) return NEW_LVAR(id);
14353         /* method call without arguments */
14354         return NEW_VCALL(id);
14355     }
14356     else if (is_global_id(id)) {
14357         return NEW_GVAR(id);
14358     }
14359     else if (is_instance_id(id)) {
14360         return NEW_IVAR(id);
14361     }
14362     else if (is_const_id(id)) {
14363         return NEW_CONST(id);
14364     }
14365     else if (is_class_id(id)) {
14366         return NEW_CVAR(id);
14367     }
14368     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14369     return 0;
14370 }
14371 #endif /* !RIPPER */
14372 
14373 #ifdef RIPPER
14374 static VALUE
14375 assignable_gen(struct parser_params *parser, VALUE lhs)
14376 #else
14377 static NODE*
14378 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14379 #endif
14380 {
14381 #ifdef RIPPER
14382     ID id = get_id(lhs);
14383 # define assignable_result(x) get_value(lhs)
14384 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14385 #else
14386 # define assignable_result(x) x
14387 #endif
14388     if (!id) return assignable_result(0);
14389     if (id == keyword_self) {
14390         yyerror("Can't change the value of self");
14391     }
14392     else if (id == keyword_nil) {
14393         yyerror("Can't assign to nil");
14394     }
14395     else if (id == keyword_true) {
14396         yyerror("Can't assign to true");
14397     }
14398     else if (id == keyword_false) {
14399         yyerror("Can't assign to false");
14400     }
14401     else if (id == keyword__FILE__) {
14402         yyerror("Can't assign to __FILE__");
14403     }
14404     else if (id == keyword__LINE__) {
14405         yyerror("Can't assign to __LINE__");
14406     }
14407     else if (id == keyword__ENCODING__) {
14408         yyerror("Can't assign to __ENCODING__");
14409     }
14410     else if (is_local_id(id)) {
14411         if (dyna_in_block()) {
14412             if (dvar_curr(id)) {
14413                 return assignable_result(NEW_DASGN_CURR(id, val));
14414             }
14415             else if (dvar_defined(id)) {
14416                 return assignable_result(NEW_DASGN(id, val));
14417             }
14418             else if (local_id(id)) {
14419                 return assignable_result(NEW_LASGN(id, val));
14420             }
14421             else {
14422                 dyna_var(id);
14423                 return assignable_result(NEW_DASGN_CURR(id, val));
14424             }
14425         }
14426         else {
14427             if (!local_id(id)) {
14428                 local_var(id);
14429             }
14430             return assignable_result(NEW_LASGN(id, val));
14431         }
14432     }
14433     else if (is_global_id(id)) {
14434         return assignable_result(NEW_GASGN(id, val));
14435     }
14436     else if (is_instance_id(id)) {
14437         return assignable_result(NEW_IASGN(id, val));
14438     }
14439     else if (is_const_id(id)) {
14440         if (!in_def && !in_single)
14441             return assignable_result(NEW_CDECL(id, val, 0));
14442         yyerror("dynamic constant assignment");
14443     }
14444     else if (is_class_id(id)) {
14445         return assignable_result(NEW_CVASGN(id, val));
14446     }
14447     else {
14448         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
14449     }
14450     return assignable_result(0);
14451 #undef assignable_result
14452 #undef parser_yyerror
14453 }
14454 
14455 static ID
14456 shadowing_lvar_gen(struct parser_params *parser, ID name)
14457 {
14458     ID uscore;
14459 
14460     CONST_ID(uscore, "_");
14461     if (uscore == name) return name;
14462     if (dyna_in_block()) {
14463         if (dvar_curr(name)) {
14464             yyerror("duplicated argument name");
14465         }
14466         else if (dvar_defined(name) || local_id(name)) {
14467             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
14468             vtable_add(lvtbl->vars, name);
14469         }
14470     }
14471     else {
14472         if (local_id(name)) {
14473             yyerror("duplicated argument name");
14474         }
14475     }
14476     return name;
14477 }
14478 
14479 static void
14480 new_bv_gen(struct parser_params *parser, ID name)
14481 {
14482     if (!name) return;
14483     if (!is_local_id(name)) {
14484         compile_error(PARSER_ARG "invalid local variable - %s",
14485                       rb_id2name(name));
14486         return;
14487     }
14488     shadowing_lvar(name);
14489     dyna_var(name);
14490 }
14491 
14492 #ifndef RIPPER
14493 static NODE *
14494 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
14495 {
14496     if (recv && nd_type(recv) == NODE_SELF)
14497         recv = (NODE *)1;
14498     return NEW_ATTRASGN(recv, tASET, idx);
14499 }
14500 
14501 static void
14502 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14503 {
14504     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
14505         compile_error(PARSER_ARG "both block arg and actual block given");
14506     }
14507 }
14508 
14509 ID
14510 rb_id_attrset(ID id)
14511 {
14512     id &= ~ID_SCOPE_MASK;
14513     id |= ID_ATTRSET;
14514     return id;
14515 }
14516 
14517 static NODE *
14518 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
14519 {
14520     if (recv && nd_type(recv) == NODE_SELF)
14521         recv = (NODE *)1;
14522     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
14523 }
14524 
14525 static void
14526 rb_backref_error_gen(struct parser_params *parser, NODE *node)
14527 {
14528     switch (nd_type(node)) {
14529       case NODE_NTH_REF:
14530         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
14531         break;
14532       case NODE_BACK_REF:
14533         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
14534         break;
14535     }
14536 }
14537 
14538 static NODE *
14539 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14540 {
14541     if (!node2) return node1;
14542     switch (nd_type(node1)) {
14543       case NODE_BLOCK_PASS:
14544         if (node1->nd_head)
14545             node1->nd_head = arg_concat(node1->nd_head, node2);
14546         else
14547             node1->nd_head = NEW_LIST(node2);
14548         return node1;
14549       case NODE_ARGSPUSH:
14550         if (nd_type(node2) != NODE_ARRAY) break;
14551         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
14552         nd_set_type(node1, NODE_ARGSCAT);
14553         return node1;
14554       case NODE_ARGSCAT:
14555         if (nd_type(node2) != NODE_ARRAY ||
14556             nd_type(node1->nd_body) != NODE_ARRAY) break;
14557         node1->nd_body = list_concat(node1->nd_body, node2);
14558         return node1;
14559     }
14560     return NEW_ARGSCAT(node1, node2);
14561 }
14562 
14563 static NODE *
14564 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14565 {
14566     if (!node1) return NEW_LIST(node2);
14567     switch (nd_type(node1))  {
14568       case NODE_ARRAY:
14569         return list_append(node1, node2);
14570       case NODE_BLOCK_PASS:
14571         node1->nd_head = arg_append(node1->nd_head, node2);
14572         return node1;
14573       case NODE_ARGSPUSH:
14574         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
14575         nd_set_type(node1, NODE_ARGSCAT);
14576         return node1;
14577     }
14578     return NEW_ARGSPUSH(node1, node2);
14579 }
14580 
14581 static NODE *
14582 splat_array(NODE* node)
14583 {
14584     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
14585     if (nd_type(node) == NODE_ARRAY) return node;
14586     return 0;
14587 }
14588 
14589 static NODE *
14590 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
14591 {
14592     if (!lhs) return 0;
14593 
14594     switch (nd_type(lhs)) {
14595       case NODE_GASGN:
14596       case NODE_IASGN:
14597       case NODE_IASGN2:
14598       case NODE_LASGN:
14599       case NODE_DASGN:
14600       case NODE_DASGN_CURR:
14601       case NODE_MASGN:
14602       case NODE_CDECL:
14603       case NODE_CVASGN:
14604         lhs->nd_value = rhs;
14605         break;
14606 
14607       case NODE_ATTRASGN:
14608       case NODE_CALL:
14609         lhs->nd_args = arg_append(lhs->nd_args, rhs);
14610         break;
14611 
14612       default:
14613         /* should not happen */
14614         break;
14615     }
14616 
14617     return lhs;
14618 }
14619 
14620 static int
14621 value_expr_gen(struct parser_params *parser, NODE *node)
14622 {
14623     int cond = 0;
14624 
14625     if (!node) {
14626         rb_warning0("empty expression");
14627     }
14628     while (node) {
14629         switch (nd_type(node)) {
14630           case NODE_DEFN:
14631           case NODE_DEFS:
14632             parser_warning(node, "void value expression");
14633             return FALSE;
14634 
14635           case NODE_RETURN:
14636           case NODE_BREAK:
14637           case NODE_NEXT:
14638           case NODE_REDO:
14639           case NODE_RETRY:
14640             if (!cond) yyerror("void value expression");
14641             /* or "control never reach"? */
14642             return FALSE;
14643 
14644           case NODE_BLOCK:
14645             while (node->nd_next) {
14646                 node = node->nd_next;
14647             }
14648             node = node->nd_head;
14649             break;
14650 
14651           case NODE_BEGIN:
14652             node = node->nd_body;
14653             break;
14654 
14655           case NODE_IF:
14656             if (!node->nd_body) {
14657                 node = node->nd_else;
14658                 break;
14659             }
14660             else if (!node->nd_else) {
14661                 node = node->nd_body;
14662                 break;
14663             }
14664             if (!value_expr(node->nd_body)) return FALSE;
14665             node = node->nd_else;
14666             break;
14667 
14668           case NODE_AND:
14669           case NODE_OR:
14670             cond = 1;
14671             node = node->nd_2nd;
14672             break;
14673 
14674           default:
14675             return TRUE;
14676         }
14677     }
14678 
14679     return TRUE;
14680 }
14681 
14682 static void
14683 void_expr_gen(struct parser_params *parser, NODE *node)
14684 {
14685     const char *useless = 0;
14686 
14687     if (!RTEST(ruby_verbose)) return;
14688 
14689     if (!node) return;
14690     switch (nd_type(node)) {
14691       case NODE_CALL:
14692         switch (node->nd_mid) {
14693           case '+':
14694           case '-':
14695           case '*':
14696           case '/':
14697           case '%':
14698           case tPOW:
14699           case tUPLUS:
14700           case tUMINUS:
14701           case '|':
14702           case '^':
14703           case '&':
14704           case tCMP:
14705           case '>':
14706           case tGEQ:
14707           case '<':
14708           case tLEQ:
14709           case tEQ:
14710           case tNEQ:
14711             useless = rb_id2name(node->nd_mid);
14712             break;
14713         }
14714         break;
14715 
14716       case NODE_LVAR:
14717       case NODE_DVAR:
14718       case NODE_GVAR:
14719       case NODE_IVAR:
14720       case NODE_CVAR:
14721       case NODE_NTH_REF:
14722       case NODE_BACK_REF:
14723         useless = "a variable";
14724         break;
14725       case NODE_CONST:
14726         useless = "a constant";
14727         break;
14728       case NODE_LIT:
14729       case NODE_STR:
14730       case NODE_DSTR:
14731       case NODE_DREGX:
14732       case NODE_DREGX_ONCE:
14733         useless = "a literal";
14734         break;
14735       case NODE_COLON2:
14736       case NODE_COLON3:
14737         useless = "::";
14738         break;
14739       case NODE_DOT2:
14740         useless = "..";
14741         break;
14742       case NODE_DOT3:
14743         useless = "...";
14744         break;
14745       case NODE_SELF:
14746         useless = "self";
14747         break;
14748       case NODE_NIL:
14749         useless = "nil";
14750         break;
14751       case NODE_TRUE:
14752         useless = "true";
14753         break;
14754       case NODE_FALSE:
14755         useless = "false";
14756         break;
14757       case NODE_DEFINED:
14758         useless = "defined?";
14759         break;
14760     }
14761 
14762     if (useless) {
14763         int line = ruby_sourceline;
14764 
14765         ruby_sourceline = nd_line(node);
14766         rb_warnS("useless use of %s in void context", useless);
14767         ruby_sourceline = line;
14768     }
14769 }
14770 
14771 static void
14772 void_stmts_gen(struct parser_params *parser, NODE *node)
14773 {
14774     if (!RTEST(ruby_verbose)) return;
14775     if (!node) return;
14776     if (nd_type(node) != NODE_BLOCK) return;
14777 
14778     for (;;) {
14779         if (!node->nd_next) return;
14780         void_expr0(node->nd_head);
14781         node = node->nd_next;
14782     }
14783 }
14784 
14785 static NODE *
14786 remove_begin(NODE *node)
14787 {
14788     NODE **n = &node, *n1 = node;
14789     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
14790         *n = n1 = n1->nd_body;
14791     }
14792     return node;
14793 }
14794 
14795 static void
14796 reduce_nodes_gen(struct parser_params *parser, NODE **body)
14797 {
14798     NODE *node = *body;
14799 
14800     if (!node) {
14801         *body = NEW_NIL();
14802         return;
14803     }
14804 #define subnodes(n1, n2) \
14805     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
14806      (!node->n2) ? (body = &node->n1, 1) : \
14807      (reduce_nodes(&node->n1), body = &node->n2, 1))
14808 
14809     while (node) {
14810         int newline = (int)(node->flags & NODE_FL_NEWLINE);
14811         switch (nd_type(node)) {
14812           end:
14813           case NODE_NIL:
14814             *body = 0;
14815             return;
14816           case NODE_RETURN:
14817             *body = node = node->nd_stts;
14818             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14819             continue;
14820           case NODE_BEGIN:
14821             *body = node = node->nd_body;
14822             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14823             continue;
14824           case NODE_BLOCK:
14825             body = &node->nd_end->nd_head;
14826             break;
14827           case NODE_IF:
14828             if (subnodes(nd_body, nd_else)) break;
14829             return;
14830           case NODE_CASE:
14831             body = &node->nd_body;
14832             break;
14833           case NODE_WHEN:
14834             if (!subnodes(nd_body, nd_next)) goto end;
14835             break;
14836           case NODE_ENSURE:
14837             if (!subnodes(nd_head, nd_resq)) goto end;
14838             break;
14839           case NODE_RESCUE:
14840             if (!subnodes(nd_head, nd_resq)) goto end;
14841             break;
14842           default:
14843             return;
14844         }
14845         node = *body;
14846         if (newline && node) node->flags |= NODE_FL_NEWLINE;
14847     }
14848 
14849 #undef subnodes
14850 }
14851 
14852 static int
14853 assign_in_cond(struct parser_params *parser, NODE *node)
14854 {
14855     switch (nd_type(node)) {
14856       case NODE_MASGN:
14857         yyerror("multiple assignment in conditional");
14858         return 1;
14859 
14860       case NODE_LASGN:
14861       case NODE_DASGN:
14862       case NODE_DASGN_CURR:
14863       case NODE_GASGN:
14864       case NODE_IASGN:
14865         break;
14866 
14867       default:
14868         return 0;
14869     }
14870 
14871     if (!node->nd_value) return 1;
14872     switch (nd_type(node->nd_value)) {
14873       case NODE_LIT:
14874       case NODE_STR:
14875       case NODE_NIL:
14876       case NODE_TRUE:
14877       case NODE_FALSE:
14878         /* reports always */
14879         parser_warn(node->nd_value, "found = in conditional, should be ==");
14880         return 1;
14881 
14882       case NODE_DSTR:
14883       case NODE_XSTR:
14884       case NODE_DXSTR:
14885       case NODE_EVSTR:
14886       case NODE_DREGX:
14887       default:
14888         break;
14889     }
14890     return 1;
14891 }
14892 
14893 static void
14894 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14895 {
14896     if (!e_option_supplied(parser)) parser_warn(node, str);
14897 }
14898 
14899 static void
14900 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14901 {
14902     if (!e_option_supplied(parser)) parser_warning(node, str);
14903 }
14904 
14905 static void
14906 fixup_nodes(NODE **rootnode)
14907 {
14908     NODE *node, *next, *head;
14909 
14910     for (node = *rootnode; node; node = next) {
14911         enum node_type type;
14912         VALUE val;
14913 
14914         next = node->nd_next;
14915         head = node->nd_head;
14916         rb_gc_force_recycle((VALUE)node);
14917         *rootnode = next;
14918         switch (type = nd_type(head)) {
14919           case NODE_DOT2:
14920           case NODE_DOT3:
14921             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
14922                                type == NODE_DOT3);
14923             rb_gc_force_recycle((VALUE)head->nd_beg);
14924             rb_gc_force_recycle((VALUE)head->nd_end);
14925             nd_set_type(head, NODE_LIT);
14926             head->nd_lit = val;
14927             break;
14928           default:
14929             break;
14930         }
14931     }
14932 }
14933 
14934 static NODE *cond0(struct parser_params*,NODE*);
14935 
14936 static NODE*
14937 range_op(struct parser_params *parser, NODE *node)
14938 {
14939     enum node_type type;
14940 
14941     if (node == 0) return 0;
14942 
14943     type = nd_type(node);
14944     value_expr(node);
14945     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
14946         warn_unless_e_option(parser, node, "integer literal in conditional range");
14947         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
14948     }
14949     return cond0(parser, node);
14950 }
14951 
14952 static int
14953 literal_node(NODE *node)
14954 {
14955     if (!node) return 1;        /* same as NODE_NIL */
14956     switch (nd_type(node)) {
14957       case NODE_LIT:
14958       case NODE_STR:
14959       case NODE_DSTR:
14960       case NODE_EVSTR:
14961       case NODE_DREGX:
14962       case NODE_DREGX_ONCE:
14963       case NODE_DSYM:
14964         return 2;
14965       case NODE_TRUE:
14966       case NODE_FALSE:
14967       case NODE_NIL:
14968         return 1;
14969     }
14970     return 0;
14971 }
14972 
14973 static NODE*
14974 cond0(struct parser_params *parser, NODE *node)
14975 {
14976     if (node == 0) return 0;
14977     assign_in_cond(parser, node);
14978 
14979     switch (nd_type(node)) {
14980       case NODE_DSTR:
14981       case NODE_EVSTR:
14982       case NODE_STR:
14983         rb_warn0("string literal in condition");
14984         break;
14985 
14986       case NODE_DREGX:
14987       case NODE_DREGX_ONCE:
14988         warning_unless_e_option(parser, node, "regex literal in condition");
14989         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
14990 
14991       case NODE_AND:
14992       case NODE_OR:
14993         node->nd_1st = cond0(parser, node->nd_1st);
14994         node->nd_2nd = cond0(parser, node->nd_2nd);
14995         break;
14996 
14997       case NODE_DOT2:
14998       case NODE_DOT3:
14999         node->nd_beg = range_op(parser, node->nd_beg);
15000         node->nd_end = range_op(parser, node->nd_end);
15001         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15002         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15003         if (!e_option_supplied(parser)) {
15004             int b = literal_node(node->nd_beg);
15005             int e = literal_node(node->nd_end);
15006             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15007                 parser_warn(node, "range literal in condition");
15008             }
15009         }
15010         break;
15011 
15012       case NODE_DSYM:
15013         parser_warning(node, "literal in condition");
15014         break;
15015 
15016       case NODE_LIT:
15017         if (TYPE(node->nd_lit) == T_REGEXP) {
15018             warn_unless_e_option(parser, node, "regex literal in condition");
15019             nd_set_type(node, NODE_MATCH);
15020         }
15021         else {
15022             parser_warning(node, "literal in condition");
15023         }
15024       default:
15025         break;
15026     }
15027     return node;
15028 }
15029 
15030 static NODE*
15031 cond_gen(struct parser_params *parser, NODE *node)
15032 {
15033     if (node == 0) return 0;
15034     return cond0(parser, node);
15035 }
15036 
15037 static NODE*
15038 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15039 {
15040     value_expr(left);
15041     if (left && (enum node_type)nd_type(left) == type) {
15042         NODE *node = left, *second;
15043         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15044             node = second;
15045         }
15046         node->nd_2nd = NEW_NODE(type, second, right, 0);
15047         return left;
15048     }
15049     return NEW_NODE(type, left, right, 0);
15050 }
15051 
15052 static void
15053 no_blockarg(struct parser_params *parser, NODE *node)
15054 {
15055     if (node && nd_type(node) == NODE_BLOCK_PASS) {
15056         compile_error(PARSER_ARG "block argument should not be given");
15057     }
15058 }
15059 
15060 static NODE *
15061 ret_args_gen(struct parser_params *parser, NODE *node)
15062 {
15063     if (node) {
15064         no_blockarg(parser, node);
15065         if (nd_type(node) == NODE_ARRAY) {
15066             if (node->nd_next == 0) {
15067                 node = node->nd_head;
15068             }
15069             else {
15070                 nd_set_type(node, NODE_VALUES);
15071             }
15072         }
15073     }
15074     return node;
15075 }
15076 
15077 static NODE *
15078 new_yield_gen(struct parser_params *parser, NODE *node)
15079 {
15080     long state = Qtrue;
15081 
15082     if (node) {
15083         no_blockarg(parser, node);
15084         if (node && nd_type(node) == NODE_SPLAT) {
15085             state = Qtrue;
15086         }
15087     }
15088     else {
15089         state = Qfalse;
15090     }
15091     return NEW_YIELD(node, state);
15092 }
15093 
15094 static NODE*
15095 negate_lit(NODE *node)
15096 {
15097     switch (TYPE(node->nd_lit)) {
15098       case T_FIXNUM:
15099         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15100         break;
15101       case T_BIGNUM:
15102         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15103         break;
15104       case T_FLOAT:
15105         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15106         break;
15107       default:
15108         break;
15109     }
15110     return node;
15111 }
15112 
15113 static NODE *
15114 arg_blk_pass(NODE *node1, NODE *node2)
15115 {
15116     if (node2) {
15117         node2->nd_head = node1;
15118         return node2;
15119     }
15120     return node1;
15121 }
15122 
15123 static NODE*
15124 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
15125 {
15126     int saved_line = ruby_sourceline;
15127     NODE *node;
15128     NODE *i1, *i2 = 0;
15129 
15130     node = NEW_ARGS(m ? m->nd_plen : 0, o);
15131     i1 = m ? m->nd_next : 0;
15132     node->nd_next = NEW_ARGS_AUX(r, b);
15133 
15134     if (p) {
15135         i2 = p->nd_next;
15136         node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
15137     }
15138     else if (i1) {
15139         node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
15140     }
15141     if (i1 || i2) {
15142         node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
15143     }
15144     ruby_sourceline = saved_line;
15145     return node;
15146 }
15147 #endif /* !RIPPER */
15148 
15149 static void
15150 local_push_gen(struct parser_params *parser, int inherit_dvars)
15151 {
15152     struct local_vars *local;
15153 
15154     local = ALLOC(struct local_vars);
15155     local->prev = lvtbl;
15156     local->args = vtable_alloc(0);
15157     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15158     lvtbl = local;
15159 }
15160 
15161 static void
15162 local_pop_gen(struct parser_params *parser)
15163 {
15164     struct local_vars *local = lvtbl->prev;
15165     vtable_free(lvtbl->args);
15166     vtable_free(lvtbl->vars);
15167     xfree(lvtbl);
15168     lvtbl = local;
15169 }
15170 
15171 #ifndef RIPPER
15172 static ID*
15173 vtable_tblcpy(ID *buf, const struct vtable *src)
15174 {
15175     int i, cnt = vtable_size(src);
15176 
15177     if (cnt > 0) {
15178         buf[0] = cnt;
15179         for (i = 0; i < cnt; i++) {
15180             buf[i] = src->tbl[i];
15181         }
15182         return buf;
15183     }
15184     return 0;
15185 }
15186 
15187 static ID*
15188 local_tbl_gen(struct parser_params *parser)
15189 {
15190     int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
15191     ID *buf;
15192 
15193     if (cnt <= 0) return 0;
15194     buf = ALLOC_N(ID, cnt + 1);
15195     vtable_tblcpy(buf+1, lvtbl->args);
15196     vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
15197     buf[0] = cnt;
15198     return buf;
15199 }
15200 #endif
15201 
15202 static int
15203 arg_var_gen(struct parser_params *parser, ID id)
15204 {
15205     vtable_add(lvtbl->args, id);
15206     return vtable_size(lvtbl->args) - 1;
15207 }
15208 
15209 static int
15210 local_var_gen(struct parser_params *parser, ID id)
15211 {
15212     vtable_add(lvtbl->vars, id);
15213     return vtable_size(lvtbl->vars) - 1;
15214 }
15215 
15216 static int
15217 local_id_gen(struct parser_params *parser, ID id)
15218 {
15219     struct vtable *vars, *args;
15220 
15221     vars = lvtbl->vars;
15222     args = lvtbl->args;
15223 
15224     while (vars && POINTER_P(vars->prev)) {
15225         vars = vars->prev;
15226         args = args->prev;
15227     }
15228 
15229     if (vars && vars->prev == DVARS_INHERIT) {
15230         return rb_local_defined(id);
15231     }
15232     else {
15233         return (vtable_included(args, id) ||
15234                 vtable_included(vars, id));
15235     }
15236 }
15237 
15238 static const struct vtable *
15239 dyna_push_gen(struct parser_params *parser)
15240 {
15241     lvtbl->args = vtable_alloc(lvtbl->args);
15242     lvtbl->vars = vtable_alloc(lvtbl->vars);
15243     return lvtbl->args;
15244 }
15245 
15246 static void
15247 dyna_pop_1(struct parser_params *parser)
15248 {
15249     struct vtable *tmp;
15250 
15251     tmp = lvtbl->args;
15252     lvtbl->args = lvtbl->args->prev;
15253     vtable_free(tmp);
15254     tmp = lvtbl->vars;
15255     lvtbl->vars = lvtbl->vars->prev;
15256     vtable_free(tmp);
15257 }
15258 
15259 static void
15260 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
15261 {
15262     while (lvtbl->args != lvargs) {
15263         dyna_pop_1(parser);
15264         if (!lvtbl->args) {
15265             struct local_vars *local = lvtbl->prev;
15266             xfree(lvtbl);
15267             lvtbl = local;
15268         }
15269     }
15270     dyna_pop_1(parser);
15271 }
15272 
15273 static int
15274 dyna_in_block_gen(struct parser_params *parser)
15275 {
15276     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
15277 }
15278 
15279 static int
15280 dvar_defined_gen(struct parser_params *parser, ID id)
15281 {
15282     struct vtable *vars, *args;
15283 
15284     args = lvtbl->args;
15285     vars = lvtbl->vars;
15286 
15287     while (POINTER_P(vars)) {
15288         if (vtable_included(args, id)) {
15289             return 1;
15290         }
15291         if (vtable_included(vars, id)) {
15292             return 1;
15293         }
15294         args = args->prev;
15295         vars = vars->prev;
15296     }
15297 
15298     if (vars == DVARS_INHERIT) {
15299         return rb_dvar_defined(id);
15300     }
15301 
15302     return 0;
15303 }
15304 
15305 static int
15306 dvar_curr_gen(struct parser_params *parser, ID id)
15307 {
15308     return (vtable_included(lvtbl->args, id) ||
15309             vtable_included(lvtbl->vars, id));
15310 }
15311 
15312 #ifndef RIPPER
15313 VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
15314 VALUE rb_reg_check_preprocess(VALUE);
15315 
15316 static void
15317 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
15318 {
15319     int c = RE_OPTION_ENCODING_IDX(options);
15320 
15321     if (c) {
15322         int opt, idx;
15323         rb_char_to_option_kcode(c, &opt, &idx);
15324         if (idx != ENCODING_GET(str) &&
15325             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15326             goto error;
15327         }
15328         ENCODING_SET(str, idx);
15329     }
15330     else if (RE_OPTION_ENCODING_NONE(options)) {
15331         if (!ENCODING_IS_ASCII8BIT(str) &&
15332             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15333             c = 'n';
15334             goto error;
15335         }
15336         rb_enc_associate(str, rb_ascii8bit_encoding());
15337     }
15338     else if (parser->enc == rb_usascii_encoding()) {
15339         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15340             /* raise in re.c */
15341             rb_enc_associate(str, rb_usascii_encoding());
15342         }
15343         else {
15344             rb_enc_associate(str, rb_ascii8bit_encoding());
15345         }
15346     }
15347     return;
15348 
15349   error:
15350     compile_error(PARSER_ARG
15351         "regexp encoding option '%c' differs from source encoding '%s'",
15352         c, rb_enc_name(rb_enc_get(str)));
15353 }
15354 
15355 static int
15356 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
15357 {
15358     VALUE err;
15359     reg_fragment_setenc(str, options);
15360     err = rb_reg_check_preprocess(str);
15361     if (err != Qnil) {
15362         err = rb_obj_as_string(err);
15363         compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
15364         RB_GC_GUARD(err);
15365         return 0;
15366     }
15367     return 1;
15368 }
15369 
15370 typedef struct {
15371     struct parser_params* parser;
15372     rb_encoding *enc;
15373     NODE *succ_block;
15374     NODE *fail_block;
15375     int num;
15376 } reg_named_capture_assign_t;
15377 
15378 static int
15379 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
15380           int back_num, int *back_refs, OnigRegex regex, void *arg0)
15381 {
15382     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
15383     struct parser_params* parser = arg->parser;
15384     rb_encoding *enc = arg->enc;
15385     long len = name_end - name;
15386     const char *s = (const char *)name;
15387     ID var;
15388 
15389     arg->num++;
15390 
15391     if (arg->succ_block == 0) {
15392         arg->succ_block = NEW_BEGIN(0);
15393         arg->fail_block = NEW_BEGIN(0);
15394     }
15395 
15396     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
15397         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
15398         !rb_enc_symname2_p(s, len, enc)) {
15399         return ST_CONTINUE;
15400     }
15401     var = rb_intern3(s, len, enc);
15402     if (dvar_defined(var) || local_id(var)) {
15403         rb_warningS("named capture conflicts a local variable - %s",
15404                     rb_id2name(var));
15405     }
15406     arg->succ_block = block_append(arg->succ_block,
15407         newline_node(node_assign(assignable(var,0),
15408             NEW_CALL(
15409               gettable(rb_intern("$~")),
15410               idAREF,
15411               NEW_LIST(NEW_LIT(ID2SYM(var))))
15412             )));
15413     arg->fail_block = block_append(arg->fail_block,
15414         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
15415     return ST_CONTINUE;
15416 }
15417 
15418 static NODE *
15419 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
15420 {
15421     reg_named_capture_assign_t arg;
15422 
15423     arg.parser = parser;
15424     arg.enc = rb_enc_get(regexp);
15425     arg.succ_block = 0;
15426     arg.fail_block = 0;
15427     arg.num = 0;
15428     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
15429 
15430     if (arg.num == 0)
15431         return match;
15432 
15433     return
15434         block_append(
15435             newline_node(match),
15436             NEW_IF(gettable(rb_intern("$~")),
15437                 block_append(
15438                     newline_node(arg.succ_block),
15439                     newline_node(
15440                         NEW_CALL(
15441                           gettable(rb_intern("$~")),
15442                           rb_intern("begin"),
15443                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
15444                 block_append(
15445                     newline_node(arg.fail_block),
15446                     newline_node(
15447                         NEW_LIT(Qnil)))));
15448 }
15449 
15450 static VALUE
15451 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
15452 {
15453     VALUE re;
15454     VALUE err;
15455 
15456     reg_fragment_setenc(str, options);
15457     err = rb_errinfo();
15458     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
15459     if (NIL_P(re)) {
15460         ID mesg = rb_intern("mesg");
15461         VALUE m = rb_attr_get(rb_errinfo(), mesg);
15462         rb_set_errinfo(err);
15463         if (!NIL_P(err)) {
15464             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
15465         }
15466         else {
15467             compile_error(PARSER_ARG "%s", RSTRING_PTR(m));
15468         }
15469         return Qnil;
15470     }
15471     return re;
15472 }
15473 
15474 void
15475 rb_gc_mark_parser(void)
15476 {
15477 }
15478 
15479 NODE*
15480 rb_parser_append_print(VALUE vparser, NODE *node)
15481 {
15482     NODE *prelude = 0;
15483     NODE *scope = node;
15484     struct parser_params *parser;
15485 
15486     if (!node) return node;
15487 
15488     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15489 
15490     node = node->nd_body;
15491 
15492     if (nd_type(node) == NODE_PRELUDE) {
15493         prelude = node;
15494         node = node->nd_body;
15495     }
15496 
15497     node = block_append(node,
15498                         NEW_FCALL(rb_intern("print"),
15499                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
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 NODE *
15512 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
15513 {
15514     NODE *prelude = 0;
15515     NODE *scope = node;
15516     struct parser_params *parser;
15517 
15518     if (!node) return node;
15519 
15520     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15521 
15522     node = node->nd_body;
15523 
15524     if (nd_type(node) == NODE_PRELUDE) {
15525         prelude = node;
15526         node = node->nd_body;
15527     }
15528     if (split) {
15529         node = block_append(NEW_GASGN(rb_intern("$F"),
15530                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
15531                                                rb_intern("split"), 0)),
15532                             node);
15533     }
15534     if (chop) {
15535         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
15536                                      rb_intern("chop!"), 0), node);
15537     }
15538 
15539     node = NEW_OPT_N(node);
15540 
15541     if (prelude) {
15542         prelude->nd_body = node;
15543         scope->nd_body = prelude;
15544     }
15545     else {
15546         scope->nd_body = node;
15547     }
15548 
15549     return scope;
15550 }
15551 
15552 static const struct {
15553     ID token;
15554     const char *name;
15555 } op_tbl[] = {
15556     {tDOT2,     ".."},
15557     {tDOT3,     "..."},
15558     {'+',       "+(binary)"},
15559     {'-',       "-(binary)"},
15560     {tPOW,      "**"},
15561     {tUPLUS,    "+@"},
15562     {tUMINUS,   "-@"},
15563     {tCMP,      "<=>"},
15564     {tGEQ,      ">="},
15565     {tLEQ,      "<="},
15566     {tEQ,       "=="},
15567     {tEQQ,      "==="},
15568     {tNEQ,      "!="},
15569     {tMATCH,    "=~"},
15570     {tNMATCH,   "!~"},
15571     {tAREF,     "[]"},
15572     {tASET,     "[]="},
15573     {tLSHFT,    "<<"},
15574     {tRSHFT,    ">>"},
15575     {tCOLON2,   "::"},
15576 };
15577 
15578 #define op_tbl_count numberof(op_tbl)
15579 
15580 #ifndef ENABLE_SELECTOR_NAMESPACE
15581 #define ENABLE_SELECTOR_NAMESPACE 0
15582 #endif
15583 
15584 static struct symbols {
15585     ID last_id;
15586     st_table *sym_id;
15587     st_table *id_str;
15588 #if ENABLE_SELECTOR_NAMESPACE
15589     st_table *ivar2_id;
15590     st_table *id_ivar2;
15591 #endif
15592     VALUE op_sym[tLAST_TOKEN];
15593 } global_symbols = {tLAST_ID};
15594 
15595 static const struct st_hash_type symhash = {
15596     rb_str_hash_cmp,
15597     rb_str_hash,
15598 };
15599 
15600 #if ENABLE_SELECTOR_NAMESPACE
15601 struct ivar2_key {
15602     ID id;
15603     VALUE klass;
15604 };
15605 
15606 static int
15607 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
15608 {
15609     if (key1->id == key2->id && key1->klass == key2->klass) {
15610         return 0;
15611     }
15612     return 1;
15613 }
15614 
15615 static int
15616 ivar2_hash(struct ivar2_key *key)
15617 {
15618     return (key->id << 8) ^ (key->klass >> 2);
15619 }
15620 
15621 static const struct st_hash_type ivar2_hash_type = {
15622     ivar2_cmp,
15623     ivar2_hash,
15624 };
15625 #endif
15626 
15627 void
15628 Init_sym(void)
15629 {
15630     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
15631     global_symbols.id_str = st_init_numtable_with_size(1000);
15632 #if ENABLE_SELECTOR_NAMESPACE
15633     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
15634     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
15635 #endif
15636 
15637     Init_id();
15638 }
15639 
15640 void
15641 rb_gc_mark_symbols(void)
15642 {
15643     rb_mark_tbl(global_symbols.id_str);
15644     rb_gc_mark_locations(global_symbols.op_sym,
15645                          global_symbols.op_sym + tLAST_TOKEN);
15646 }
15647 #endif /* !RIPPER */
15648 
15649 static ID
15650 internal_id_gen(struct parser_params *parser)
15651 {
15652     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
15653     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
15654     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
15655 }
15656 
15657 #ifndef RIPPER
15658 static int
15659 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
15660 {
15661     int mb = 0;
15662 
15663     if (m >= e) return 0;
15664     switch (*m) {
15665       case '~': case '*': case '$': case '?': case '!': case '@':
15666       case '/': case '\\': case ';': case ',': case '.': case '=':
15667       case ':': case '<': case '>': case '\"':
15668       case '&': case '`': case '\'': case '+':
15669       case '0':
15670         ++m;
15671         break;
15672       case '-':
15673         ++m;
15674         if (m < e && is_identchar(m, e, enc)) {
15675             if (!ISASCII(*m)) mb = 1;
15676             m += rb_enc_mbclen(m, e, enc);
15677         }
15678         break;
15679       default:
15680         if (!rb_enc_isdigit(*m, enc)) return 0;
15681         do {
15682             if (!ISASCII(*m)) mb = 1;
15683             ++m;
15684         } while (m < e && rb_enc_isdigit(*m, enc));
15685     }
15686     return m == e ? mb + 1 : 0;
15687 }
15688 
15689 int
15690 rb_symname_p(const char *name)
15691 {
15692     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
15693 }
15694 
15695 int
15696 rb_enc_symname_p(const char *name, rb_encoding *enc)
15697 {
15698     return rb_enc_symname2_p(name, strlen(name), enc);
15699 }
15700 
15701 int
15702 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
15703 {
15704     const char *m = name;
15705     const char *e = m + len;
15706     int localid = FALSE;
15707 
15708     if (!m) return FALSE;
15709     switch (*m) {
15710       case '\0':
15711         return FALSE;
15712 
15713       case '$':
15714         if (is_special_global_name(++m, e, enc)) return TRUE;
15715         goto id;
15716 
15717       case '@':
15718         if (*++m == '@') ++m;
15719         goto id;
15720 
15721       case '<':
15722         switch (*++m) {
15723           case '<': ++m; break;
15724           case '=': if (*++m == '>') ++m; break;
15725           default: break;
15726         }
15727         break;
15728 
15729       case '>':
15730         switch (*++m) {
15731           case '>': case '=': ++m; break;
15732         }
15733         break;
15734 
15735       case '=':
15736         switch (*++m) {
15737           case '~': ++m; break;
15738           case '=': if (*++m == '=') ++m; break;
15739           default: return FALSE;
15740         }
15741         break;
15742 
15743       case '*':
15744         if (*++m == '*') ++m;
15745         break;
15746 
15747       case '+': case '-':
15748         if (*++m == '@') ++m;
15749         break;
15750 
15751       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
15752         ++m;
15753         break;
15754 
15755       case '[':
15756         if (*++m != ']') return FALSE;
15757         if (*++m == '=') ++m;
15758         break;
15759 
15760       case '!':
15761         switch (*++m) {
15762           case '\0': return TRUE;
15763           case '=': case '~': ++m; break;
15764           default: return FALSE;
15765         }
15766         break;
15767 
15768       default:
15769         localid = !rb_enc_isupper(*m, enc);
15770       id:
15771         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
15772             return FALSE;
15773         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
15774         if (localid) {
15775             switch (*m) {
15776               case '!': case '?': case '=': ++m;
15777             }
15778         }
15779         break;
15780     }
15781     return m == e;
15782 }
15783 
15784 static ID
15785 register_symid(ID id, const char *name, long len, rb_encoding *enc)
15786 {
15787     VALUE str = rb_enc_str_new(name, len, enc);
15788     OBJ_FREEZE(str);
15789     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
15790     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
15791     return id;
15792 }
15793 
15794 ID
15795 rb_intern3(const char *name, long len, rb_encoding *enc)
15796 {
15797     const char *m = name;
15798     const char *e = m + len;
15799     unsigned char c;
15800     VALUE str;
15801     ID id;
15802     long last;
15803     int mb;
15804     st_data_t data;
15805     struct RString fake_str;
15806     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED|FL_FREEZE;
15807     fake_str.basic.klass = rb_cString;
15808     fake_str.as.heap.len = len;
15809     fake_str.as.heap.ptr = (char *)name;
15810     fake_str.as.heap.aux.capa = len;
15811     str = (VALUE)&fake_str;
15812     rb_enc_associate(str, enc);
15813 
15814     if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
15815         rb_raise(rb_eEncodingError, "invalid encoding symbol");
15816     }
15817 
15818     if (st_lookup(global_symbols.sym_id, str, &data))
15819         return (ID)data;
15820 
15821     if (rb_cString && !rb_enc_asciicompat(enc)) {
15822         id = ID_JUNK;
15823         goto new_id;
15824     }
15825     last = len-1;
15826     id = 0;
15827     switch (*m) {
15828       case '$':
15829         id |= ID_GLOBAL;
15830         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
15831             if (!--mb) enc = rb_ascii8bit_encoding();
15832             goto new_id;
15833         }
15834         break;
15835       case '@':
15836         if (m[1] == '@') {
15837             m++;
15838             id |= ID_CLASS;
15839         }
15840         else {
15841             id |= ID_INSTANCE;
15842         }
15843         m++;
15844         break;
15845       default:
15846         c = m[0];
15847         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
15848             /* operators */
15849             int i;
15850 
15851             if (len == 1) {
15852                 id = c;
15853                 goto id_register;
15854             }
15855             for (i = 0; i < op_tbl_count; i++) {
15856                 if (*op_tbl[i].name == *m &&
15857                     strcmp(op_tbl[i].name, m) == 0) {
15858                     id = op_tbl[i].token;
15859                     goto id_register;
15860                 }
15861             }
15862         }
15863 
15864         if (m[last] == '=') {
15865             /* attribute assignment */
15866             id = rb_intern3(name, last, enc);
15867             if (id > tLAST_TOKEN && !is_attrset_id(id)) {
15868                 enc = rb_enc_get(rb_id2str(id));
15869                 id = rb_id_attrset(id);
15870                 goto id_register;
15871             }
15872             id = ID_ATTRSET;
15873         }
15874         else if (rb_enc_isupper(m[0], enc)) {
15875             id = ID_CONST;
15876         }
15877         else {
15878             id = ID_LOCAL;
15879         }
15880         break;
15881     }
15882     mb = 0;
15883     if (!rb_enc_isdigit(*m, enc)) {
15884         while (m <= name + last && is_identchar(m, e, enc)) {
15885             if (ISASCII(*m)) {
15886                 m++;
15887             }
15888             else {
15889                 mb = 1;
15890                 m += rb_enc_mbclen(m, e, enc);
15891             }
15892         }
15893     }
15894     if (m - name < len) id = ID_JUNK;
15895     if (enc != rb_usascii_encoding()) {
15896         /*
15897          * this clause makes sense only when called from other than
15898          * rb_intern_str() taking care of code-range.
15899          */
15900         if (!mb) {
15901             for (; m <= name + len; ++m) {
15902                 if (!ISASCII(*m)) goto mbstr;
15903             }
15904             enc = rb_usascii_encoding();
15905         }
15906       mbstr:;
15907     }
15908   new_id:
15909     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
15910         if (len > 20) {
15911             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
15912                      name);
15913         }
15914         else {
15915             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
15916                      (int)len, name);
15917         }
15918     }
15919     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
15920   id_register:
15921     return register_symid(id, name, len, enc);
15922 }
15923 
15924 ID
15925 rb_intern2(const char *name, long len)
15926 {
15927     return rb_intern3(name, len, rb_usascii_encoding());
15928 }
15929 
15930 #undef rb_intern
15931 ID
15932 rb_intern(const char *name)
15933 {
15934     return rb_intern2(name, strlen(name));
15935 }
15936 
15937 ID
15938 rb_intern_str(VALUE str)
15939 {
15940     rb_encoding *enc;
15941     ID id;
15942 
15943     if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
15944         enc = rb_usascii_encoding();
15945     }
15946     else {
15947         enc = rb_enc_get(str);
15948     }
15949     id = rb_intern3(RSTRING_PTR(str), RSTRING_LEN(str), enc);
15950     RB_GC_GUARD(str);
15951     return id;
15952 }
15953 
15954 VALUE
15955 rb_id2str(ID id)
15956 {
15957     st_data_t data;
15958 
15959     if (id < tLAST_TOKEN) {
15960         int i = 0;
15961 
15962         if (id < INT_MAX && rb_ispunct((int)id)) {
15963             VALUE str = global_symbols.op_sym[i = (int)id];
15964             if (!str) {
15965                 char name[2];
15966                 name[0] = (char)id;
15967                 name[1] = 0;
15968                 str = rb_usascii_str_new(name, 1);
15969                 OBJ_FREEZE(str);
15970                 global_symbols.op_sym[i] = str;
15971             }
15972             return str;
15973         }
15974         for (i = 0; i < op_tbl_count; i++) {
15975             if (op_tbl[i].token == id) {
15976                 VALUE str = global_symbols.op_sym[i];
15977                 if (!str) {
15978                     str = rb_usascii_str_new2(op_tbl[i].name);
15979                     OBJ_FREEZE(str);
15980                     global_symbols.op_sym[i] = str;
15981                 }
15982                 return str;
15983             }
15984         }
15985     }
15986 
15987     if (st_lookup(global_symbols.id_str, id, &data)) {
15988         VALUE str = (VALUE)data;
15989         if (RBASIC(str)->klass == 0)
15990             RBASIC(str)->klass = rb_cString;
15991         return str;
15992     }
15993 
15994     if (is_attrset_id(id)) {
15995         ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
15996         VALUE str;
15997 
15998         while (!(str = rb_id2str(id2))) {
15999             if (!is_local_id(id2)) return 0;
16000             id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
16001         }
16002         str = rb_str_dup(str);
16003         rb_str_cat(str, "=", 1);
16004         rb_intern_str(str);
16005         if (st_lookup(global_symbols.id_str, id, &data)) {
16006             VALUE str = (VALUE)data;
16007             if (RBASIC(str)->klass == 0)
16008                 RBASIC(str)->klass = rb_cString;
16009             return str;
16010         }
16011     }
16012     return 0;
16013 }
16014 
16015 const char *
16016 rb_id2name(ID id)
16017 {
16018     VALUE str = rb_id2str(id);
16019 
16020     if (!str) return 0;
16021     return RSTRING_PTR(str);
16022 }
16023 
16024 static int
16025 symbols_i(VALUE sym, ID value, VALUE ary)
16026 {
16027     rb_ary_push(ary, ID2SYM(value));
16028     return ST_CONTINUE;
16029 }
16030 
16031 /*
16032  *  call-seq:
16033  *     Symbol.all_symbols    => array
16034  *
16035  *  Returns an array of all the symbols currently in Ruby's symbol
16036  *  table.
16037  *
16038  *     Symbol.all_symbols.size    #=> 903
16039  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
16040  *                                     :chown, :EOFError, :$;, :String,
16041  *                                     :LOCK_SH, :"setuid?", :$<,
16042  *                                     :default_proc, :compact, :extend,
16043  *                                     :Tms, :getwd, :$=, :ThreadGroup,
16044  *                                     :wait2, :$>]
16045  */
16046 
16047 VALUE
16048 rb_sym_all_symbols(void)
16049 {
16050     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
16051 
16052     st_foreach(global_symbols.sym_id, symbols_i, ary);
16053     return ary;
16054 }
16055 
16056 int
16057 rb_is_const_id(ID id)
16058 {
16059     return is_const_id(id);
16060 }
16061 
16062 int
16063 rb_is_class_id(ID id)
16064 {
16065     return is_class_id(id);
16066 }
16067 
16068 int
16069 rb_is_instance_id(ID id)
16070 {
16071     return is_instance_id(id);
16072 }
16073 
16074 int
16075 rb_is_local_id(ID id)
16076 {
16077     return is_local_id(id);
16078 }
16079 
16080 int
16081 rb_is_junk_id(ID id)
16082 {
16083     return is_junk_id(id);
16084 }
16085 
16086 #endif /* !RIPPER */
16087 
16088 static void
16089 parser_initialize(struct parser_params *parser)
16090 {
16091     parser->eofp = Qfalse;
16092 
16093     parser->parser_lex_strterm = 0;
16094     parser->parser_cond_stack = 0;
16095     parser->parser_cmdarg_stack = 0;
16096     parser->parser_class_nest = 0;
16097     parser->parser_paren_nest = 0;
16098     parser->parser_lpar_beg = 0;
16099     parser->parser_in_single = 0;
16100     parser->parser_in_def = 0;
16101     parser->parser_in_defined = 0;
16102     parser->parser_compile_for_eval = 0;
16103     parser->parser_cur_mid = 0;
16104     parser->parser_tokenbuf = NULL;
16105     parser->parser_tokidx = 0;
16106     parser->parser_toksiz = 0;
16107     parser->parser_heredoc_end = 0;
16108     parser->parser_command_start = TRUE;
16109     parser->parser_deferred_nodes = 0;
16110     parser->parser_lex_pbeg = 0;
16111     parser->parser_lex_p = 0;
16112     parser->parser_lex_pend = 0;
16113     parser->parser_lvtbl = 0;
16114     parser->parser_ruby__end__seen = 0;
16115     parser->parser_ruby_sourcefile = 0;
16116 #ifndef RIPPER
16117     parser->is_ripper = 0;
16118     parser->parser_eval_tree_begin = 0;
16119     parser->parser_eval_tree = 0;
16120 #else
16121     parser->is_ripper = 1;
16122     parser->parser_ruby_sourcefile_string = Qnil;
16123     parser->delayed = Qnil;
16124 
16125     parser->result = Qnil;
16126     parser->parsing_thread = Qnil;
16127     parser->toplevel_p = TRUE;
16128 #endif
16129 #ifdef YYMALLOC
16130     parser->heap = NULL;
16131 #endif
16132     parser->enc = rb_usascii_encoding();
16133 }
16134 
16135 #ifdef RIPPER
16136 #define parser_mark ripper_parser_mark
16137 #define parser_free ripper_parser_free
16138 #endif
16139 
16140 static void
16141 parser_mark(void *ptr)
16142 {
16143     struct parser_params *p = (struct parser_params*)ptr;
16144 
16145     rb_gc_mark((VALUE)p->parser_lex_strterm);
16146     rb_gc_mark((VALUE)p->parser_deferred_nodes);
16147     rb_gc_mark(p->parser_lex_input);
16148     rb_gc_mark(p->parser_lex_lastline);
16149     rb_gc_mark(p->parser_lex_nextline);
16150 #ifndef RIPPER
16151     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
16152     rb_gc_mark((VALUE)p->parser_eval_tree) ;
16153     rb_gc_mark(p->debug_lines);
16154 #else
16155     rb_gc_mark(p->parser_ruby_sourcefile_string);
16156     rb_gc_mark(p->delayed);
16157     rb_gc_mark(p->value);
16158     rb_gc_mark(p->result);
16159     rb_gc_mark(p->parsing_thread);
16160 #endif
16161 #ifdef YYMALLOC
16162     rb_gc_mark((VALUE)p->heap);
16163 #endif
16164 }
16165 
16166 static void
16167 parser_free(void *ptr)
16168 {
16169     struct parser_params *p = (struct parser_params*)ptr;
16170     struct local_vars *local, *prev;
16171 
16172     if (p->parser_tokenbuf) {
16173         xfree(p->parser_tokenbuf);
16174     }
16175     for (local = p->parser_lvtbl; local; local = prev) {
16176         if (local->vars) xfree(local->vars);
16177         prev = local->prev;
16178         xfree(local);
16179     }
16180 #ifndef RIPPER
16181     xfree(p->parser_ruby_sourcefile);
16182 #endif
16183     xfree(p);
16184 }
16185 
16186 static size_t
16187 parser_memsize(const void *ptr)
16188 {
16189     struct parser_params *p = (struct parser_params*)ptr;
16190     struct local_vars *local;
16191     size_t size = sizeof(*p);
16192 
16193     if (!ptr) return 0;
16194     size += p->parser_toksiz;
16195     for (local = p->parser_lvtbl; local; local = local->prev) {
16196         size += sizeof(*local);
16197         if (local->vars) size += local->vars->capa * sizeof(ID);
16198     }
16199 #ifndef RIPPER
16200     if (p->parser_ruby_sourcefile) {
16201         size += strlen(p->parser_ruby_sourcefile) + 1;
16202     }
16203 #endif
16204     return size;
16205 }
16206 
16207 static const rb_data_type_t parser_data_type = {
16208     "parser",
16209     parser_mark,
16210     parser_free,
16211     parser_memsize,
16212 };
16213 
16214 VALUE rb_parser_get_yydebug(VALUE);
16215 VALUE rb_parser_set_yydebug(VALUE, VALUE);
16216 
16217 #ifndef RIPPER
16218 #undef rb_reserved_word
16219 
16220 const struct kwtable *
16221 rb_reserved_word(const char *str, unsigned int len)
16222 {
16223     return reserved_word(str, len);
16224 }
16225 
16226 static struct parser_params *
16227 parser_new(void)
16228 {
16229     struct parser_params *p;
16230 
16231     p = ALLOC_N(struct parser_params, 1);
16232     MEMZERO(p, struct parser_params, 1);
16233     parser_initialize(p);
16234     return p;
16235 }
16236 
16237 VALUE
16238 rb_parser_new(void)
16239 {
16240     struct parser_params *p = parser_new();
16241 
16242     return TypedData_Wrap_Struct(0, &parser_data_type, p);
16243 }
16244 
16245 /*
16246  *  call-seq:
16247  *    ripper#end_seen?   -> Boolean
16248  *
16249  *  Return true if parsed source ended by +\_\_END\_\_+.
16250  */
16251 VALUE
16252 rb_parser_end_seen_p(VALUE vparser)
16253 {
16254     struct parser_params *parser;
16255 
16256     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16257     return ruby__end__seen ? Qtrue : Qfalse;
16258 }
16259 
16260 /*
16261  *  call-seq:
16262  *    ripper#encoding   -> encoding
16263  *
16264  *  Return encoding of the source.
16265  */
16266 VALUE
16267 rb_parser_encoding(VALUE vparser)
16268 {
16269     struct parser_params *parser;
16270 
16271     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16272     return rb_enc_from_encoding(parser->enc);
16273 }
16274 
16275 /*
16276  *  call-seq:
16277  *    ripper.yydebug   -> true or false
16278  *
16279  *  Get yydebug.
16280  */
16281 VALUE
16282 rb_parser_get_yydebug(VALUE self)
16283 {
16284     struct parser_params *parser;
16285 
16286     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16287     return yydebug ? Qtrue : Qfalse;
16288 }
16289 
16290 /*
16291  *  call-seq:
16292  *    ripper.yydebug = flag
16293  *
16294  *  Set yydebug.
16295  */
16296 VALUE
16297 rb_parser_set_yydebug(VALUE self, VALUE flag)
16298 {
16299     struct parser_params *parser;
16300 
16301     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16302     yydebug = RTEST(flag);
16303     return flag;
16304 }
16305 
16306 #ifdef YYMALLOC
16307 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
16308 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
16309 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
16310                            (n)->u3.cnt = (c), (p))
16311 
16312 void *
16313 rb_parser_malloc(struct parser_params *parser, size_t size)
16314 {
16315     size_t cnt = HEAPCNT(1, size);
16316     NODE *n = NEWHEAP();
16317     void *ptr = xmalloc(size);
16318 
16319     return ADD2HEAP(n, cnt, ptr);
16320 }
16321 
16322 void *
16323 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
16324 {
16325     size_t cnt = HEAPCNT(nelem, size);
16326     NODE *n = NEWHEAP();
16327     void *ptr = xcalloc(nelem, size);
16328 
16329     return ADD2HEAP(n, cnt, ptr);
16330 }
16331 
16332 void *
16333 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
16334 {
16335     NODE *n;
16336     size_t cnt = HEAPCNT(1, size);
16337 
16338     if (ptr && (n = parser->heap) != NULL) {
16339         do {
16340             if (n->u1.node == ptr) {
16341                 n->u1.node = ptr = xrealloc(ptr, size);
16342                 if (n->u3.cnt) n->u3.cnt = cnt;
16343                 return ptr;
16344             }
16345         } while ((n = n->u2.node) != NULL);
16346     }
16347     n = NEWHEAP();
16348     ptr = xrealloc(ptr, size);
16349     return ADD2HEAP(n, cnt, ptr);
16350 }
16351 
16352 void
16353 rb_parser_free(struct parser_params *parser, void *ptr)
16354 {
16355     NODE **prev = &parser->heap, *n;
16356 
16357     while ((n = *prev) != NULL) {
16358         if (n->u1.node == ptr) {
16359             *prev = n->u2.node;
16360             rb_gc_force_recycle((VALUE)n);
16361             break;
16362         }
16363         prev = &n->u2.node;
16364     }
16365     xfree(ptr);
16366 }
16367 #endif
16368 #endif
16369 
16370 #ifdef RIPPER
16371 #ifdef RIPPER_DEBUG
16372 extern int rb_is_pointer_to_heap(VALUE);
16373 
16374 /* :nodoc: */
16375 static VALUE
16376 ripper_validate_object(VALUE self, VALUE x)
16377 {
16378     if (x == Qfalse) return x;
16379     if (x == Qtrue) return x;
16380     if (x == Qnil) return x;
16381     if (x == Qundef)
16382         rb_raise(rb_eArgError, "Qundef given");
16383     if (FIXNUM_P(x)) return x;
16384     if (SYMBOL_P(x)) return x;
16385     if (!rb_is_pointer_to_heap(x))
16386         rb_raise(rb_eArgError, "invalid pointer: %p", x);
16387     switch (TYPE(x)) {
16388       case T_STRING:
16389       case T_OBJECT:
16390       case T_ARRAY:
16391       case T_BIGNUM:
16392       case T_FLOAT:
16393         return x;
16394       case T_NODE:
16395         if (nd_type(x) != NODE_LASGN) {
16396             rb_raise(rb_eArgError, "NODE given: %p", x);
16397         }
16398         return ((NODE *)x)->nd_rval;
16399       default:
16400         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
16401                  x, rb_obj_classname(x));
16402     }
16403     return x;
16404 }
16405 #endif
16406 
16407 #define validate(x) (x = get_value(x))
16408 
16409 static VALUE
16410 ripper_dispatch0(struct parser_params *parser, ID mid)
16411 {
16412     return rb_funcall(parser->value, mid, 0);
16413 }
16414 
16415 static VALUE
16416 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
16417 {
16418     validate(a);
16419     return rb_funcall(parser->value, mid, 1, a);
16420 }
16421 
16422 static VALUE
16423 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
16424 {
16425     validate(a);
16426     validate(b);
16427     return rb_funcall(parser->value, mid, 2, a, b);
16428 }
16429 
16430 static VALUE
16431 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
16432 {
16433     validate(a);
16434     validate(b);
16435     validate(c);
16436     return rb_funcall(parser->value, mid, 3, a, b, c);
16437 }
16438 
16439 static VALUE
16440 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
16441 {
16442     validate(a);
16443     validate(b);
16444     validate(c);
16445     validate(d);
16446     return rb_funcall(parser->value, mid, 4, a, b, c, d);
16447 }
16448 
16449 static VALUE
16450 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
16451 {
16452     validate(a);
16453     validate(b);
16454     validate(c);
16455     validate(d);
16456     validate(e);
16457     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
16458 }
16459 
16460 static const struct kw_assoc {
16461     ID id;
16462     const char *name;
16463 } keyword_to_name[] = {
16464     {keyword_class,     "class"},
16465     {keyword_module,    "module"},
16466     {keyword_def,       "def"},
16467     {keyword_undef,     "undef"},
16468     {keyword_begin,     "begin"},
16469     {keyword_rescue,    "rescue"},
16470     {keyword_ensure,    "ensure"},
16471     {keyword_end,       "end"},
16472     {keyword_if,        "if"},
16473     {keyword_unless,    "unless"},
16474     {keyword_then,      "then"},
16475     {keyword_elsif,     "elsif"},
16476     {keyword_else,      "else"},
16477     {keyword_case,      "case"},
16478     {keyword_when,      "when"},
16479     {keyword_while,     "while"},
16480     {keyword_until,     "until"},
16481     {keyword_for,       "for"},
16482     {keyword_break,     "break"},
16483     {keyword_next,      "next"},
16484     {keyword_redo,      "redo"},
16485     {keyword_retry,     "retry"},
16486     {keyword_in,        "in"},
16487     {keyword_do,        "do"},
16488     {keyword_do_cond,   "do"},
16489     {keyword_do_block,  "do"},
16490     {keyword_return,    "return"},
16491     {keyword_yield,     "yield"},
16492     {keyword_super,     "super"},
16493     {keyword_self,      "self"},
16494     {keyword_nil,       "nil"},
16495     {keyword_true,      "true"},
16496     {keyword_false,     "false"},
16497     {keyword_and,       "and"},
16498     {keyword_or,        "or"},
16499     {keyword_not,       "not"},
16500     {modifier_if,       "if"},
16501     {modifier_unless,   "unless"},
16502     {modifier_while,    "while"},
16503     {modifier_until,    "until"},
16504     {modifier_rescue,   "rescue"},
16505     {keyword_alias,     "alias"},
16506     {keyword_defined,   "defined?"},
16507     {keyword_BEGIN,     "BEGIN"},
16508     {keyword_END,       "END"},
16509     {keyword__LINE__,   "__LINE__"},
16510     {keyword__FILE__,   "__FILE__"},
16511     {keyword__ENCODING__, "__ENCODING__"},
16512     {0, NULL}
16513 };
16514 
16515 static const char*
16516 keyword_id_to_str(ID id)
16517 {
16518     const struct kw_assoc *a;
16519 
16520     for (a = keyword_to_name; a->id; a++) {
16521         if (a->id == id)
16522             return a->name;
16523     }
16524     return NULL;
16525 }
16526 
16527 #undef ripper_id2sym
16528 static VALUE
16529 ripper_id2sym(ID id)
16530 {
16531     const char *name;
16532     char buf[8];
16533 
16534     if (id <= 256) {
16535         buf[0] = (char)id;
16536         buf[1] = '\0';
16537         return ID2SYM(rb_intern2(buf, 1));
16538     }
16539     if ((name = keyword_id_to_str(id))) {
16540         return ID2SYM(rb_intern(name));
16541     }
16542     switch (id) {
16543       case tOROP:
16544         name = "||";
16545         break;
16546       case tANDOP:
16547         name = "&&";
16548         break;
16549       default:
16550         name = rb_id2name(id);
16551         if (!name) {
16552             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
16553         }
16554         return ID2SYM(id);
16555     }
16556     return ID2SYM(rb_intern(name));
16557 }
16558 
16559 static ID
16560 ripper_get_id(VALUE v)
16561 {
16562     NODE *nd;
16563     if (!RB_TYPE_P(v, T_NODE)) return 0;
16564     nd = (NODE *)v;
16565     if (nd_type(nd) != NODE_LASGN) return 0;
16566     return nd->nd_vid;
16567 }
16568 
16569 static VALUE
16570 ripper_get_value(VALUE v)
16571 {
16572     NODE *nd;
16573     if (v == Qundef) return Qnil;
16574     if (!RB_TYPE_P(v, T_NODE)) return v;
16575     nd = (NODE *)v;
16576     if (nd_type(nd) != NODE_LASGN) return Qnil;
16577     return nd->nd_rval;
16578 }
16579 
16580 static void
16581 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
16582 {
16583     VALUE str;
16584     va_list args;
16585 
16586     va_start(args, fmt);
16587     str = rb_vsprintf(fmt, args);
16588     va_end(args);
16589     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
16590 }
16591 
16592 static void
16593 ripper_warn0(struct parser_params *parser, const char *fmt)
16594 {
16595     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
16596 }
16597 
16598 static void
16599 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
16600 {
16601     rb_funcall(parser->value, rb_intern("warn"), 2,
16602                STR_NEW2(fmt), INT2NUM(a));
16603 }
16604 
16605 #if 0
16606 static void
16607 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
16608 {
16609     rb_funcall(parser->value, rb_intern("warn"), 2,
16610                STR_NEW2(fmt), STR_NEW2(str));
16611 }
16612 #endif
16613 
16614 static void
16615 ripper_warning0(struct parser_params *parser, const char *fmt)
16616 {
16617     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
16618 }
16619 
16620 static void
16621 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
16622 {
16623     rb_funcall(parser->value, rb_intern("warning"), 2,
16624                STR_NEW2(fmt), STR_NEW2(str));
16625 }
16626 
16627 static VALUE
16628 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
16629 {
16630     return rb_funcall(src, ripper_id_gets, 0);
16631 }
16632 
16633 static VALUE
16634 ripper_s_allocate(VALUE klass)
16635 {
16636     struct parser_params *p;
16637     VALUE self;
16638 
16639     p = ALLOC_N(struct parser_params, 1);
16640     MEMZERO(p, struct parser_params, 1);
16641     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
16642     p->value = self;
16643     return self;
16644 }
16645 
16646 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
16647 
16648 /*
16649  *  call-seq:
16650  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
16651  *
16652  *  Create a new Ripper object.
16653  *  _src_ must be a String, an IO, or an Object which has #gets method.
16654  *
16655  *  This method does not starts parsing.
16656  *  See also Ripper#parse and Ripper.parse.
16657  */
16658 static VALUE
16659 ripper_initialize(int argc, VALUE *argv, VALUE self)
16660 {
16661     struct parser_params *parser;
16662     VALUE src, fname, lineno;
16663 
16664     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16665     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
16666     if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
16667         parser->parser_lex_gets = ripper_lex_get_generic;
16668     }
16669     else {
16670         StringValue(src);
16671         parser->parser_lex_gets = lex_get_str;
16672     }
16673     parser->parser_lex_input = src;
16674     parser->eofp = Qfalse;
16675     if (NIL_P(fname)) {
16676         fname = STR_NEW2("(ripper)");
16677     }
16678     else {
16679         StringValue(fname);
16680     }
16681     parser_initialize(parser);
16682 
16683     parser->parser_ruby_sourcefile_string = fname;
16684     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
16685     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
16686 
16687     return Qnil;
16688 }
16689 
16690 extern VALUE rb_thread_pass(void);
16691 
16692 struct ripper_args {
16693     struct parser_params *parser;
16694     int argc;
16695     VALUE *argv;
16696 };
16697 
16698 static VALUE
16699 ripper_parse0(VALUE parser_v)
16700 {
16701     struct parser_params *parser;
16702 
16703     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16704     parser_prepare(parser);
16705     ripper_yyparse((void*)parser);
16706     return parser->result;
16707 }
16708 
16709 static VALUE
16710 ripper_ensure(VALUE parser_v)
16711 {
16712     struct parser_params *parser;
16713 
16714     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16715     parser->parsing_thread = Qnil;
16716     return Qnil;
16717 }
16718 
16719 /*
16720  *  call-seq:
16721  *    ripper#parse
16722  *
16723  *  Start parsing and returns the value of the root action.
16724  */
16725 static VALUE
16726 ripper_parse(VALUE self)
16727 {
16728     struct parser_params *parser;
16729 
16730     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16731     if (!ripper_initialized_p(parser)) {
16732         rb_raise(rb_eArgError, "method called for uninitialized object");
16733     }
16734     if (!NIL_P(parser->parsing_thread)) {
16735         if (parser->parsing_thread == rb_thread_current())
16736             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
16737         else
16738             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
16739     }
16740     parser->parsing_thread = rb_thread_current();
16741     rb_ensure(ripper_parse0, self, ripper_ensure, self);
16742 
16743     return parser->result;
16744 }
16745 
16746 /*
16747  *  call-seq:
16748  *    ripper#column   -> Integer
16749  *
16750  *  Return column number of current parsing line.
16751  *  This number starts from 0.
16752  */
16753 static VALUE
16754 ripper_column(VALUE self)
16755 {
16756     struct parser_params *parser;
16757     long col;
16758 
16759     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16760     if (!ripper_initialized_p(parser)) {
16761         rb_raise(rb_eArgError, "method called for uninitialized object");
16762     }
16763     if (NIL_P(parser->parsing_thread)) return Qnil;
16764     col = parser->tokp - parser->parser_lex_pbeg;
16765     return LONG2NUM(col);
16766 }
16767 
16768 /*
16769  *  call-seq:
16770  *    ripper#filename   -> String
16771  *
16772  *  Return current parsing filename.
16773  */
16774 static VALUE
16775 ripper_filename(VALUE self)
16776 {
16777     struct parser_params *parser;
16778 
16779     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16780     if (!ripper_initialized_p(parser)) {
16781         rb_raise(rb_eArgError, "method called for uninitialized object");
16782     }
16783     return parser->parser_ruby_sourcefile_string;
16784 }
16785 
16786 /*
16787  *  call-seq:
16788  *    ripper#lineno   -> Integer
16789  *
16790  *  Return line number of current parsing line.
16791  *  This number starts from 1.
16792  */
16793 static VALUE
16794 ripper_lineno(VALUE self)
16795 {
16796     struct parser_params *parser;
16797 
16798     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16799     if (!ripper_initialized_p(parser)) {
16800         rb_raise(rb_eArgError, "method called for uninitialized object");
16801     }
16802     if (NIL_P(parser->parsing_thread)) return Qnil;
16803     return INT2NUM(parser->parser_ruby_sourceline);
16804 }
16805 
16806 #ifdef RIPPER_DEBUG
16807 /* :nodoc: */
16808 static VALUE
16809 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
16810 {
16811     StringValue(msg);
16812     if (obj == Qundef) {
16813         rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
16814     }
16815     return Qnil;
16816 }
16817 
16818 /* :nodoc: */
16819 static VALUE
16820 ripper_value(VALUE self, VALUE obj)
16821 {
16822     return ULONG2NUM(obj);
16823 }
16824 #endif
16825 
16826 void
16827 Init_ripper(void)
16828 {
16829     VALUE Ripper;
16830 
16831     Ripper = rb_define_class("Ripper", rb_cObject);
16832     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
16833     rb_define_alloc_func(Ripper, ripper_s_allocate);
16834     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
16835     rb_define_method(Ripper, "parse", ripper_parse, 0);
16836     rb_define_method(Ripper, "column", ripper_column, 0);
16837     rb_define_method(Ripper, "filename", ripper_filename, 0);
16838     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
16839     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
16840     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
16841     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
16842     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
16843 #ifdef RIPPER_DEBUG
16844     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
16845     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
16846     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
16847 #endif
16848 
16849     ripper_id_gets = rb_intern("gets");
16850     ripper_init_eventids1(Ripper);
16851     ripper_init_eventids2(Ripper);
16852     /* ensure existing in symbol table */
16853     rb_intern("||");
16854     rb_intern("&&");
16855 }
16856 #endif /* RIPPER */
16857 
16858 

Generated on Sat Jul 7 2012 15:29:13 for Ruby by  doxygen 1.7.1