Ruby  2.0.0p247(2013-06-27revision41674)
ext/ripper/ripper.c
Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.3.  */
00002 
00003 /* Skeleton implementation for Bison's Yacc-like parsers in C
00004 
00005    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
00006    Free Software Foundation, Inc.
00007 
00008    This program is free software; you can redistribute it and/or modify
00009    it under the terms of the GNU General Public License as published by
00010    the Free Software Foundation; either version 2, or (at your option)
00011    any later version.
00012 
00013    This program is distributed in the hope that it will be useful,
00014    but WITHOUT ANY WARRANTY; without even the implied warranty of
00015    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016    GNU General Public License for more details.
00017 
00018    You should have received a copy of the GNU General Public License
00019    along with this program; if not, write to the Free Software
00020    Foundation, Inc., 51 Franklin Street, Fifth Floor,
00021    Boston, MA 02110-1301, USA.  */
00022 
00023 /* As a special exception, you may create a larger work that contains
00024    part or all of the Bison parser skeleton and distribute that work
00025    under terms of your choice, so long as that work isn't itself a
00026    parser generator using the skeleton or a modified version thereof
00027    as a parser skeleton.  Alternatively, if you modify or redistribute
00028    the parser skeleton itself, you may (at your option) remove this
00029    special exception, which will cause the skeleton and the resulting
00030    Bison output files to be licensed under the GNU General Public
00031    License without this special exception.
00032 
00033    This special exception was added by the Free Software Foundation in
00034    version 2.2 of Bison.  */
00035 
00036 /* C LALR(1) parser skeleton written by Richard Stallman, by
00037    simplifying the original so-called "semantic" parser.  */
00038 
00039 /* All symbols defined below should begin with yy or YY, to avoid
00040    infringing on user name space.  This should be done even for local
00041    variables, as they might otherwise be expanded by user macros.
00042    There are some unavoidable exceptions within include files to
00043    define necessary library symbols; they are noted "INFRINGES ON
00044    USER NAME SPACE" below.  */
00045 
00046 /* Identify Bison output.  */
00047 #define YYBISON 1
00048 
00049 /* Bison version.  */
00050 #define YYBISON_VERSION "2.3"
00051 
00052 /* Skeleton name.  */
00053 #define YYSKELETON_NAME "yacc.c"
00054 
00055 /* Pure parsers.  */
00056 #define YYPURE 1
00057 
00058 /* Using locations.  */
00059 #define YYLSP_NEEDED 0
00060 
00061 
00062 
00063 /* Tokens.  */
00064 #ifndef YYTOKENTYPE
00065 # define YYTOKENTYPE
00066    /* Put the tokens into the symbol table, so that GDB and other debuggers
00067       know about them.  */
00068    enum yytokentype {
00069      END_OF_INPUT = 0,
00070      keyword_class = 258,
00071      keyword_module = 259,
00072      keyword_def = 260,
00073      keyword_undef = 261,
00074      keyword_begin = 262,
00075      keyword_rescue = 263,
00076      keyword_ensure = 264,
00077      keyword_end = 265,
00078      keyword_if = 266,
00079      keyword_unless = 267,
00080      keyword_then = 268,
00081      keyword_elsif = 269,
00082      keyword_else = 270,
00083      keyword_case = 271,
00084      keyword_when = 272,
00085      keyword_while = 273,
00086      keyword_until = 274,
00087      keyword_for = 275,
00088      keyword_break = 276,
00089      keyword_next = 277,
00090      keyword_redo = 278,
00091      keyword_retry = 279,
00092      keyword_in = 280,
00093      keyword_do = 281,
00094      keyword_do_cond = 282,
00095      keyword_do_block = 283,
00096      keyword_do_LAMBDA = 284,
00097      keyword_return = 285,
00098      keyword_yield = 286,
00099      keyword_super = 287,
00100      keyword_self = 288,
00101      keyword_nil = 289,
00102      keyword_true = 290,
00103      keyword_false = 291,
00104      keyword_and = 292,
00105      keyword_or = 293,
00106      keyword_not = 294,
00107      modifier_if = 295,
00108      modifier_unless = 296,
00109      modifier_while = 297,
00110      modifier_until = 298,
00111      modifier_rescue = 299,
00112      keyword_alias = 300,
00113      keyword_defined = 301,
00114      keyword_BEGIN = 302,
00115      keyword_END = 303,
00116      keyword__LINE__ = 304,
00117      keyword__FILE__ = 305,
00118      keyword__ENCODING__ = 306,
00119      tIDENTIFIER = 307,
00120      tFID = 308,
00121      tGVAR = 309,
00122      tIVAR = 310,
00123      tCONSTANT = 311,
00124      tCVAR = 312,
00125      tLABEL = 313,
00126      tINTEGER = 314,
00127      tFLOAT = 315,
00128      tSTRING_CONTENT = 316,
00129      tCHAR = 317,
00130      tNTH_REF = 318,
00131      tBACK_REF = 319,
00132      tREGEXP_END = 320,
00133      tUPLUS = 130,
00134      tUMINUS = 131,
00135      tPOW = 132,
00136      tCMP = 134,
00137      tEQ = 139,
00138      tEQQ = 140,
00139      tNEQ = 141,
00140      tGEQ = 138,
00141      tLEQ = 137,
00142      tANDOP = 321,
00143      tOROP = 322,
00144      tMATCH = 142,
00145      tNMATCH = 143,
00146      tDOT2 = 128,
00147      tDOT3 = 129,
00148      tAREF = 144,
00149      tASET = 145,
00150      tLSHFT = 135,
00151      tRSHFT = 136,
00152      tCOLON2 = 323,
00153      tCOLON3 = 324,
00154      tOP_ASGN = 325,
00155      tASSOC = 326,
00156      tLPAREN = 327,
00157      tLPAREN_ARG = 328,
00158      tRPAREN = 329,
00159      tLBRACK = 330,
00160      tLBRACE = 331,
00161      tLBRACE_ARG = 332,
00162      tSTAR = 333,
00163      tDSTAR = 334,
00164      tAMPER = 335,
00165      tLAMBDA = 336,
00166      tSYMBEG = 337,
00167      tSTRING_BEG = 338,
00168      tXSTRING_BEG = 339,
00169      tREGEXP_BEG = 340,
00170      tWORDS_BEG = 341,
00171      tQWORDS_BEG = 342,
00172      tSYMBOLS_BEG = 343,
00173      tQSYMBOLS_BEG = 344,
00174      tSTRING_DBEG = 345,
00175      tSTRING_DEND = 346,
00176      tSTRING_DVAR = 347,
00177      tSTRING_END = 348,
00178      tLAMBEG = 349,
00179      tLOWEST = 350,
00180      tUMINUS_NUM = 351,
00181      tLAST_TOKEN = 352
00182    };
00183 #endif
00184 /* Tokens.  */
00185 #define END_OF_INPUT 0
00186 #define keyword_class 258
00187 #define keyword_module 259
00188 #define keyword_def 260
00189 #define keyword_undef 261
00190 #define keyword_begin 262
00191 #define keyword_rescue 263
00192 #define keyword_ensure 264
00193 #define keyword_end 265
00194 #define keyword_if 266
00195 #define keyword_unless 267
00196 #define keyword_then 268
00197 #define keyword_elsif 269
00198 #define keyword_else 270
00199 #define keyword_case 271
00200 #define keyword_when 272
00201 #define keyword_while 273
00202 #define keyword_until 274
00203 #define keyword_for 275
00204 #define keyword_break 276
00205 #define keyword_next 277
00206 #define keyword_redo 278
00207 #define keyword_retry 279
00208 #define keyword_in 280
00209 #define keyword_do 281
00210 #define keyword_do_cond 282
00211 #define keyword_do_block 283
00212 #define keyword_do_LAMBDA 284
00213 #define keyword_return 285
00214 #define keyword_yield 286
00215 #define keyword_super 287
00216 #define keyword_self 288
00217 #define keyword_nil 289
00218 #define keyword_true 290
00219 #define keyword_false 291
00220 #define keyword_and 292
00221 #define keyword_or 293
00222 #define keyword_not 294
00223 #define modifier_if 295
00224 #define modifier_unless 296
00225 #define modifier_while 297
00226 #define modifier_until 298
00227 #define modifier_rescue 299
00228 #define keyword_alias 300
00229 #define keyword_defined 301
00230 #define keyword_BEGIN 302
00231 #define keyword_END 303
00232 #define keyword__LINE__ 304
00233 #define keyword__FILE__ 305
00234 #define keyword__ENCODING__ 306
00235 #define tIDENTIFIER 307
00236 #define tFID 308
00237 #define tGVAR 309
00238 #define tIVAR 310
00239 #define tCONSTANT 311
00240 #define tCVAR 312
00241 #define tLABEL 313
00242 #define tINTEGER 314
00243 #define tFLOAT 315
00244 #define tSTRING_CONTENT 316
00245 #define tCHAR 317
00246 #define tNTH_REF 318
00247 #define tBACK_REF 319
00248 #define tREGEXP_END 320
00249 #define tUPLUS 130
00250 #define tUMINUS 131
00251 #define tPOW 132
00252 #define tCMP 134
00253 #define tEQ 139
00254 #define tEQQ 140
00255 #define tNEQ 141
00256 #define tGEQ 138
00257 #define tLEQ 137
00258 #define tANDOP 321
00259 #define tOROP 322
00260 #define tMATCH 142
00261 #define tNMATCH 143
00262 #define tDOT2 128
00263 #define tDOT3 129
00264 #define tAREF 144
00265 #define tASET 145
00266 #define tLSHFT 135
00267 #define tRSHFT 136
00268 #define tCOLON2 323
00269 #define tCOLON3 324
00270 #define tOP_ASGN 325
00271 #define tASSOC 326
00272 #define tLPAREN 327
00273 #define tLPAREN_ARG 328
00274 #define tRPAREN 329
00275 #define tLBRACK 330
00276 #define tLBRACE 331
00277 #define tLBRACE_ARG 332
00278 #define tSTAR 333
00279 #define tDSTAR 334
00280 #define tAMPER 335
00281 #define tLAMBDA 336
00282 #define tSYMBEG 337
00283 #define tSTRING_BEG 338
00284 #define tXSTRING_BEG 339
00285 #define tREGEXP_BEG 340
00286 #define tWORDS_BEG 341
00287 #define tQWORDS_BEG 342
00288 #define tSYMBOLS_BEG 343
00289 #define tQSYMBOLS_BEG 344
00290 #define tSTRING_DBEG 345
00291 #define tSTRING_DEND 346
00292 #define tSTRING_DVAR 347
00293 #define tSTRING_END 348
00294 #define tLAMBEG 349
00295 #define tLOWEST 350
00296 #define tUMINUS_NUM 351
00297 #define tLAST_TOKEN 352
00298 
00299 
00300 
00301 
00302 /* Copy the first part of user declarations.  */
00303 #line 12 "ripper.y"
00304 
00305 
00306 #ifndef PARSER_DEBUG
00307 #define PARSER_DEBUG 0
00308 #endif
00309 #define YYDEBUG 1
00310 #define YYERROR_VERBOSE 1
00311 #define YYSTACK_USE_ALLOCA 0
00312 
00313 #include "ruby/ruby.h"
00314 #include "ruby/st.h"
00315 #include "ruby/encoding.h"
00316 #include "internal.h"
00317 #include "node.h"
00318 #include "parse.h"
00319 #include "id.h"
00320 #include "regenc.h"
00321 #include <stdio.h>
00322 #include <errno.h>
00323 #include <ctype.h>
00324 #include "probes.h"
00325 
00326 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
00327 
00328 #define YYMALLOC(size)          rb_parser_malloc(parser, (size))
00329 #define YYREALLOC(ptr, size)    rb_parser_realloc(parser, (ptr), (size))
00330 #define YYCALLOC(nelem, size)   rb_parser_calloc(parser, (nelem), (size))
00331 #define YYFREE(ptr)             rb_parser_free(parser, (ptr))
00332 #define malloc  YYMALLOC
00333 #define realloc YYREALLOC
00334 #define calloc  YYCALLOC
00335 #define free    YYFREE
00336 
00337 #ifndef RIPPER
00338 static ID register_symid(ID, const char *, long, rb_encoding *);
00339 static ID register_symid_str(ID, VALUE);
00340 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
00341 #include "id.c"
00342 #endif
00343 
00344 #define is_notop_id(id) ((id)>tLAST_OP_ID)
00345 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
00346 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
00347 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
00348 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
00349 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
00350 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
00351 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
00352 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
00353 
00354 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
00355         (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
00356          ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
00357          ((id)&ID_SCOPE_MASK) == ID_CLASS))
00358 
00359 enum lex_state_bits {
00360     EXPR_BEG_bit,               /* ignore newline, +/- is a sign. */
00361     EXPR_END_bit,               /* newline significant, +/- is an operator. */
00362     EXPR_ENDARG_bit,            /* ditto, and unbound braces. */
00363     EXPR_ENDFN_bit,             /* ditto, and unbound braces. */
00364     EXPR_ARG_bit,               /* newline significant, +/- is an operator. */
00365     EXPR_CMDARG_bit,            /* newline significant, +/- is an operator. */
00366     EXPR_MID_bit,               /* newline significant, +/- is an operator. */
00367     EXPR_FNAME_bit,             /* ignore newline, no reserved words. */
00368     EXPR_DOT_bit,               /* right after `.' or `::', no reserved words. */
00369     EXPR_CLASS_bit,             /* immediate after `class', no here document. */
00370     EXPR_VALUE_bit,             /* alike EXPR_BEG but label is disallowed. */
00371     EXPR_MAX_STATE
00372 };
00373 /* examine combinations */
00374 enum lex_state_e {
00375 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
00376     DEF_EXPR(BEG),
00377     DEF_EXPR(END),
00378     DEF_EXPR(ENDARG),
00379     DEF_EXPR(ENDFN),
00380     DEF_EXPR(ARG),
00381     DEF_EXPR(CMDARG),
00382     DEF_EXPR(MID),
00383     DEF_EXPR(FNAME),
00384     DEF_EXPR(DOT),
00385     DEF_EXPR(CLASS),
00386     DEF_EXPR(VALUE),
00387     EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS),
00388     EXPR_ARG_ANY  =  (EXPR_ARG | EXPR_CMDARG),
00389     EXPR_END_ANY  =  (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
00390 };
00391 #define IS_lex_state_for(x, ls) ((x) & (ls))
00392 #define IS_lex_state(ls)        IS_lex_state_for(lex_state, (ls))
00393 
00394 #if PARSER_DEBUG
00395 static const char *lex_state_name(enum lex_state_e state);
00396 #endif
00397 
00398 typedef VALUE stack_type;
00399 
00400 # define BITSTACK_PUSH(stack, n)        ((stack) = ((stack)<<1)|((n)&1))
00401 # define BITSTACK_POP(stack)    ((stack) = (stack) >> 1)
00402 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
00403 # define BITSTACK_SET_P(stack)  ((stack)&1)
00404 
00405 #define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, (n))
00406 #define COND_POP()      BITSTACK_POP(cond_stack)
00407 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
00408 #define COND_P()        BITSTACK_SET_P(cond_stack)
00409 
00410 #define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, (n))
00411 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
00412 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
00413 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
00414 
00415 struct vtable {
00416     ID *tbl;
00417     int pos;
00418     int capa;
00419     struct vtable *prev;
00420 };
00421 
00422 struct local_vars {
00423     struct vtable *args;
00424     struct vtable *vars;
00425     struct vtable *used;
00426     struct local_vars *prev;
00427 };
00428 
00429 #define DVARS_INHERIT ((void*)1)
00430 #define DVARS_TOPSCOPE NULL
00431 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
00432 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
00433 
00434 static int
00435 vtable_size(const struct vtable *tbl)
00436 {
00437     if (POINTER_P(tbl)) {
00438         return tbl->pos;
00439     }
00440     else {
00441         return 0;
00442     }
00443 }
00444 
00445 #define VTBL_DEBUG 0
00446 
00447 static struct vtable *
00448 vtable_alloc(struct vtable *prev)
00449 {
00450     struct vtable *tbl = ALLOC(struct vtable);
00451     tbl->pos = 0;
00452     tbl->capa = 8;
00453     tbl->tbl = ALLOC_N(ID, tbl->capa);
00454     tbl->prev = prev;
00455     if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
00456     return tbl;
00457 }
00458 
00459 static void
00460 vtable_free(struct vtable *tbl)
00461 {
00462     if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
00463     if (POINTER_P(tbl)) {
00464         if (tbl->tbl) {
00465             xfree(tbl->tbl);
00466         }
00467         xfree(tbl);
00468     }
00469 }
00470 
00471 static void
00472 vtable_add(struct vtable *tbl, ID id)
00473 {
00474     if (!POINTER_P(tbl)) {
00475         rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
00476     }
00477     if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
00478 
00479     if (tbl->pos == tbl->capa) {
00480         tbl->capa = tbl->capa * 2;
00481         REALLOC_N(tbl->tbl, ID, tbl->capa);
00482     }
00483     tbl->tbl[tbl->pos++] = id;
00484 }
00485 
00486 static int
00487 vtable_included(const struct vtable * tbl, ID id)
00488 {
00489     int i;
00490 
00491     if (POINTER_P(tbl)) {
00492         for (i = 0; i < tbl->pos; i++) {
00493             if (tbl->tbl[i] == id) {
00494                 return i+1;
00495             }
00496         }
00497     }
00498     return 0;
00499 }
00500 
00501 
00502 #ifndef RIPPER
00503 typedef struct token_info {
00504     const char *token;
00505     int linenum;
00506     int column;
00507     int nonspc;
00508     struct token_info *next;
00509 } token_info;
00510 #endif
00511 
00512 /*
00513     Structure of Lexer Buffer:
00514 
00515  lex_pbeg      tokp         lex_p        lex_pend
00516     |           |              |            |
00517     |-----------+--------------+------------|
00518                 |<------------>|
00519                      token
00520 */
00521 struct parser_params {
00522     int is_ripper;
00523     NODE *heap;
00524 
00525     YYSTYPE *parser_yylval;
00526     VALUE eofp;
00527 
00528     NODE *parser_lex_strterm;
00529     enum lex_state_e parser_lex_state;
00530     stack_type parser_cond_stack;
00531     stack_type parser_cmdarg_stack;
00532     int parser_class_nest;
00533     int parser_paren_nest;
00534     int parser_lpar_beg;
00535     int parser_in_single;
00536     int parser_in_def;
00537     int parser_brace_nest;
00538     int parser_compile_for_eval;
00539     VALUE parser_cur_mid;
00540     int parser_in_defined;
00541     char *parser_tokenbuf;
00542     int parser_tokidx;
00543     int parser_toksiz;
00544     int parser_tokline;
00545     VALUE parser_lex_input;
00546     VALUE parser_lex_lastline;
00547     VALUE parser_lex_nextline;
00548     const char *parser_lex_pbeg;
00549     const char *parser_lex_p;
00550     const char *parser_lex_pend;
00551     int parser_heredoc_end;
00552     int parser_command_start;
00553     NODE *parser_deferred_nodes;
00554     long parser_lex_gets_ptr;
00555     VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
00556     struct local_vars *parser_lvtbl;
00557     int parser_ruby__end__seen;
00558     int line_count;
00559     int has_shebang;
00560     char *parser_ruby_sourcefile; /* current source file */
00561     int parser_ruby_sourceline; /* current line no. */
00562     rb_encoding *enc;
00563 
00564     int parser_yydebug;
00565 
00566 #ifndef RIPPER
00567     /* Ruby core only */
00568     NODE *parser_eval_tree_begin;
00569     NODE *parser_eval_tree;
00570     VALUE debug_lines;
00571     VALUE coverage;
00572     int nerr;
00573 
00574     int parser_token_info_enabled;
00575     token_info *parser_token_info;
00576 #else
00577     /* Ripper only */
00578     VALUE parser_ruby_sourcefile_string;
00579     const char *tokp;
00580     VALUE delayed;
00581     int delayed_line;
00582     int delayed_col;
00583 
00584     VALUE value;
00585     VALUE result;
00586     VALUE parsing_thread;
00587     int toplevel_p;
00588 #endif
00589 };
00590 
00591 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
00592 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
00593 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
00594 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
00595 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
00596 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
00597 
00598 static int parser_yyerror(struct parser_params*, const char*);
00599 #define yyerror(msg) parser_yyerror(parser, (msg))
00600 
00601 #define YYLEX_PARAM parser
00602 
00603 #define lex_strterm             (parser->parser_lex_strterm)
00604 #define lex_state               (parser->parser_lex_state)
00605 #define cond_stack              (parser->parser_cond_stack)
00606 #define cmdarg_stack            (parser->parser_cmdarg_stack)
00607 #define class_nest              (parser->parser_class_nest)
00608 #define paren_nest              (parser->parser_paren_nest)
00609 #define lpar_beg                (parser->parser_lpar_beg)
00610 #define brace_nest              (parser->parser_brace_nest)
00611 #define in_single               (parser->parser_in_single)
00612 #define in_def                  (parser->parser_in_def)
00613 #define compile_for_eval        (parser->parser_compile_for_eval)
00614 #define cur_mid                 (parser->parser_cur_mid)
00615 #define in_defined              (parser->parser_in_defined)
00616 #define tokenbuf                (parser->parser_tokenbuf)
00617 #define tokidx                  (parser->parser_tokidx)
00618 #define toksiz                  (parser->parser_toksiz)
00619 #define tokline                 (parser->parser_tokline)
00620 #define lex_input               (parser->parser_lex_input)
00621 #define lex_lastline            (parser->parser_lex_lastline)
00622 #define lex_nextline            (parser->parser_lex_nextline)
00623 #define lex_pbeg                (parser->parser_lex_pbeg)
00624 #define lex_p                   (parser->parser_lex_p)
00625 #define lex_pend                (parser->parser_lex_pend)
00626 #define heredoc_end             (parser->parser_heredoc_end)
00627 #define command_start           (parser->parser_command_start)
00628 #define deferred_nodes          (parser->parser_deferred_nodes)
00629 #define lex_gets_ptr            (parser->parser_lex_gets_ptr)
00630 #define lex_gets                (parser->parser_lex_gets)
00631 #define lvtbl                   (parser->parser_lvtbl)
00632 #define ruby__end__seen         (parser->parser_ruby__end__seen)
00633 #define ruby_sourceline         (parser->parser_ruby_sourceline)
00634 #define ruby_sourcefile         (parser->parser_ruby_sourcefile)
00635 #define current_enc             (parser->enc)
00636 #define yydebug                 (parser->parser_yydebug)
00637 #ifdef RIPPER
00638 #else
00639 #define ruby_eval_tree          (parser->parser_eval_tree)
00640 #define ruby_eval_tree_begin    (parser->parser_eval_tree_begin)
00641 #define ruby_debug_lines        (parser->debug_lines)
00642 #define ruby_coverage           (parser->coverage)
00643 #endif
00644 
00645 static int yylex(void*, void*);
00646 
00647 #ifndef RIPPER
00648 #define yyparse ruby_yyparse
00649 
00650 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
00651 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
00652 
00653 static NODE *cond_gen(struct parser_params*,NODE*);
00654 #define cond(node) cond_gen(parser, (node))
00655 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
00656 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
00657 
00658 static NODE *newline_node(NODE*);
00659 static void fixpos(NODE*,NODE*);
00660 
00661 static int value_expr_gen(struct parser_params*,NODE*);
00662 static void void_expr_gen(struct parser_params*,NODE*);
00663 static NODE *remove_begin(NODE*);
00664 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
00665 #define void_expr0(node) void_expr_gen(parser, (node))
00666 #define void_expr(node) void_expr0((node) = remove_begin(node))
00667 static void void_stmts_gen(struct parser_params*,NODE*);
00668 #define void_stmts(node) void_stmts_gen(parser, (node))
00669 static void reduce_nodes_gen(struct parser_params*,NODE**);
00670 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
00671 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
00672 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
00673 
00674 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
00675 #define block_append(h,t) block_append_gen(parser,(h),(t))
00676 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
00677 #define list_append(l,i) list_append_gen(parser,(l),(i))
00678 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
00679 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
00680 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
00681 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
00682 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
00683 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
00684 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
00685 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
00686 static int literal_concat0(struct parser_params *, VALUE, VALUE);
00687 static NODE *new_evstr_gen(struct parser_params*,NODE*);
00688 #define new_evstr(n) new_evstr_gen(parser,(n))
00689 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
00690 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
00691 static NODE *splat_array(NODE*);
00692 
00693 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
00694 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
00695 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
00696 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
00697 
00698 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
00699 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00700 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
00701 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00702 
00703 static NODE *negate_lit(NODE*);
00704 static NODE *ret_args_gen(struct parser_params*,NODE*);
00705 #define ret_args(node) ret_args_gen(parser, (node))
00706 static NODE *arg_blk_pass(NODE*,NODE*);
00707 static NODE *new_yield_gen(struct parser_params*,NODE*);
00708 #define new_yield(node) new_yield_gen(parser, (node))
00709 static NODE *dsym_node_gen(struct parser_params*,NODE*);
00710 #define dsym_node(node) dsym_node_gen(parser, (node))
00711 
00712 static NODE *gettable_gen(struct parser_params*,ID);
00713 #define gettable(id) gettable_gen(parser,(id))
00714 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
00715 #define assignable(id,node) assignable_gen(parser, (id), (node))
00716 
00717 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
00718 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
00719 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
00720 #define attrset(node,id) attrset_gen(parser, (node), (id))
00721 
00722 static void rb_backref_error_gen(struct parser_params*,NODE*);
00723 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
00724 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
00725 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
00726 
00727 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00728 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
00729 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
00730 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
00731 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
00732 
00733 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
00734 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
00735 
00736 static ID  *local_tbl_gen(struct parser_params*);
00737 #define local_tbl() local_tbl_gen(parser)
00738 
00739 static void fixup_nodes(NODE **);
00740 
00741 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
00742 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
00743 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
00744 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
00745 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
00746 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
00747 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
00748 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
00749 
00750 #define get_id(id) (id)
00751 #define get_value(val) (val)
00752 #else
00753 #define value_expr(node) ((void)(node))
00754 #define remove_begin(node) (node)
00755 #define rb_dvar_defined(id) 0
00756 #define rb_local_defined(id) 0
00757 static ID ripper_get_id(VALUE);
00758 #define get_id(id) ripper_get_id(id)
00759 static VALUE ripper_get_value(VALUE);
00760 #define get_value(val) ripper_get_value(val)
00761 static VALUE assignable_gen(struct parser_params*,VALUE);
00762 #define assignable(lhs,node) assignable_gen(parser, (lhs))
00763 static int id_is_var_gen(struct parser_params *parser, ID id);
00764 #define id_is_var(id) id_is_var_gen(parser, (id))
00765 
00766 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
00767 
00768 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
00769 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
00770 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
00771 
00772 #endif /* !RIPPER */
00773 
00774 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
00775 
00776 static ID formal_argument_gen(struct parser_params*, ID);
00777 #define formal_argument(id) formal_argument_gen(parser, (id))
00778 static ID shadowing_lvar_gen(struct parser_params*,ID);
00779 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
00780 static void new_bv_gen(struct parser_params*,ID);
00781 #define new_bv(id) new_bv_gen(parser, (id))
00782 
00783 static void local_push_gen(struct parser_params*,int);
00784 #define local_push(top) local_push_gen(parser,(top))
00785 static void local_pop_gen(struct parser_params*);
00786 #define local_pop() local_pop_gen(parser)
00787 static int local_var_gen(struct parser_params*, ID);
00788 #define local_var(id) local_var_gen(parser, (id))
00789 static int arg_var_gen(struct parser_params*, ID);
00790 #define arg_var(id) arg_var_gen(parser, (id))
00791 static int  local_id_gen(struct parser_params*, ID);
00792 #define local_id(id) local_id_gen(parser, (id))
00793 static ID   internal_id_gen(struct parser_params*);
00794 #define internal_id() internal_id_gen(parser)
00795 
00796 static const struct vtable *dyna_push_gen(struct parser_params *);
00797 #define dyna_push() dyna_push_gen(parser)
00798 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
00799 #define dyna_pop(node) dyna_pop_gen(parser, (node))
00800 static int dyna_in_block_gen(struct parser_params*);
00801 #define dyna_in_block() dyna_in_block_gen(parser)
00802 #define dyna_var(id) local_var(id)
00803 static int dvar_defined_gen(struct parser_params*,ID,int);
00804 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
00805 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
00806 static int dvar_curr_gen(struct parser_params*,ID);
00807 #define dvar_curr(id) dvar_curr_gen(parser, (id))
00808 
00809 static int lvar_defined_gen(struct parser_params*, ID);
00810 #define lvar_defined(id) lvar_defined_gen(parser, (id))
00811 
00812 #define RE_OPTION_ONCE (1<<16)
00813 #define RE_OPTION_ENCODING_SHIFT 8
00814 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
00815 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
00816 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
00817 #define RE_OPTION_MASK  0xff
00818 #define RE_OPTION_ARG_ENCODING_NONE 32
00819 
00820 #define NODE_STRTERM NODE_ZARRAY        /* nothing to gc */
00821 #define NODE_HEREDOC NODE_ARRAY         /* 1, 3 to gc */
00822 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
00823 #define nd_func u1.id
00824 #if SIZEOF_SHORT == 2
00825 #define nd_term(node) ((signed short)(node)->u2.id)
00826 #else
00827 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
00828 #endif
00829 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
00830 #define nd_nest u3.cnt
00831 
00832 /****** Ripper *******/
00833 
00834 #ifdef RIPPER
00835 #define RIPPER_VERSION "0.1.0"
00836 
00837 #include "eventids1.c"
00838 #include "eventids2.c"
00839 
00840 static VALUE ripper_dispatch0(struct parser_params*,ID);
00841 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
00842 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
00843 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
00844 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
00845 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
00846 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
00847 
00848 #define dispatch0(n)            ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
00849 #define dispatch1(n,a)          ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
00850 #define dispatch2(n,a,b)        ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
00851 #define dispatch3(n,a,b,c)      ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
00852 #define dispatch4(n,a,b,c,d)    ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
00853 #define dispatch5(n,a,b,c,d,e)  ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
00854 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
00855 
00856 #define yyparse ripper_yyparse
00857 
00858 #define ripper_intern(s) ID2SYM(rb_intern(s))
00859 static VALUE ripper_id2sym(ID);
00860 #ifdef __GNUC__
00861 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
00862                            ID2SYM(id) : ripper_id2sym(id))
00863 #endif
00864 
00865 #define arg_new() dispatch0(args_new)
00866 #define arg_add(l,a) dispatch2(args_add, (l), (a))
00867 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
00868 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
00869 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
00870 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
00871 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
00872 
00873 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
00874 #define mrhs_new() dispatch0(mrhs_new)
00875 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
00876 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
00877 
00878 #define mlhs_new() dispatch0(mlhs_new)
00879 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
00880 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
00881 
00882 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
00883         dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
00884 
00885 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
00886 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
00887 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
00888 
00889 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
00890 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
00891 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
00892 
00893 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
00894 
00895 static inline VALUE
00896 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
00897 {
00898     NODE *t = (NODE *)tail;
00899     VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
00900     return params_new(f, o, r, p, k, kr, escape_Qundef(b));
00901 }
00902 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
00903 
00904 static inline VALUE
00905 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
00906 {
00907     return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
00908 }
00909 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
00910 
00911 #define FIXME 0
00912 
00913 #endif /* RIPPER */
00914 
00915 #ifndef RIPPER
00916 # define Qnone 0
00917 # define ifndef_ripper(x) (x)
00918 #else
00919 # define Qnone Qnil
00920 # define ifndef_ripper(x)
00921 #endif
00922 
00923 #ifndef RIPPER
00924 # define rb_warn0(fmt)    rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
00925 # define rb_warnI(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00926 # define rb_warnS(fmt,a)  rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00927 # define rb_warn4S(file,line,fmt,a)  rb_compile_warn((file), (line), (fmt), (a))
00928 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
00929 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
00930 #else
00931 # define rb_warn0(fmt)    ripper_warn0(parser, (fmt))
00932 # define rb_warnI(fmt,a)  ripper_warnI(parser, (fmt), (a))
00933 # define rb_warnS(fmt,a)  ripper_warnS(parser, (fmt), (a))
00934 # define rb_warn4S(file,line,fmt,a)  ripper_warnS(parser, (fmt), (a))
00935 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
00936 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
00937 static void ripper_warn0(struct parser_params*, const char*);
00938 static void ripper_warnI(struct parser_params*, const char*, int);
00939 static void ripper_warnS(struct parser_params*, const char*, const char*);
00940 static void ripper_warning0(struct parser_params*, const char*);
00941 static void ripper_warningS(struct parser_params*, const char*, const char*);
00942 #endif
00943 
00944 #ifdef RIPPER
00945 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
00946 # define rb_compile_error ripper_compile_error
00947 # define compile_error ripper_compile_error
00948 # define PARSER_ARG parser,
00949 #else
00950 # define rb_compile_error rb_compile_error_with_enc
00951 # define compile_error parser->nerr++,rb_compile_error_with_enc
00952 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
00953 #endif
00954 
00955 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
00956    for instance).  This is too low for Ruby to parse some files, such as
00957    date/format.rb, therefore bump the value up to at least Bison's default. */
00958 #ifdef OLD_YACC
00959 #ifndef YYMAXDEPTH
00960 #define YYMAXDEPTH 10000
00961 #endif
00962 #endif
00963 
00964 #ifndef RIPPER
00965 static void token_info_push(struct parser_params*, const char *token);
00966 static void token_info_pop(struct parser_params*, const char *token);
00967 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
00968 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
00969 #else
00970 #define token_info_push(token) /* nothing */
00971 #define token_info_pop(token) /* nothing */
00972 #endif
00973 
00974 
00975 /* Enabling traces.  */
00976 #ifndef YYDEBUG
00977 # define YYDEBUG 1
00978 #endif
00979 
00980 /* Enabling verbose error messages.  */
00981 #ifdef YYERROR_VERBOSE
00982 # undef YYERROR_VERBOSE
00983 # define YYERROR_VERBOSE 1
00984 #else
00985 # define YYERROR_VERBOSE 0
00986 #endif
00987 
00988 /* Enabling the token table.  */
00989 #ifndef YYTOKEN_TABLE
00990 # define YYTOKEN_TABLE 0
00991 #endif
00992 
00993 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00994 typedef union YYSTYPE
00995 #line 686 "ripper.y"
00996 {
00997     VALUE val;
00998     NODE *node;
00999     ID id;
01000     int num;
01001     const struct vtable *vars;
01002 }
01003 /* Line 187 of yacc.c.  */
01004 #line 1005 "parse.c"
01005         YYSTYPE;
01006 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
01007 # define YYSTYPE_IS_DECLARED 1
01008 # define YYSTYPE_IS_TRIVIAL 1
01009 #endif
01010 
01011 
01012 
01013 /* Copy the second part of user declarations.  */
01014 
01015 
01016 /* Line 216 of yacc.c.  */
01017 #line 1018 "parse.c"
01018 
01019 #ifdef short
01020 # undef short
01021 #endif
01022 
01023 #ifdef YYTYPE_UINT8
01024 typedef YYTYPE_UINT8 yytype_uint8;
01025 #else
01026 typedef unsigned char yytype_uint8;
01027 #endif
01028 
01029 #ifdef YYTYPE_INT8
01030 typedef YYTYPE_INT8 yytype_int8;
01031 #elif (defined __STDC__ || defined __C99__FUNC__ \
01032      || defined __cplusplus || defined _MSC_VER)
01033 typedef signed char yytype_int8;
01034 #else
01035 typedef short int yytype_int8;
01036 #endif
01037 
01038 #ifdef YYTYPE_UINT16
01039 typedef YYTYPE_UINT16 yytype_uint16;
01040 #else
01041 typedef unsigned short int yytype_uint16;
01042 #endif
01043 
01044 #ifdef YYTYPE_INT16
01045 typedef YYTYPE_INT16 yytype_int16;
01046 #else
01047 typedef short int yytype_int16;
01048 #endif
01049 
01050 #ifndef YYSIZE_T
01051 # ifdef __SIZE_TYPE__
01052 #  define YYSIZE_T __SIZE_TYPE__
01053 # elif defined size_t
01054 #  define YYSIZE_T size_t
01055 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
01056      || defined __cplusplus || defined _MSC_VER)
01057 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
01058 #  define YYSIZE_T size_t
01059 # else
01060 #  define YYSIZE_T unsigned int
01061 # endif
01062 #endif
01063 
01064 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
01065 
01066 #ifndef YY_
01067 # if YYENABLE_NLS
01068 #  if ENABLE_NLS
01069 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
01070 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
01071 #  endif
01072 # endif
01073 # ifndef YY_
01074 #  define YY_(msgid) msgid
01075 # endif
01076 #endif
01077 
01078 /* Suppress unused-variable warnings by "using" E.  */
01079 #if ! defined lint || defined __GNUC__
01080 # define YYUSE(e) ((void) (e))
01081 #else
01082 # define YYUSE(e) /* empty */
01083 #endif
01084 
01085 /* Identity function, used to suppress warnings about constant conditions.  */
01086 #ifndef lint
01087 # define YYID(n) (n)
01088 #else
01089 #if (defined __STDC__ || defined __C99__FUNC__ \
01090      || defined __cplusplus || defined _MSC_VER)
01091 static int
01092 YYID (int i)
01093 #else
01094 static int
01095 YYID (i)
01096     int i;
01097 #endif
01098 {
01099   return i;
01100 }
01101 #endif
01102 
01103 #if ! defined yyoverflow || YYERROR_VERBOSE
01104 
01105 /* The parser invokes alloca or malloc; define the necessary symbols.  */
01106 
01107 # ifdef YYSTACK_USE_ALLOCA
01108 #  if YYSTACK_USE_ALLOCA
01109 #   ifdef __GNUC__
01110 #    define YYSTACK_ALLOC __builtin_alloca
01111 #   elif defined __BUILTIN_VA_ARG_INCR
01112 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
01113 #   elif defined _AIX
01114 #    define YYSTACK_ALLOC __alloca
01115 #   elif defined _MSC_VER
01116 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
01117 #    define alloca _alloca
01118 #   else
01119 #    define YYSTACK_ALLOC alloca
01120 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
01121      || defined __cplusplus || defined _MSC_VER)
01122 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01123 #     ifndef _STDLIB_H
01124 #      define _STDLIB_H 1
01125 #     endif
01126 #    endif
01127 #   endif
01128 #  endif
01129 # endif
01130 
01131 # ifdef YYSTACK_ALLOC
01132    /* Pacify GCC's `empty if-body' warning.  */
01133 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
01134 #  ifndef YYSTACK_ALLOC_MAXIMUM
01135     /* The OS might guarantee only one guard page at the bottom of the stack,
01136        and a page size can be as small as 4096 bytes.  So we cannot safely
01137        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
01138        to allow for a few compiler-allocated temporary stack slots.  */
01139 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
01140 #  endif
01141 # else
01142 #  define YYSTACK_ALLOC YYMALLOC
01143 #  define YYSTACK_FREE YYFREE
01144 #  ifndef YYSTACK_ALLOC_MAXIMUM
01145 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
01146 #  endif
01147 #  if (defined __cplusplus && ! defined _STDLIB_H \
01148        && ! ((defined YYMALLOC || defined malloc) \
01149              && (defined YYFREE || defined free)))
01150 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01151 #   ifndef _STDLIB_H
01152 #    define _STDLIB_H 1
01153 #   endif
01154 #  endif
01155 #  ifndef YYMALLOC
01156 #   define YYMALLOC malloc
01157 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
01158      || defined __cplusplus || defined _MSC_VER)
01159 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
01160 #   endif
01161 #  endif
01162 #  ifndef YYFREE
01163 #   define YYFREE free
01164 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
01165      || defined __cplusplus || defined _MSC_VER)
01166 void free (void *); /* INFRINGES ON USER NAME SPACE */
01167 #   endif
01168 #  endif
01169 # endif
01170 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01171 
01172 
01173 #if (! defined yyoverflow \
01174      && (! defined __cplusplus \
01175          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01176 
01177 /* A type that is properly aligned for any stack member.  */
01178 union yyalloc
01179 {
01180   yytype_int16 yyss;
01181   YYSTYPE yyvs;
01182   };
01183 
01184 /* The size of the maximum gap between one aligned stack and the next.  */
01185 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01186 
01187 /* The size of an array large to enough to hold all stacks, each with
01188    N elements.  */
01189 # define YYSTACK_BYTES(N) \
01190      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01191       + YYSTACK_GAP_MAXIMUM)
01192 
01193 /* Copy COUNT objects from FROM to TO.  The source and destination do
01194    not overlap.  */
01195 # ifndef YYCOPY
01196 #  if defined __GNUC__ && 1 < __GNUC__
01197 #   define YYCOPY(To, From, Count) \
01198       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01199 #  else
01200 #   define YYCOPY(To, From, Count)              \
01201       do                                        \
01202         {                                       \
01203           YYSIZE_T yyi;                         \
01204           for (yyi = 0; yyi < (Count); yyi++)   \
01205             (To)[yyi] = (From)[yyi];            \
01206         }                                       \
01207       while (YYID (0))
01208 #  endif
01209 # endif
01210 
01211 /* Relocate STACK from its old location to the new one.  The
01212    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01213    elements in the stack, and YYPTR gives the new location of the
01214    stack.  Advance YYPTR to a properly aligned location for the next
01215    stack.  */
01216 # define YYSTACK_RELOCATE(Stack)                                        \
01217     do                                                                  \
01218       {                                                                 \
01219         YYSIZE_T yynewbytes;                                            \
01220         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
01221         Stack = &yyptr->Stack;                                          \
01222         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01223         yyptr += yynewbytes / sizeof (*yyptr);                          \
01224       }                                                                 \
01225     while (YYID (0))
01226 
01227 #endif
01228 
01229 /* YYFINAL -- State number of the termination state.  */
01230 #define YYFINAL  3
01231 /* YYLAST -- Last index in YYTABLE.  */
01232 #define YYLAST   10982
01233 
01234 /* YYNTOKENS -- Number of terminals.  */
01235 #define YYNTOKENS  142
01236 /* YYNNTS -- Number of nonterminals.  */
01237 #define YYNNTS  197
01238 /* YYNRULES -- Number of rules.  */
01239 #define YYNRULES  618
01240 /* YYNRULES -- Number of states.  */
01241 #define YYNSTATES  1055
01242 
01243 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01244 #define YYUNDEFTOK  2
01245 #define YYMAXUTOK   352
01246 
01247 #define YYTRANSLATE(YYX)                                                \
01248   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01249 
01250 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01251 static const yytype_uint8 yytranslate[] =
01252 {
01253        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01254      141,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01255        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01256        2,     2,   140,   127,     2,     2,     2,   125,   120,     2,
01257      136,   137,   123,   121,   134,   122,   133,   124,     2,     2,
01258        2,     2,     2,     2,     2,     2,     2,     2,   115,   139,
01259      117,   113,   116,   114,     2,     2,     2,     2,     2,     2,
01260        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01261        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01262        2,   132,     2,   138,   119,     2,   135,     2,     2,     2,
01263        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01264        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01265        2,     2,     2,   130,   118,   131,   128,     2,    79,    80,
01266       66,    67,    68,     2,    69,    83,    84,    74,    73,    70,
01267       71,    72,    77,    78,    81,    82,     2,     2,     2,     2,
01268        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01269        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01270        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01271        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01272        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01273        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01274        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01275        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01276        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01277        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01278        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01279        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01280       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01281       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01282       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01283       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01284       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01285       65,    75,    76,    85,    86,    87,    88,    89,    90,    91,
01286       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
01287      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
01288      112,   126,   129
01289 };
01290 
01291 #if YYDEBUG
01292 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01293    YYRHS.  */
01294 static const yytype_uint16 yyprhs[] =
01295 {
01296        0,     0,     3,     4,     7,    10,    12,    14,    18,    21,
01297       23,    24,    30,    35,    38,    40,    42,    46,    49,    51,
01298       52,    58,    59,    64,    68,    72,    76,    79,    83,    87,
01299       91,    95,    99,   104,   106,   110,   114,   121,   127,   133,
01300      139,   145,   149,   153,   157,   161,   163,   167,   171,   173,
01301      177,   181,   185,   188,   190,   192,   194,   196,   198,   203,
01302      204,   210,   212,   215,   219,   224,   230,   235,   241,   244,
01303      247,   250,   253,   256,   258,   262,   264,   268,   270,   273,
01304      277,   283,   286,   291,   294,   299,   301,   305,   307,   311,
01305      314,   318,   320,   324,   326,   328,   333,   337,   341,   345,
01306      349,   352,   354,   356,   358,   363,   367,   371,   375,   379,
01307      382,   384,   386,   388,   391,   393,   397,   399,   401,   403,
01308      405,   407,   409,   411,   413,   415,   417,   418,   423,   425,
01309      427,   429,   431,   433,   435,   437,   439,   441,   443,   445,
01310      447,   449,   451,   453,   455,   457,   459,   461,   463,   465,
01311      467,   469,   471,   473,   475,   477,   479,   481,   483,   485,
01312      487,   489,   491,   493,   495,   497,   499,   501,   503,   505,
01313      507,   509,   511,   513,   515,   517,   519,   521,   523,   525,
01314      527,   529,   531,   533,   535,   537,   539,   541,   543,   545,
01315      547,   549,   551,   553,   555,   557,   559,   561,   563,   565,
01316      569,   575,   579,   585,   592,   598,   604,   610,   616,   621,
01317      625,   629,   633,   637,   641,   645,   649,   653,   657,   662,
01318      667,   670,   673,   677,   681,   685,   689,   693,   697,   701,
01319      705,   709,   713,   717,   721,   725,   728,   731,   735,   739,
01320      743,   747,   748,   753,   760,   762,   764,   766,   769,   774,
01321      777,   781,   783,   785,   787,   789,   792,   797,   800,   802,
01322      805,   808,   813,   815,   816,   819,   822,   825,   827,   829,
01323      832,   836,   841,   845,   850,   853,   855,   857,   859,   861,
01324      863,   865,   867,   869,   871,   873,   875,   876,   881,   882,
01325      886,   887,   892,   896,   900,   903,   907,   911,   913,   918,
01326      922,   924,   925,   932,   937,   941,   944,   946,   949,   952,
01327      959,   966,   967,   968,   976,   977,   978,   986,   992,   997,
01328      998,   999,  1009,  1010,  1017,  1018,  1019,  1028,  1029,  1035,
01329     1036,  1043,  1044,  1045,  1055,  1057,  1059,  1061,  1063,  1065,
01330     1067,  1069,  1071,  1073,  1075,  1077,  1079,  1081,  1083,  1085,
01331     1087,  1089,  1091,  1094,  1096,  1098,  1100,  1106,  1108,  1111,
01332     1113,  1115,  1117,  1121,  1123,  1127,  1129,  1134,  1141,  1145,
01333     1151,  1154,  1159,  1161,  1165,  1170,  1173,  1176,  1178,  1181,
01334     1182,  1189,  1198,  1203,  1210,  1215,  1218,  1225,  1228,  1233,
01335     1240,  1243,  1248,  1251,  1256,  1258,  1260,  1262,  1266,  1268,
01336     1273,  1275,  1280,  1282,  1286,  1288,  1290,  1291,  1292,  1297,
01337     1302,  1304,  1308,  1312,  1313,  1319,  1322,  1327,  1333,  1339,
01338     1342,  1343,  1349,  1350,  1356,  1360,  1361,  1366,  1367,  1372,
01339     1375,  1377,  1382,  1383,  1389,  1390,  1396,  1402,  1404,  1406,
01340     1413,  1415,  1417,  1419,  1421,  1424,  1426,  1429,  1431,  1433,
01341     1435,  1437,  1439,  1441,  1443,  1446,  1450,  1454,  1458,  1462,
01342     1466,  1467,  1471,  1473,  1476,  1480,  1484,  1485,  1489,  1493,
01343     1497,  1501,  1505,  1506,  1510,  1511,  1515,  1516,  1519,  1520,
01344     1523,  1524,  1527,  1529,  1530,  1534,  1535,  1536,  1537,  1544,
01345     1546,  1548,  1550,  1552,  1555,  1557,  1559,  1561,  1563,  1567,
01346     1569,  1571,  1574,  1577,  1579,  1581,  1583,  1585,  1587,  1589,
01347     1591,  1593,  1595,  1597,  1599,  1601,  1603,  1605,  1607,  1609,
01348     1611,  1613,  1615,  1616,  1621,  1624,  1628,  1631,  1636,  1639,
01349     1642,  1644,  1647,  1648,  1655,  1664,  1669,  1676,  1681,  1688,
01350     1691,  1696,  1703,  1706,  1711,  1714,  1719,  1721,  1722,  1724,
01351     1726,  1728,  1730,  1732,  1734,  1736,  1740,  1742,  1746,  1749,
01352     1752,  1754,  1758,  1760,  1764,  1766,  1768,  1771,  1773,  1777,
01353     1781,  1783,  1787,  1789,  1793,  1795,  1797,  1800,  1802,  1804,
01354     1806,  1809,  1812,  1814,  1816,  1817,  1822,  1824,  1827,  1829,
01355     1833,  1837,  1840,  1843,  1845,  1847,  1849,  1851,  1853,  1855,
01356     1857,  1859,  1861,  1863,  1865,  1867,  1868,  1870,  1871,  1873,
01357     1876,  1879,  1880,  1882,  1884,  1886,  1888,  1890,  1893
01358 };
01359 
01360 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01361 static const yytype_int16 yyrhs[] =
01362 {
01363      143,     0,    -1,    -1,   144,   145,    -1,   146,   331,    -1,
01364      338,    -1,   147,    -1,   146,   337,   147,    -1,     1,   147,
01365       -1,   154,    -1,    -1,    47,   148,   130,   145,   131,    -1,
01366      150,   260,   229,   263,    -1,   151,   331,    -1,   338,    -1,
01367      152,    -1,   151,   337,   152,    -1,     1,   154,    -1,   154,
01368       -1,    -1,    47,   153,   130,   145,   131,    -1,    -1,    45,
01369      177,   155,   177,    -1,    45,    54,    54,    -1,    45,    54,
01370       64,    -1,    45,    54,    63,    -1,     6,   178,    -1,   154,
01371       40,   158,    -1,   154,    41,   158,    -1,   154,    42,   158,
01372       -1,   154,    43,   158,    -1,   154,    44,   154,    -1,    48,
01373      130,   150,   131,    -1,   156,    -1,   165,   113,   159,    -1,
01374      295,    87,   159,    -1,   214,   132,   188,   334,    87,   159,
01375       -1,   214,   133,    52,    87,   159,    -1,   214,   133,    56,
01376       87,   159,    -1,   214,    85,    56,    87,   159,    -1,   214,
01377       85,    52,    87,   159,    -1,   296,    87,   159,    -1,   172,
01378      113,   195,    -1,   165,   113,   184,    -1,   165,   113,   195,
01379       -1,   157,    -1,   172,   113,   159,    -1,   172,   113,   156,
01380       -1,   159,    -1,   157,    37,   157,    -1,   157,    38,   157,
01381       -1,    39,   332,   157,    -1,   127,   159,    -1,   182,    -1,
01382      157,    -1,   164,    -1,   160,    -1,   249,    -1,   249,   330,
01383      328,   190,    -1,    -1,    94,   162,   237,   150,   131,    -1,
01384      327,    -1,   163,   190,    -1,   163,   190,   161,    -1,   214,
01385      133,   328,   190,    -1,   214,   133,   328,   190,   161,    -1,
01386      214,    85,   328,   190,    -1,   214,    85,   328,   190,   161,
01387       -1,    32,   190,    -1,    31,   190,    -1,    30,   189,    -1,
01388       21,   189,    -1,    22,   189,    -1,   167,    -1,    89,   166,
01389      333,    -1,   167,    -1,    89,   166,   333,    -1,   169,    -1,
01390      169,   168,    -1,   169,    95,   171,    -1,   169,    95,   171,
01391      134,   170,    -1,   169,    95,    -1,   169,    95,   134,   170,
01392       -1,    95,   171,    -1,    95,   171,   134,   170,    -1,    95,
01393       -1,    95,   134,   170,    -1,   171,    -1,    89,   166,   333,
01394       -1,   168,   134,    -1,   169,   168,   134,    -1,   168,    -1,
01395      170,   134,   168,    -1,   292,    -1,   293,    -1,   214,   132,
01396      188,   334,    -1,   214,   133,    52,    -1,   214,    85,    52,
01397       -1,   214,   133,    56,    -1,   214,    85,    56,    -1,    86,
01398       56,    -1,   296,    -1,   292,    -1,   293,    -1,   214,   132,
01399      188,   334,    -1,   214,   133,    52,    -1,   214,    85,    52,
01400       -1,   214,   133,    56,    -1,   214,    85,    56,    -1,    86,
01401       56,    -1,   296,    -1,    52,    -1,    56,    -1,    86,   173,
01402       -1,   173,    -1,   214,    85,   173,    -1,    52,    -1,    56,
01403       -1,    53,    -1,   180,    -1,   181,    -1,   175,    -1,   288,
01404       -1,   176,    -1,   290,    -1,   177,    -1,    -1,   178,   134,
01405      179,   177,    -1,   118,    -1,   119,    -1,   120,    -1,    69,
01406       -1,    70,    -1,    71,    -1,    77,    -1,    78,    -1,   116,
01407       -1,    73,    -1,   117,    -1,    74,    -1,    72,    -1,    83,
01408       -1,    84,    -1,   121,    -1,   122,    -1,   123,    -1,    95,
01409       -1,   124,    -1,   125,    -1,    68,    -1,    96,    -1,   127,
01410       -1,   128,    -1,    66,    -1,    67,    -1,    81,    -1,    82,
01411       -1,   135,    -1,    49,    -1,    50,    -1,    51,    -1,    47,
01412       -1,    48,    -1,    45,    -1,    37,    -1,     7,    -1,    21,
01413       -1,    16,    -1,     3,    -1,     5,    -1,    46,    -1,    26,
01414       -1,    15,    -1,    14,    -1,    10,    -1,     9,    -1,    36,
01415       -1,    20,    -1,    25,    -1,     4,    -1,    22,    -1,    34,
01416       -1,    39,    -1,    38,    -1,    23,    -1,     8,    -1,    24,
01417       -1,    30,    -1,    33,    -1,    32,    -1,    13,    -1,    35,
01418       -1,     6,    -1,    17,    -1,    31,    -1,    11,    -1,    12,
01419       -1,    18,    -1,    19,    -1,   172,   113,   182,    -1,   172,
01420      113,   182,    44,   182,    -1,   295,    87,   182,    -1,   295,
01421       87,   182,    44,   182,    -1,   214,   132,   188,   334,    87,
01422      182,    -1,   214,   133,    52,    87,   182,    -1,   214,   133,
01423       56,    87,   182,    -1,   214,    85,    52,    87,   182,    -1,
01424      214,    85,    56,    87,   182,    -1,    86,    56,    87,   182,
01425       -1,   296,    87,   182,    -1,   182,    79,   182,    -1,   182,
01426       80,   182,    -1,   182,   121,   182,    -1,   182,   122,   182,
01427       -1,   182,   123,   182,    -1,   182,   124,   182,    -1,   182,
01428      125,   182,    -1,   182,    68,   182,    -1,   126,    59,    68,
01429      182,    -1,   126,    60,    68,   182,    -1,    66,   182,    -1,
01430       67,   182,    -1,   182,   118,   182,    -1,   182,   119,   182,
01431       -1,   182,   120,   182,    -1,   182,    69,   182,    -1,   182,
01432      116,   182,    -1,   182,    73,   182,    -1,   182,   117,   182,
01433       -1,   182,    74,   182,    -1,   182,    70,   182,    -1,   182,
01434       71,   182,    -1,   182,    72,   182,    -1,   182,    77,   182,
01435       -1,   182,    78,   182,    -1,   127,   182,    -1,   128,   182,
01436       -1,   182,    83,   182,    -1,   182,    84,   182,    -1,   182,
01437       75,   182,    -1,   182,    76,   182,    -1,    -1,    46,   332,
01438      183,   182,    -1,   182,   114,   182,   332,   115,   182,    -1,
01439      196,    -1,   182,    -1,   338,    -1,   194,   335,    -1,   194,
01440      134,   325,   335,    -1,   325,   335,    -1,   136,   188,   333,
01441       -1,   338,    -1,   186,    -1,   338,    -1,   189,    -1,   194,
01442      134,    -1,   194,   134,   325,   134,    -1,   325,   134,    -1,
01443      164,    -1,   194,   193,    -1,   325,   193,    -1,   194,   134,
01444      325,   193,    -1,   192,    -1,    -1,   191,   189,    -1,    97,
01445      184,    -1,   134,   192,    -1,   338,    -1,   184,    -1,    95,
01446      184,    -1,   194,   134,   184,    -1,   194,   134,    95,   184,
01447       -1,   194,   134,   184,    -1,   194,   134,    95,   184,    -1,
01448       95,   184,    -1,   264,    -1,   265,    -1,   268,    -1,   269,
01449       -1,   270,    -1,   275,    -1,   273,    -1,   276,    -1,   294,
01450       -1,   296,    -1,    53,    -1,    -1,   215,   197,   149,   225,
01451       -1,    -1,    90,   198,   333,    -1,    -1,    90,   157,   199,
01452      333,    -1,    89,   150,   137,    -1,   214,    85,    56,    -1,
01453       86,    56,    -1,    92,   185,   138,    -1,    93,   324,   131,
01454       -1,    30,    -1,    31,   136,   189,   333,    -1,    31,   136,
01455      333,    -1,    31,    -1,    -1,    46,   332,   136,   200,   157,
01456      333,    -1,    39,   136,   157,   333,    -1,    39,   136,   333,
01457       -1,   163,   255,    -1,   250,    -1,   250,   255,    -1,    98,
01458      242,    -1,   216,   158,   226,   150,   228,   225,    -1,   217,
01459      158,   226,   150,   229,   225,    -1,    -1,    -1,   218,   201,
01460      158,   227,   202,   150,   225,    -1,    -1,    -1,   219,   203,
01461      158,   227,   204,   150,   225,    -1,   220,   158,   331,   258,
01462      225,    -1,   220,   331,   258,   225,    -1,    -1,    -1,   221,
01463      230,    25,   205,   158,   227,   206,   150,   225,    -1,    -1,
01464      222,   174,   297,   207,   149,   225,    -1,    -1,    -1,   222,
01465       83,   157,   208,   336,   209,   149,   225,    -1,    -1,   223,
01466      174,   210,   149,   225,    -1,    -1,   224,   175,   211,   299,
01467      149,   225,    -1,    -1,    -1,   224,   322,   330,   212,   175,
01468      213,   299,   149,   225,    -1,    21,    -1,    22,    -1,    23,
01469       -1,    24,    -1,   196,    -1,     7,    -1,    11,    -1,    12,
01470       -1,    18,    -1,    19,    -1,    16,    -1,    20,    -1,     3,
01471       -1,     4,    -1,     5,    -1,    10,    -1,   336,    -1,    13,
01472       -1,   336,    13,    -1,   336,    -1,    27,    -1,   229,    -1,
01473       14,   158,   226,   150,   228,    -1,   338,    -1,    15,   150,
01474       -1,   172,    -1,   165,    -1,   304,    -1,    89,   233,   333,
01475       -1,   231,    -1,   232,   134,   231,    -1,   232,    -1,   232,
01476      134,    95,   304,    -1,   232,   134,    95,   304,   134,   232,
01477       -1,   232,   134,    95,    -1,   232,   134,    95,   134,   232,
01478       -1,    95,   304,    -1,    95,   304,   134,   232,    -1,    95,
01479       -1,    95,   134,   232,    -1,   309,   134,   312,   321,    -1,
01480      309,   321,    -1,   312,   321,    -1,   320,    -1,   134,   234,
01481       -1,    -1,   306,   134,   315,   134,   318,   235,    -1,   306,
01482      134,   315,   134,   318,   134,   306,   235,    -1,   306,   134,
01483      315,   235,    -1,   306,   134,   315,   134,   306,   235,    -1,
01484      306,   134,   318,   235,    -1,   306,   134,    -1,   306,   134,
01485      318,   134,   306,   235,    -1,   306,   235,    -1,   315,   134,
01486      318,   235,    -1,   315,   134,   318,   134,   306,   235,    -1,
01487      315,   235,    -1,   315,   134,   306,   235,    -1,   318,   235,
01488       -1,   318,   134,   306,   235,    -1,   234,    -1,   338,    -1,
01489      238,    -1,   118,   239,   118,    -1,    76,    -1,   118,   236,
01490      239,   118,    -1,   332,    -1,   332,   139,   240,   332,    -1,
01491      241,    -1,   240,   134,   241,    -1,    52,    -1,   303,    -1,
01492       -1,    -1,   243,   244,   245,   246,    -1,   136,   302,   239,
01493      137,    -1,   302,    -1,   111,   150,   131,    -1,    29,   150,
01494       10,    -1,    -1,    28,   248,   237,   150,    10,    -1,   164,
01495      247,    -1,   249,   330,   328,   187,    -1,   249,   330,   328,
01496      187,   255,    -1,   249,   330,   328,   190,   247,    -1,   163,
01497      186,    -1,    -1,   214,   133,   328,   251,   187,    -1,    -1,
01498      214,    85,   328,   252,   186,    -1,   214,    85,   329,    -1,
01499       -1,   214,   133,   253,   186,    -1,    -1,   214,    85,   254,
01500      186,    -1,    32,   186,    -1,    32,    -1,   214,   132,   188,
01501      334,    -1,    -1,   130,   256,   237,   150,   131,    -1,    -1,
01502       26,   257,   237,   150,    10,    -1,    17,   194,   226,   150,
01503      259,    -1,   229,    -1,   258,    -1,     8,   261,   262,   226,
01504      150,   260,    -1,   338,    -1,   184,    -1,   195,    -1,   338,
01505       -1,    88,   172,    -1,   338,    -1,     9,   150,    -1,   338,
01506       -1,   291,    -1,   288,    -1,   290,    -1,   266,    -1,    62,
01507       -1,   267,    -1,   266,   267,    -1,   100,   279,   110,    -1,
01508      101,   280,   110,    -1,   102,   281,    65,    -1,   103,   140,
01509      110,    -1,   103,   271,   110,    -1,    -1,   271,   272,   140,
01510       -1,   282,    -1,   272,   282,    -1,   105,   140,   110,    -1,
01511      105,   274,   110,    -1,    -1,   274,   272,   140,    -1,   104,
01512      140,   110,    -1,   104,   277,   110,    -1,   106,   140,   110,
01513       -1,   106,   278,   110,    -1,    -1,   277,    61,   140,    -1,
01514       -1,   278,    61,   140,    -1,    -1,   279,   282,    -1,    -1,
01515      280,   282,    -1,    -1,   281,   282,    -1,    61,    -1,    -1,
01516      109,   283,   287,    -1,    -1,    -1,    -1,   107,   284,   285,
01517      286,   150,   108,    -1,    54,    -1,    55,    -1,    57,    -1,
01518      296,    -1,    99,   289,    -1,   175,    -1,    55,    -1,    54,
01519       -1,    57,    -1,    99,   280,   110,    -1,    59,    -1,    60,
01520       -1,   126,    59,    -1,   126,    60,    -1,    52,    -1,    55,
01521       -1,    54,    -1,    56,    -1,    57,    -1,    34,    -1,    33,
01522       -1,    35,    -1,    36,    -1,    50,    -1,    49,    -1,    51,
01523       -1,   292,    -1,   293,    -1,   292,    -1,   293,    -1,    63,
01524       -1,    64,    -1,   336,    -1,    -1,   117,   298,   158,   336,
01525       -1,     1,   336,    -1,   136,   302,   333,    -1,   302,   336,
01526       -1,   310,   134,   312,   321,    -1,   310,   321,    -1,   312,
01527      321,    -1,   320,    -1,   134,   300,    -1,    -1,   306,   134,
01528      316,   134,   318,   301,    -1,   306,   134,   316,   134,   318,
01529      134,   306,   301,    -1,   306,   134,   316,   301,    -1,   306,
01530      134,   316,   134,   306,   301,    -1,   306,   134,   318,   301,
01531       -1,   306,   134,   318,   134,   306,   301,    -1,   306,   301,
01532       -1,   316,   134,   318,   301,    -1,   316,   134,   318,   134,
01533      306,   301,    -1,   316,   301,    -1,   316,   134,   306,   301,
01534       -1,   318,   301,    -1,   318,   134,   306,   301,    -1,   300,
01535       -1,    -1,    56,    -1,    55,    -1,    54,    -1,    57,    -1,
01536      303,    -1,    52,    -1,   304,    -1,    89,   233,   333,    -1,
01537      305,    -1,   306,   134,   305,    -1,    58,   184,    -1,    58,
01538      214,    -1,   308,    -1,   309,   134,   308,    -1,   307,    -1,
01539      310,   134,   307,    -1,    68,    -1,    96,    -1,   311,    52,
01540       -1,   311,    -1,    52,   113,   184,    -1,    52,   113,   214,
01541       -1,   314,    -1,   315,   134,   314,    -1,   313,    -1,   316,
01542      134,   313,    -1,   123,    -1,    95,    -1,   317,    52,    -1,
01543      317,    -1,   120,    -1,    97,    -1,   319,    52,    -1,   134,
01544      320,    -1,   338,    -1,   294,    -1,    -1,   136,   323,   157,
01545      333,    -1,   338,    -1,   325,   335,    -1,   326,    -1,   325,
01546      134,   326,    -1,   184,    88,   184,    -1,    58,   184,    -1,
01547       96,   184,    -1,    52,    -1,    56,    -1,    53,    -1,    52,
01548       -1,    56,    -1,    53,    -1,   180,    -1,    52,    -1,    53,
01549       -1,   180,    -1,   133,    -1,    85,    -1,    -1,   337,    -1,
01550       -1,   141,    -1,   332,   137,    -1,   332,   138,    -1,    -1,
01551      141,    -1,   134,    -1,   139,    -1,   141,    -1,   336,    -1,
01552      337,   139,    -1,    -1
01553 };
01554 
01555 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01556 static const yytype_uint16 yyrline[] =
01557 {
01558        0,   850,   850,   850,   881,   892,   901,   909,   917,   923,
01559      925,   924,   945,   978,   989,   998,  1006,  1014,  1020,  1025,
01560     1024,  1045,  1045,  1053,  1061,  1072,  1082,  1090,  1099,  1108,
01561     1121,  1134,  1143,  1155,  1156,  1166,  1171,  1192,  1197,  1202,
01562     1212,  1217,  1227,  1236,  1245,  1254,  1257,  1266,  1278,  1279,
01563     1287,  1295,  1303,  1311,  1314,  1326,  1327,  1330,  1331,  1343,
01564     1342,  1364,  1374,  1383,  1396,  1405,  1417,  1426,  1438,  1447,
01565     1456,  1464,  1472,  1482,  1483,  1493,  1494,  1504,  1512,  1520,
01566     1528,  1537,  1545,  1554,  1562,  1571,  1579,  1590,  1591,  1601,
01567     1609,  1619,  1627,  1637,  1641,  1645,  1653,  1661,  1669,  1677,
01568     1689,  1699,  1711,  1720,  1729,  1737,  1745,  1753,  1761,  1774,
01569     1787,  1798,  1806,  1809,  1817,  1825,  1835,  1836,  1837,  1838,
01570     1843,  1854,  1855,  1858,  1866,  1869,  1877,  1877,  1887,  1888,
01571     1889,  1890,  1891,  1892,  1893,  1894,  1895,  1896,  1897,  1898,
01572     1899,  1900,  1901,  1902,  1903,  1904,  1905,  1906,  1907,  1908,
01573     1909,  1910,  1911,  1912,  1913,  1914,  1915,  1916,  1919,  1919,
01574     1919,  1920,  1920,  1921,  1921,  1921,  1922,  1922,  1922,  1922,
01575     1923,  1923,  1923,  1923,  1924,  1924,  1924,  1925,  1925,  1925,
01576     1925,  1926,  1926,  1926,  1926,  1927,  1927,  1927,  1927,  1928,
01577     1928,  1928,  1928,  1929,  1929,  1929,  1929,  1930,  1930,  1933,
01578     1942,  1952,  1957,  1967,  1993,  1998,  2003,  2008,  2018,  2028,
01579     2039,  2053,  2067,  2075,  2083,  2091,  2099,  2107,  2115,  2124,
01580     2133,  2141,  2149,  2157,  2165,  2173,  2181,  2189,  2197,  2205,
01581     2213,  2221,  2229,  2237,  2248,  2256,  2264,  2272,  2280,  2288,
01582     2296,  2304,  2304,  2314,  2324,  2330,  2342,  2343,  2347,  2355,
01583     2365,  2375,  2376,  2379,  2380,  2381,  2385,  2393,  2403,  2412,
01584     2420,  2430,  2439,  2448,  2448,  2460,  2470,  2474,  2480,  2488,
01585     2496,  2510,  2526,  2540,  2555,  2565,  2566,  2567,  2568,  2569,
01586     2570,  2571,  2572,  2573,  2574,  2575,  2584,  2583,  2611,  2611,
01587     2619,  2619,  2627,  2635,  2643,  2651,  2664,  2672,  2680,  2688,
01588     2696,  2704,  2704,  2714,  2722,  2730,  2740,  2741,  2751,  2755,
01589     2767,  2779,  2779,  2779,  2790,  2790,  2790,  2801,  2812,  2821,
01590     2823,  2820,  2887,  2886,  2908,  2913,  2907,  2932,  2931,  2953,
01591     2952,  2975,  2976,  2975,  2996,  3004,  3012,  3020,  3030,  3042,
01592     3048,  3054,  3060,  3066,  3072,  3078,  3084,  3090,  3096,  3106,
01593     3112,  3117,  3118,  3125,  3130,  3133,  3134,  3147,  3148,  3158,
01594     3159,  3162,  3170,  3180,  3188,  3198,  3206,  3215,  3224,  3232,
01595     3240,  3249,  3261,  3269,  3280,  3284,  3288,  3292,  3298,  3303,
01596     3308,  3312,  3316,  3320,  3324,  3328,  3336,  3340,  3344,  3348,
01597     3352,  3356,  3360,  3364,  3368,  3374,  3375,  3381,  3390,  3399,
01598     3410,  3414,  3424,  3431,  3440,  3448,  3454,  3457,  3454,  3474,
01599     3482,  3492,  3496,  3503,  3502,  3523,  3539,  3548,  3560,  3574,
01600     3584,  3583,  3600,  3599,  3615,  3624,  3623,  3641,  3640,  3657,
01601     3665,  3673,  3688,  3687,  3707,  3706,  3727,  3739,  3740,  3743,
01602     3762,  3765,  3773,  3781,  3784,  3788,  3791,  3799,  3802,  3803,
01603     3811,  3814,  3831,  3832,  3833,  3843,  3853,  3880,  3945,  3954,
01604     3965,  3972,  3982,  3990,  4000,  4009,  4020,  4027,  4039,  4048,
01605     4058,  4067,  4078,  4085,  4096,  4103,  4118,  4125,  4136,  4143,
01606     4154,  4161,  4190,  4192,  4191,  4208,  4214,  4219,  4207,  4238,
01607     4246,  4254,  4262,  4265,  4276,  4277,  4278,  4279,  4282,  4293,
01608     4294,  4295,  4303,  4313,  4314,  4315,  4316,  4317,  4320,  4321,
01609     4322,  4323,  4324,  4325,  4326,  4329,  4342,  4352,  4360,  4370,
01610     4371,  4374,  4383,  4382,  4391,  4403,  4413,  4421,  4425,  4429,
01611     4433,  4439,  4444,  4449,  4453,  4457,  4461,  4465,  4469,  4473,
01612     4477,  4481,  4485,  4489,  4493,  4497,  4501,  4506,  4512,  4521,
01613     4530,  4539,  4550,  4551,  4558,  4567,  4586,  4593,  4606,  4618,
01614     4630,  4638,  4655,  4663,  4679,  4680,  4683,  4688,  4694,  4706,
01615     4718,  4726,  4742,  4750,  4766,  4767,  4770,  4783,  4794,  4795,
01616     4798,  4815,  4819,  4829,  4839,  4839,  4868,  4869,  4879,  4886,
01617     4896,  4904,  4912,  4924,  4925,  4926,  4929,  4930,  4931,  4932,
01618     4935,  4936,  4937,  4940,  4945,  4952,  4953,  4956,  4957,  4960,
01619     4963,  4966,  4967,  4968,  4971,  4972,  4975,  4976,  4980
01620 };
01621 #endif
01622 
01623 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
01624 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
01625    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
01626 static const char *const yytname[] =
01627 {
01628   "\"end-of-input\"", "error", "$undefined", "keyword_class",
01629   "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
01630   "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
01631   "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
01632   "keyword_case", "keyword_when", "keyword_while", "keyword_until",
01633   "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
01634   "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
01635   "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
01636   "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
01637   "keyword_true", "keyword_false", "keyword_and", "keyword_or",
01638   "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
01639   "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
01640   "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
01641   "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
01642   "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
01643   "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
01644   "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
01645   "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
01646   "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
01647   "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
01648   "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
01649   "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
01650   "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
01651   "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
01652   "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
01653   "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
01654   "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
01655   "' '", "'\\n'", "$accept", "program", "@1", "top_compstmt", "top_stmts",
01656   "top_stmt", "@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin", "@3",
01657   "stmt", "@4", "command_asgn", "expr", "expr_value", "command_call",
01658   "block_command", "cmd_brace_block", "@5", "fcall", "command", "mlhs",
01659   "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head", "mlhs_post",
01660   "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", "fitem",
01661   "undef_list", "@6", "op", "reswords", "arg", "@7", "arg_value",
01662   "aref_args", "paren_args", "opt_paren_args", "opt_call_args",
01663   "call_args", "command_args", "@8", "block_arg", "opt_block_arg", "args",
01664   "mrhs", "primary", "@9", "@10", "@11", "@12", "@13", "@14", "@15", "@16",
01665   "@17", "@18", "@19", "@20", "@21", "@22", "@23", "@24", "@25",
01666   "primary_value", "k_begin", "k_if", "k_unless", "k_while", "k_until",
01667   "k_case", "k_for", "k_class", "k_module", "k_def", "k_end", "then", "do",
01668   "if_tail", "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs",
01669   "block_args_tail", "opt_block_args_tail", "block_param",
01670   "opt_block_param", "block_param_def", "opt_bv_decl", "bv_decls", "bvar",
01671   "lambda", "@26", "@27", "f_larglist", "lambda_body", "do_block", "@28",
01672   "block_call", "method_call", "@29", "@30", "@31", "@32", "brace_block",
01673   "@33", "@34", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
01674   "opt_ensure", "literal", "strings", "string", "string1", "xstring",
01675   "regexp", "words", "word_list", "word", "symbols", "symbol_list",
01676   "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
01677   "xstring_contents", "regexp_contents", "string_content", "@35", "@36",
01678   "@37", "@38", "string_dvar", "symbol", "sym", "dsym", "numeric",
01679   "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
01680   "superclass", "@39", "f_arglist", "args_tail", "opt_args_tail", "f_args",
01681   "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw", "f_block_kw",
01682   "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest", "f_opt",
01683   "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
01684   "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
01685   "singleton", "@40", "assoc_list", "assocs", "assoc", "operation",
01686   "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
01687   "rparen", "rbracket", "trailer", "term", "terms", "none", 0
01688 };
01689 #endif
01690 
01691 # ifdef YYPRINT
01692 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
01693    token YYLEX-NUM.  */
01694 static const yytype_uint16 yytoknum[] =
01695 {
01696        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
01697      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
01698      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
01699      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
01700      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
01701      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
01702      315,   316,   317,   318,   319,   320,   130,   131,   132,   134,
01703      139,   140,   141,   138,   137,   321,   322,   142,   143,   128,
01704      129,   144,   145,   135,   136,   323,   324,   325,   326,   327,
01705      328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
01706      338,   339,   340,   341,   342,   343,   344,   345,   346,   347,
01707      348,   349,   350,    61,    63,    58,    62,    60,   124,    94,
01708       38,    43,    45,    42,    47,    37,   351,    33,   126,   352,
01709      123,   125,    91,    46,    44,    96,    40,    41,    93,    59,
01710       32,    10
01711 };
01712 # endif
01713 
01714 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
01715 static const yytype_uint16 yyr1[] =
01716 {
01717        0,   142,   144,   143,   145,   146,   146,   146,   146,   147,
01718      148,   147,   149,   150,   151,   151,   151,   151,   152,   153,
01719      152,   155,   154,   154,   154,   154,   154,   154,   154,   154,
01720      154,   154,   154,   154,   154,   154,   154,   154,   154,   154,
01721      154,   154,   154,   154,   154,   154,   156,   156,   157,   157,
01722      157,   157,   157,   157,   158,   159,   159,   160,   160,   162,
01723      161,   163,   164,   164,   164,   164,   164,   164,   164,   164,
01724      164,   164,   164,   165,   165,   166,   166,   167,   167,   167,
01725      167,   167,   167,   167,   167,   167,   167,   168,   168,   169,
01726      169,   170,   170,   171,   171,   171,   171,   171,   171,   171,
01727      171,   171,   172,   172,   172,   172,   172,   172,   172,   172,
01728      172,   173,   173,   174,   174,   174,   175,   175,   175,   175,
01729      175,   176,   176,   177,   177,   178,   179,   178,   180,   180,
01730      180,   180,   180,   180,   180,   180,   180,   180,   180,   180,
01731      180,   180,   180,   180,   180,   180,   180,   180,   180,   180,
01732      180,   180,   180,   180,   180,   180,   180,   180,   181,   181,
01733      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01734      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01735      181,   181,   181,   181,   181,   181,   181,   181,   181,   181,
01736      181,   181,   181,   181,   181,   181,   181,   181,   181,   182,
01737      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01738      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01739      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01740      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
01741      182,   183,   182,   182,   182,   184,   185,   185,   185,   185,
01742      186,   187,   187,   188,   188,   188,   188,   188,   189,   189,
01743      189,   189,   189,   191,   190,   192,   193,   193,   194,   194,
01744      194,   194,   195,   195,   195,   196,   196,   196,   196,   196,
01745      196,   196,   196,   196,   196,   196,   197,   196,   198,   196,
01746      199,   196,   196,   196,   196,   196,   196,   196,   196,   196,
01747      196,   200,   196,   196,   196,   196,   196,   196,   196,   196,
01748      196,   201,   202,   196,   203,   204,   196,   196,   196,   205,
01749      206,   196,   207,   196,   208,   209,   196,   210,   196,   211,
01750      196,   212,   213,   196,   196,   196,   196,   196,   214,   215,
01751      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
01752      226,   226,   226,   227,   227,   228,   228,   229,   229,   230,
01753      230,   231,   231,   232,   232,   233,   233,   233,   233,   233,
01754      233,   233,   233,   233,   234,   234,   234,   234,   235,   235,
01755      236,   236,   236,   236,   236,   236,   236,   236,   236,   236,
01756      236,   236,   236,   236,   236,   237,   237,   238,   238,   238,
01757      239,   239,   240,   240,   241,   241,   243,   244,   242,   245,
01758      245,   246,   246,   248,   247,   249,   249,   249,   249,   250,
01759      251,   250,   252,   250,   250,   253,   250,   254,   250,   250,
01760      250,   250,   256,   255,   257,   255,   258,   259,   259,   260,
01761      260,   261,   261,   261,   262,   262,   263,   263,   264,   264,
01762      264,   265,   266,   266,   266,   267,   268,   269,   270,   270,
01763      271,   271,   272,   272,   273,   273,   274,   274,   275,   275,
01764      276,   276,   277,   277,   278,   278,   279,   279,   280,   280,
01765      281,   281,   282,   283,   282,   284,   285,   286,   282,   287,
01766      287,   287,   287,   288,   289,   289,   289,   289,   290,   291,
01767      291,   291,   291,   292,   292,   292,   292,   292,   293,   293,
01768      293,   293,   293,   293,   293,   294,   294,   295,   295,   296,
01769      296,   297,   298,   297,   297,   299,   299,   300,   300,   300,
01770      300,   301,   301,   302,   302,   302,   302,   302,   302,   302,
01771      302,   302,   302,   302,   302,   302,   302,   302,   303,   303,
01772      303,   303,   304,   304,   305,   305,   306,   306,   307,   308,
01773      309,   309,   310,   310,   311,   311,   312,   312,   313,   314,
01774      315,   315,   316,   316,   317,   317,   318,   318,   319,   319,
01775      320,   321,   321,   322,   323,   322,   324,   324,   325,   325,
01776      326,   326,   326,   327,   327,   327,   328,   328,   328,   328,
01777      329,   329,   329,   330,   330,   331,   331,   332,   332,   333,
01778      334,   335,   335,   335,   336,   336,   337,   337,   338
01779 };
01780 
01781 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
01782 static const yytype_uint8 yyr2[] =
01783 {
01784        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
01785        0,     5,     4,     2,     1,     1,     3,     2,     1,     0,
01786        5,     0,     4,     3,     3,     3,     2,     3,     3,     3,
01787        3,     3,     4,     1,     3,     3,     6,     5,     5,     5,
01788        5,     3,     3,     3,     3,     1,     3,     3,     1,     3,
01789        3,     3,     2,     1,     1,     1,     1,     1,     4,     0,
01790        5,     1,     2,     3,     4,     5,     4,     5,     2,     2,
01791        2,     2,     2,     1,     3,     1,     3,     1,     2,     3,
01792        5,     2,     4,     2,     4,     1,     3,     1,     3,     2,
01793        3,     1,     3,     1,     1,     4,     3,     3,     3,     3,
01794        2,     1,     1,     1,     4,     3,     3,     3,     3,     2,
01795        1,     1,     1,     2,     1,     3,     1,     1,     1,     1,
01796        1,     1,     1,     1,     1,     1,     0,     4,     1,     1,
01797        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01798        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01799        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01800        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01801        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01802        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01803        1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
01804        5,     3,     5,     6,     5,     5,     5,     5,     4,     3,
01805        3,     3,     3,     3,     3,     3,     3,     3,     4,     4,
01806        2,     2,     3,     3,     3,     3,     3,     3,     3,     3,
01807        3,     3,     3,     3,     3,     2,     2,     3,     3,     3,
01808        3,     0,     4,     6,     1,     1,     1,     2,     4,     2,
01809        3,     1,     1,     1,     1,     2,     4,     2,     1,     2,
01810        2,     4,     1,     0,     2,     2,     2,     1,     1,     2,
01811        3,     4,     3,     4,     2,     1,     1,     1,     1,     1,
01812        1,     1,     1,     1,     1,     1,     0,     4,     0,     3,
01813        0,     4,     3,     3,     2,     3,     3,     1,     4,     3,
01814        1,     0,     6,     4,     3,     2,     1,     2,     2,     6,
01815        6,     0,     0,     7,     0,     0,     7,     5,     4,     0,
01816        0,     9,     0,     6,     0,     0,     8,     0,     5,     0,
01817        6,     0,     0,     9,     1,     1,     1,     1,     1,     1,
01818        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01819        1,     1,     2,     1,     1,     1,     5,     1,     2,     1,
01820        1,     1,     3,     1,     3,     1,     4,     6,     3,     5,
01821        2,     4,     1,     3,     4,     2,     2,     1,     2,     0,
01822        6,     8,     4,     6,     4,     2,     6,     2,     4,     6,
01823        2,     4,     2,     4,     1,     1,     1,     3,     1,     4,
01824        1,     4,     1,     3,     1,     1,     0,     0,     4,     4,
01825        1,     3,     3,     0,     5,     2,     4,     5,     5,     2,
01826        0,     5,     0,     5,     3,     0,     4,     0,     4,     2,
01827        1,     4,     0,     5,     0,     5,     5,     1,     1,     6,
01828        1,     1,     1,     1,     2,     1,     2,     1,     1,     1,
01829        1,     1,     1,     1,     2,     3,     3,     3,     3,     3,
01830        0,     3,     1,     2,     3,     3,     0,     3,     3,     3,
01831        3,     3,     0,     3,     0,     3,     0,     2,     0,     2,
01832        0,     2,     1,     0,     3,     0,     0,     0,     6,     1,
01833        1,     1,     1,     2,     1,     1,     1,     1,     3,     1,
01834        1,     2,     2,     1,     1,     1,     1,     1,     1,     1,
01835        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
01836        1,     1,     0,     4,     2,     3,     2,     4,     2,     2,
01837        1,     2,     0,     6,     8,     4,     6,     4,     6,     2,
01838        4,     6,     2,     4,     2,     4,     1,     0,     1,     1,
01839        1,     1,     1,     1,     1,     3,     1,     3,     2,     2,
01840        1,     3,     1,     3,     1,     1,     2,     1,     3,     3,
01841        1,     3,     1,     3,     1,     1,     2,     1,     1,     1,
01842        2,     2,     1,     1,     0,     4,     1,     2,     1,     3,
01843        3,     2,     2,     1,     1,     1,     1,     1,     1,     1,
01844        1,     1,     1,     1,     1,     0,     1,     0,     1,     2,
01845        2,     0,     1,     1,     1,     1,     1,     2,     0
01846 };
01847 
01848 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
01849    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
01850    means the default is an error.  */
01851 static const yytype_uint16 yydefact[] =
01852 {
01853        2,     0,     0,     1,     0,   346,   347,   348,     0,   339,
01854      340,   341,   344,   342,   343,   345,   334,   335,   336,   337,
01855      297,   263,   263,   509,   508,   510,   511,   607,     0,   607,
01856       10,     0,   513,   512,   514,   593,   595,   505,   504,   594,
01857      507,   499,   500,   452,   519,   520,     0,     0,     0,     0,
01858      288,   618,   618,    85,   406,   478,   476,   478,   480,   460,
01859      472,   466,   474,     0,     0,     0,     3,   605,     6,     9,
01860       33,    45,    48,    56,   263,    55,     0,    73,     0,    77,
01861       87,     0,    53,   244,     0,   286,     0,     0,   311,   314,
01862      605,     0,     0,     0,     0,    57,   306,   275,   276,   451,
01863      453,   277,   278,   279,   281,   280,   282,   449,   450,   448,
01864      515,   516,   283,     0,   284,    61,     5,     8,   168,   179,
01865      169,   192,   165,   185,   175,   174,   195,   196,   190,   173,
01866      172,   167,   193,   197,   198,   177,   166,   180,   184,   186,
01867      178,   171,   187,   194,   189,   188,   181,   191,   176,   164,
01868      183,   182,   163,   170,   161,   162,   158,   159,   160,   116,
01869      118,   117,   153,   154,   149,   131,   132,   133,   140,   137,
01870      139,   134,   135,   155,   156,   141,   142,   146,   150,   136,
01871      138,   128,   129,   130,   143,   144,   145,   147,   148,   151,
01872      152,   157,   121,   123,   125,    26,   119,   120,   122,   124,
01873        0,     0,     0,     0,     0,     0,     0,     0,   258,     0,
01874      245,   268,    71,   262,   618,     0,   515,   516,     0,   284,
01875      618,   588,    72,    70,   607,    69,     0,   618,   429,    68,
01876      607,   608,     0,     0,    21,   241,     0,     0,   334,   335,
01877      297,   300,   430,     0,   220,     0,   221,   294,     0,    19,
01878        0,     0,   605,    15,    18,   607,    75,    14,   290,   607,
01879        0,   611,   611,   246,     0,     0,   611,   586,   607,     0,
01880        0,     0,    83,   338,     0,    93,    94,   101,   308,   407,
01881      496,   495,   497,   494,     0,   493,     0,     0,     0,     0,
01882        0,     0,     0,     0,     0,     0,     0,   501,   502,    52,
01883      235,   236,   614,   615,     4,   616,   606,     0,     0,     0,
01884        0,     0,     0,     0,   434,   432,   419,    62,   305,   413,
01885      415,     0,    89,     0,    81,    78,     0,     0,     0,     0,
01886        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01887        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
01888        0,     0,     0,   427,   618,   425,     0,    54,     0,     0,
01889        0,     0,   605,     0,   606,     0,   360,   359,     0,     0,
01890      515,   516,   284,   111,   112,     0,     0,   114,     0,     0,
01891      515,   516,   284,   327,   188,   181,   191,   176,   158,   159,
01892      160,   116,   117,   584,   329,   583,     0,   604,   603,     0,
01893      307,   454,     0,     0,   126,   591,   294,   269,   592,   265,
01894        0,     0,     0,   259,   267,   427,   618,   425,     0,     0,
01895        0,   260,   607,     0,   299,   264,   607,   254,   618,   618,
01896      253,   607,   304,    51,    23,    25,    24,     0,   301,     0,
01897        0,     0,   427,   425,     0,    17,     0,   607,   292,    13,
01898      606,    74,   607,   289,   295,   613,   612,   247,   613,   249,
01899      296,   587,     0,   100,   501,   502,    91,    86,     0,   427,
01900      618,   425,   547,   482,   485,   483,   498,   479,   455,   477,
01901      456,   457,   481,   458,   459,     0,   462,   468,     0,   469,
01902      464,   465,     0,   470,     0,   471,     0,     0,   617,     7,
01903       27,    28,    29,    30,    31,    49,    50,   618,   618,    59,
01904       63,   618,     0,    34,    43,     0,    44,   607,     0,    79,
01905       90,    47,    46,     0,   199,   268,    42,   217,   225,   230,
01906      231,   232,   227,   229,   239,   240,   233,   234,   210,   211,
01907      237,   238,   607,   226,   228,   222,   223,   224,   212,   213,
01908      214,   215,   216,   596,   598,   597,   599,     0,   263,   424,
01909      607,   596,   598,   597,   599,     0,   263,     0,   618,   351,
01910        0,   350,     0,     0,     0,     0,     0,     0,   294,   427,
01911      618,   425,   319,   324,   111,   112,   113,     0,   522,   322,
01912      521,   427,   618,   425,     0,     0,   547,   331,   596,   597,
01913      263,    35,   201,    41,   209,     0,   199,   590,     0,   270,
01914      266,   618,   596,   597,   607,   596,   597,   589,   298,   609,
01915      250,   255,   257,   303,    22,     0,   242,     0,    32,   422,
01916      420,   208,     0,    76,    16,   291,   611,     0,    84,    97,
01917       99,   607,   596,   597,   553,   550,   549,   548,   551,     0,
01918      564,     0,   575,   565,   579,   578,   574,   547,     0,   546,
01919      410,   552,   554,   556,   532,   562,   618,   567,   618,   572,
01920      532,   577,   532,     0,   530,   486,     0,   461,   463,   473,
01921      467,   475,   218,   219,   398,   607,     0,   396,   395,     0,
01922      618,     0,   274,     0,    88,    82,     0,     0,     0,     0,
01923        0,     0,   428,    66,     0,     0,   431,     0,     0,   426,
01924       64,   618,   349,   287,   618,   618,   440,   618,   352,   618,
01925      354,   312,   353,   315,     0,     0,   318,   600,   293,   607,
01926      596,   597,     0,     0,   524,     0,     0,   111,   112,   115,
01927      607,     0,   607,   547,     0,     0,     0,   252,   416,    58,
01928      251,     0,   127,   271,   261,     0,     0,   431,     0,     0,
01929      618,   607,    11,     0,   248,    92,    95,     0,   558,   553,
01930        0,   372,   363,   365,   607,   361,   607,     0,     0,   408,
01931        0,   539,     0,   528,   582,   566,     0,   529,     0,   542,
01932      576,     0,   544,   580,   487,   489,   490,   491,   484,   492,
01933      553,     0,   394,   607,     0,   379,   560,   618,   618,   570,
01934      379,   379,   377,   400,     0,     0,     0,     0,     0,   272,
01935       80,   200,     0,    40,   206,    39,   207,    67,   423,   610,
01936        0,    37,   204,    38,   205,    65,   421,   441,   442,   618,
01937      443,     0,   618,   357,     0,     0,   355,     0,     0,     0,
01938      317,     0,     0,   431,     0,   325,     0,     0,   431,   328,
01939      585,   607,     0,   526,   332,   417,   418,   202,     0,   256,
01940      302,    20,   568,   607,     0,   370,     0,   555,     0,     0,
01941        0,   531,   557,   532,   532,   563,   618,   581,   532,   573,
01942      532,   532,     0,     0,     0,   559,     0,   397,   385,   387,
01943        0,   375,   376,     0,   390,     0,   392,     0,   435,   433,
01944        0,   414,   273,   243,    36,   203,     0,     0,   445,   358,
01945        0,    12,   447,     0,   309,   310,     0,     0,   270,   618,
01946      320,     0,   523,   323,   525,   330,   547,   362,   373,     0,
01947      368,   364,   409,   412,   411,     0,   535,     0,   537,   527,
01948        0,   543,     0,   540,   545,     0,   569,   294,   427,   399,
01949      378,   379,   379,   561,   618,   379,   571,   379,   379,   404,
01950      607,   402,   405,    60,     0,   444,     0,   102,   103,   110,
01951        0,   446,     0,   313,   316,   437,   438,   436,     0,     0,
01952        0,     0,   371,     0,   366,   532,   532,   532,   532,   488,
01953      600,   293,     0,   382,     0,   384,   374,     0,   391,     0,
01954      388,   393,     0,   401,   109,   427,   618,   425,   618,   618,
01955        0,   326,     0,   369,     0,   536,     0,   533,   538,   541,
01956      379,   379,   379,   379,   403,   600,   108,   607,   596,   597,
01957      439,   356,   321,   333,   367,   532,   383,     0,   380,   386,
01958      389,   431,   534,   379,   381
01959 };
01960 
01961 /* YYDEFGOTO[NTERM-NUM].  */
01962 static const yytype_int16 yydefgoto[] =
01963 {
01964       -1,     1,     2,    66,    67,    68,   236,   567,   568,   252,
01965      253,   446,   254,   437,    70,    71,   358,    72,    73,   510,
01966      690,   243,    75,    76,   255,    77,    78,    79,   467,    80,
01967      209,   377,   378,   192,   193,   194,   195,   605,   556,   197,
01968       82,   439,   211,   260,   228,   748,   426,   427,   225,   226,
01969      213,   413,   428,   516,    83,   356,   259,   452,   625,   360,
01970      848,   361,   849,   732,   988,   736,   733,   931,   594,   596,
01971      746,   936,   245,    85,    86,    87,    88,    89,    90,    91,
01972       92,    93,    94,   713,   570,   721,   845,   846,   369,   772,
01973      773,   774,   960,   899,   803,   686,   687,   804,   970,   971,
01974      278,   279,   472,   658,   779,   320,   511,    95,    96,   711,
01975      704,   565,   557,   318,   508,   507,   577,   987,   715,   839,
01976      917,   921,    97,    98,    99,   100,   101,   102,   103,   290,
01977      485,   104,   294,   105,   106,   292,   296,   286,   284,   288,
01978      477,   676,   675,   794,   892,   798,   107,   285,   108,   109,
01979      216,   217,   112,   218,   219,   589,   735,   744,   881,   781,
01980      745,   661,   662,   663,   664,   665,   806,   807,   666,   667,
01981      668,   669,   809,   810,   670,   671,   672,   673,   674,   783,
01982      396,   595,   265,   429,   221,   115,   629,   559,   399,   304,
01983      423,   424,   706,   457,   571,   364,   257
01984 };
01985 
01986 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
01987    STATE-NUM.  */
01988 #define YYPACT_NINF -804
01989 static const yytype_int16 yypact[] =
01990 {
01991     -804,   112,  2751,  -804,  7365,  -804,  -804,  -804,  6888,  -804,
01992     -804,  -804,  -804,  -804,  -804,  -804,  7478,  7478,  -804,  -804,
01993     7478,  4073,  3668,  -804,  -804,  -804,  -804,   335,  6755,   -10,
01994     -804,    15,  -804,  -804,  -804,  2993,  3803,  -804,  -804,  3128,
01995     -804,  -804,  -804,  -804,  -804,  -804,  8834,  8834,    92,  5125,
01996     8947,  7817,  8156,  7147,  -804,  6622,  -804,  -804,  -804,    44,
01997       56,   182,   209,   544,  9060,  8834,  -804,    -9,  -804,   845,
01998     -804,   130,  -804,  -804,   138,   266,   238,  -804,   219,  9173,
01999     -804,   295,  2612,   398,   405,  -804,  8947,  8947,  -804,  -804,
02000     6012,  9282,  9391,  9500,  6488,    30,    62,  -804,  -804,   316,
02001     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02002      564,   574,  -804,   356,   634,  -804,  -804,  -804,  -804,  -804,
02003     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02004     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02005     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02006     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02007     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02008     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02009     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02010     -804,  -804,  -804,  -804,  -804,   315,  -804,  -804,  -804,  -804,
02011      360,  8834,   402,  5264,  8834,  8834,  8834,  8834,  -804,   388,
02012     2612,   430,  -804,  -804,   392,   422,   174,   185,   447,   291,
02013      408,  -804,  -804,  -804,  5899,  -804,  7478,  7478,  -804,  -804,
02014     6125,  -804,  8947,   596,  -804,   400,   420,  5403,  -804,  -804,
02015     -804,   423,   432,   138,  -804,   546,   515,   720,  7591,  -804,
02016     5125,   478,    -9,  -804,   845,   -10,   487,  -804,   130,   -10,
02017      479,   180,   247,  -804,   430,   491,   247,  -804,   -10,   582,
02018      577,  9609,   499,  -804,   573,   578,   600,   654,  -804,  -804,
02019     -804,  -804,  -804,  -804,   322,  -804,   463,   486,   401,   532,
02020      504,   545,    55,   563,   518,   566,    63,   625,   650,  -804,
02021     -804,  -804,  -804,  -804,  -804,  -804,  6238,  8947,  8947,  8947,
02022     8947,  7591,  8947,  8947,  -804,  -804,  -804,   608,  -804,  -804,
02023     -804,  8269,  -804,  5125,  7256,   588,  8269,  8834,  8834,  8834,
02024     8834,  8834,  8834,  8834,  8834,  8834,  8834,  8834,  8834,  8834,
02025     8834,  8834,  8834,  8834,  8834,  8834,  8834,  8834,  8834,  8834,
02026     8834,  8834,  8834,  9888,  7478,  9965,  4482,   130,   116,   116,
02027     8947,  8947,    -9,   707,   592,   678,  -804,  -804,   657,   711,
02028       65,    66,    69,   444,   571,  8947,   129,  -804,   257,   670,
02029     -804,  -804,  -804,  -804,   253,   334,   349,   370,   387,   458,
02030      477,   535,   539,  -804,  -804,  -804,    30,  -804,  -804, 10042,
02031     -804,  -804,  9060,  9060,  -804,  -804,   304,  -804,  -804,  -804,
02032     8834,  8834,  7704,  -804,  -804, 10119,  7478, 10196,  8834,  8834,
02033     7930,  -804,   -10,   604,  -804,  -804,   -10,  -804,   603,   609,
02034     -804,    89,  -804,  -804,  -804,  -804,  -804,  6888,  -804,  8834,
02035     5534,   617, 10119, 10196,  8834,   845,   621,   -10,  -804,  -804,
02036     6351,   618,   -10,  -804,  -804,  8043,  -804,  -804,  8156,  -804,
02037     -804,  -804,   400,   692,  -804,  -804,  -804,   619,  9609, 10273,
02038     7478, 10350,  1377,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02039     -804,  -804,  -804,  -804,  -804,   283,  -804,  -804,   614,  -804,
02040     -804,  -804,   293,  -804,   638,  -804,  8834,  8834,  -804,  -804,
02041     -804,  -804,  -804,  -804,  -804,  -804,  -804,    29,    29,  -804,
02042     -804,    29,  8834,  -804,   649,   662,  -804,   -10,  9609,   674,
02043     -804,  -804,  -804,   691,  2023,  -804,  -804,   515,  2149,  2149,
02044     2149,  2149,  1118,  1118,  2550,  1796,  2149,  2149,  2837,  2837,
02045      524,   524, 10841,  1118,  1118,  1095,  1095,  1178,    52,    52,
02046      515,   515,   515,  4208,  3263,  4343,  3398,   432,   685,  -804,
02047      -10,   722,  -804,   732,  -804,   432,  3938,   800,   804,  -804,
02048     4621,   801,  4899,    70,    70,   707,  8382,   800,    85, 10427,
02049     7478, 10504,  -804,   130,  -804,   692,  -804,    -9,  -804,  -804,
02050     -804, 10581,  7478, 10042,  4482,  8947,  1481,  -804,  -804,  -804,
02051     1147,  -804,  2365,  -804,  2612,  6888,  2484,  -804,  8834,   430,
02052     -804,   408,  2858,  3533,   -10,   328,   333,  -804,  -804,  -804,
02053     -804,  7704,  7930,  -804,  -804,  8947,  2612,   700,  -804,  -804,
02054     -804,  2612,  5534,   364,  -804,  -804,   247,  9609,   619,   643,
02055       23,   -10,   202,   323,   703,  -804,  -804,  -804,  -804,  8834,
02056     -804,   807,  -804,  -804,  -804,  -804,  -804,  1551,    75,  -804,
02057     -804,  -804,  -804,  -804,   689,  -804,   694,   780,   702,  -804,
02058      717,   806,   733,   817,  -804,  -804,   789,  -804,  -804,  -804,
02059     -804,  -804,   515,   515,  -804,  1086,  5673,  -804,  -804,  5403,
02060       29,  5673,   737,  8495,  -804,   619,  9609,  9060,  8834,   726,
02061     9060,  9060,  -804,   608,   432,   735,   747,  9060,  9060,  -804,
02062      608,   432,  -804,  -804,  8608,   859,  -804,   676,  -804,   859,
02063     -804,  -804,  -804,  -804,   800,    74,  -804,    57,    61,   -10,
02064      100,   108,  8947,    -9,  -804,  8947,  4482,   643,    23,  -804,
02065      -10,   800,    89,  1551,  4482,    -9,  7021,  -804,    62,   266,
02066     -804,  8834,  -804,  -804,  -804,  8834,  8834,   374,  8834,  8834,
02067      742,    89,  -804,   749,  -804,  -804,   428,  8834,  -804,  -804,
02068      807,   708,  -804,   744,   -10,  -804,   -10,  5673,  5403,  -804,
02069     1551,  -804,   395,  -804,  -804,  -804,    40,  -804,  1551,  -804,
02070     -804,   992,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02071      769,  9718,  -804,   -10,   773,   760,  -804,   765,   702,  -804,
02072      766,   771,  -804,   764,   898,   778,  5403,   901,  8834,   781,
02073      619,  2612,  8834,  -804,  2612,  -804,  2612,  -804,  -804,  -804,
02074     9060,  -804,  2612,  -804,  2612,  -804,  -804,   649,  -804,   826,
02075     -804,  5012,   907,  -804,  8947,   800,  -804,   800,  5673,  5673,
02076     -804,  8721,  4760,   154,    70,  -804,    -9,   800,  -804,  -804,
02077     -804,   -10,   800,  -804,  -804,  -804,  -804,  2612,  8834,  7930,
02078     -804,  -804,  -804,   -10,   892,   784,   877,  -804,   783,   912,
02079      792,  -804,  -804,   791,   802,  -804,   702,  -804,   809,  -804,
02080      811,   809,  5786,  9718,   894,   697,   833,  -804,  1627,  -804,
02081      436,  -804,  -804,  1627,  -804,  1699,  -804,   883,  -804,  -804,
02082      821,  -804,   819,  2612,  -804,  2612,  9827,   116,  -804,  -804,
02083     5673,  -804,  -804,   116,  -804,  -804,   800,   800,  -804,   289,
02084     -804,  4482,  -804,  -804,  -804,  -804,  1481,  -804,   820,   892,
02085      743,  -804,  -804,  -804,  -804,  1551,  -804,   992,  -804,  -804,
02086      992,  -804,   992,  -804,  -804,   848,   697,  -804, 10658,  -804,
02087     -804,   823,   824,  -804,   702,   825,  -804,   829,   825,  -804,
02088      277,  -804,  -804,  -804,   904,  -804,   706,   578,   600,   654,
02089     4482,  -804,  4621,  -804,  -804,  -804,  -804,  -804,  5673,   800,
02090     4482,   892,   820,   892,   834,   809,   836,   809,   809,  -804,
02091      831,   837,  1627,  -804,  1699,  -804,  -804,  1699,  -804,  1699,
02092     -804,  -804,   883,  -804,   692, 10735,  7478, 10812,   804,   676,
02093      800,  -804,   800,   820,   892,  -804,   992,  -804,  -804,  -804,
02094      825,   841,   825,   825,  -804,   169,    23,   -10,   139,   170,
02095     -804,  -804,  -804,  -804,   820,   809,  -804,  1699,  -804,  -804,
02096     -804,   241,  -804,   825,  -804
02097 };
02098 
02099 /* YYPGOTO[NTERM-NUM].  */
02100 static const yytype_int16 yypgoto[] =
02101 {
02102     -804,  -804,  -804,  -386,  -804,    41,  -804,  -542,   285,  -804,
02103      527,  -804,    35,  -804,  -310,   -43,   -70,    19,  -804,  -187,
02104     -804,   680,     9,   887,  -154,    27,   -73,  -804,  -404,     6,
02105     1733,  -328,   886,   -52,  -804,   -24,  -804,  -804,    13,  -804,
02106     1007,  -804,   909,  -804,   -72,   271,  -336,   141,     5,  -804,
02107     -320,  -212,    58,  -313,   -21,  -804,  -804,  -804,  -804,  -804,
02108     -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02109     -804,  -804,    49,  -804,  -804,  -804,  -804,  -804,  -804,  -804,
02110     -804,  -804,  -804,  -520,  -348,  -519,   -36,  -634,  -804,  -803,
02111     -773,   214,   300,    37,  -804,  -405,  -804,  -653,  -804,   -18,
02112     -804,  -804,  -804,  -804,  -804,   246,  -804,  -804,  -804,  -804,
02113     -804,  -804,  -804,   -95,  -804,  -804,  -535,  -804,   -22,  -804,
02114     -804,  -804,  -804,  -804,  -804,   908,  -804,  -804,  -804,  -804,
02115      714,  -804,  -804,  -804,  -804,  -804,  -804,  -804,   940,  -804,
02116     -116,  -804,  -804,  -804,  -804,  -804,     2,  -804,     7,  -804,
02117     1388,  1539,   906,  1901,  1724,  -804,  -804,    73,  -450,  -410,
02118     -412,  -769,  -627,  -718,  -134,   228,   111,  -804,  -804,  -804,
02119      -83,  -721,  -786,   114,   233,  -804,  -574,  -804,  -463,  -579,
02120     -804,  -804,  -804,   102,  -374,  -804,  -322,  -804,   622,   -29,
02121      -15,  -221,  -578,  -243,   -62,   -11,    -2
02122 };
02123 
02124 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
02125    positive, shift that token.  If negative, reduce the rule which
02126    number is the opposite.  If zero, do what YYDEFACT says.
02127    If YYTABLE_NINF, syntax error.  */
02128 #define YYTABLE_NINF -619
02129 static const yytype_int16 yytable[] =
02130 {
02131      116,   400,   316,   283,   234,   305,   325,   258,   421,   432,
02132      198,   572,   232,   526,   235,   199,   521,   359,   560,   459,
02133      362,   196,   659,   461,   775,   208,   208,   229,   305,   208,
02134      198,   558,   273,   566,   451,   199,   757,    69,   453,    69,
02135      724,   196,   394,   357,   357,   117,   617,   357,   586,   263,
02136      267,    84,   741,    84,   627,   723,   306,   726,   273,   272,
02137      660,   363,   882,   766,   638,   215,   215,   889,   196,   215,
02138      273,   273,   273,   941,   214,   214,   256,   600,   214,   317,
02139      614,   842,  -106,   299,   617,   847,  -108,   569,   314,   787,
02140     -102,  -103,   610,   558,  -110,   566,   447,   720,    84,   215,
02141      610,   938,   274,   689,   777,   684,   691,   196,  -293,   261,
02142     -109,   811,     3,   215,   695,   397,   488,   966,   220,   220,
02143      327,   630,   220,   878,   494,  -105,   312,   313,   274,   569,
02144      302,   231,   303,  -107,   641,   215,   215,   654,   972,   215,
02145      368,   379,   379,   775,   875,   237,   659,   685,   247,   630,
02146      896,   853,  -105,   262,   266,  -293,  -293,   212,   222,  -597,
02147      655,   223,   858,   398,   314,   489,   992,   312,   313,   517,
02148      479,   316,   482,   495,   486,   350,   351,   352,   486,  -104,
02149      882,   584,  -106,  -107,   289,   585,   778,   431,   941,   433,
02150      305,   -97,   315,  -596,   857,   -99,   291,  -597,   466,   -93,
02151      -94,   618,   862,  -101,   850,   620,   884,   659,   851,   302,
02152      623,   303,   414,   302,   890,   303,   966,   421,   414,  -100,
02153     1023,   859,   812,   449,   889,   430,   633,   -96,   901,   902,
02154      231,   635,   882,   208,   -96,   208,   208,   500,   501,   502,
02155      503,   450,   -98,   972,   729,   776,   763,   775,   617,   775,
02156      273,  1044,    84,   462,  -104,   302,   740,   303,   587,   630,
02157      789,  -517,   792,   739,   357,   357,   357,   357,   315,   505,
02158      506,   630,  -518,   215,   227,   215,   215,   256,  -105,   215,
02159     -105,   215,   214,   445,   214,   816,    84,  -102,   -95,   882,
02160      573,   574,   820,   659,   319,   985,   694,    84,  -103,    84,
02161      305,   610,   610,   273,   841,  -596,   576,   949,  -106,  -107,
02162     -106,  -107,   775,   994,   455,   -96,   590,   357,   357,   887,
02163      274,   456,   293,   887,   962,   924,   220,   925,   220,   967,
02164      519,   861,   583,   575,   251,   930,   -96,   933,  -509,   -96,
02165      513,    69,   935,   -96,   473,   522,   504,   499,   -98,   295,
02166      256,   321,   430,   322,   473,    84,   215,   215,   215,   215,
02167       84,   215,   215,   208,   775,   422,   775,   425,   564,   678,
02168      215,   996,    84,   274,   588,   215,   678,   852,   419,   515,
02169     -104,   458,  -104,   473,   515,  1006,  -509,   521,   456,   989,
02170      474,   444,   475,   764,   986,   466,   302,   775,   303,   754,
02171      474,   838,   475,   215,  -110,    84,   983,   984,   326,   215,
02172      215,  1012,   564,   624,   430,   758,    56,  -109,   231,  -508,
02173      759,   601,   603,   677,   215,   208,   414,   414,  1031,   474,
02174      564,   475,   476,   680,  -510,   812,   -98,   887,   116,   198,
02175      812,  -105,   812,   402,   199,   466,  -107,   273,  1022,   404,
02176      196,   215,   215,   649,  -431,  -511,   564,   -98,   406,  1051,
02177      -98,   868,   473,   650,   -98,   215,   481,  -508,   430,  1021,
02178     -593,   230,  -513,   946,   948,    69,   231,   -74,   951,   208,
02179      953,   954,  -510,  -338,   564,   702,   659,  -104,   251,    84,
02180      353,   653,   654,   709,   801,   617,   230,   273,   -88,    84,
02181     1042,   410,  1043,  -511,   650,   688,   688,   415,   474,   688,
02182      475,   722,   722,  -431,   611,   655,   827,   274,   411,   215,
02183     -513,   860,   441,   835,   473,   734,   412,   699,   747,  -503,
02184     -338,  -338,   653,   654,   418,   251,   438,   354,   355,   812,
02185      870,   812,   420,  -512,   812,   705,   812,   473,   754,   610,
02186      440,   805,   742,   877,   416,   417,   655,   636,  -431,   224,
02187     -431,  -431,  -514,   703,   765,   473,   716,   274,   227,   980,
02188      474,   710,   475,   478,  -593,   982,  -503,  -503,   430,   473,
02189     -593,   752,   761,   327,   812,  1025,  1027,  1028,  1029,   208,
02190      430,  -512,   327,   474,   564,   475,   480,  -594,   750,   705,
02191      -73,   208,   808,   297,   298,   749,   564,   198,   251,   414,
02192     -514,   474,   199,   475,   484,   448,   273,   454,   196,    84,
02193     -503,    84,   460,   466,  -506,   474,   705,   475,   491,   215,
02194      116,   442,   828,   468,   725,  1052,   464,   465,   463,   747,
02195      934,   215,   483,    84,   215,   348,   349,   350,   351,   352,
02196      434,  -517,   937,   865,   888,   487,  -506,   891,   469,   435,
02197      436,  -518,   854,  -515,   784,   856,   784,    69,  -503,  -600,
02198      813,   855,  -506,   490,   215,   273,   493,  -102,   416,   443,
02199     1037,    84,    74,   863,    74,  -516,   274,  -103,   688,   357,
02200      844,   841,   357,   496,   864,   630,    74,    74,   -93,   886,
02201       74,  -594,   509,  -506,  -506,   470,   471,  -594,   -94,   750,
02202     -515,  -515,   840,   843,   705,   843,   522,   843,   497,   823,
02203      825,   403,   520,   760,   576,   705,   831,   833,  -600,    74,
02204       74,   498,  -516,  -516,   578,    84,   582,   621,    84,  -284,
02205       84,   619,   579,   622,    74,   274,   215,  -110,   628,   215,
02206      215,   632,   -88,   637,   679,   591,   215,   215,   414,   196,
02207      769,   813,   645,   646,   647,   648,    74,    74,  -101,   965,
02208       74,   968,   515,  -600,   923,  -600,  -600,  -294,   681,  -596,
02209      273,   215,   958,  -268,   215,    84,  -284,  -284,   813,   580,
02210      581,  1015,   722,    84,   932,   769,   693,   645,   646,   647,
02211      648,   357,   592,   593,   697,   784,   784,   444,   696,   707,
02212      712,   995,   714,   997,   718,   808,   767,   964,   998,   708,
02213      808,  -422,   808,   780,  -294,  -294,    84,    84,   782,   592,
02214      593,   762,   785,  -109,   830,  -105,   786,   918,  1016,  1017,
02215      922,   822,   874,   795,   796,  -107,   797,   904,   906,   914,
02216      895,   788,    44,    45,  -100,   717,   -96,   719,   790,   769,
02217     -104,   645,   646,   647,   648,    84,   -98,   791,  1030,   793,
02218     1032,  -269,   273,   829,   841,  1033,   869,   993,   876,   215,
02219      871,   -95,   893,    74,   784,   307,   308,   309,   310,   311,
02220       84,   897,  1045,   215,   898,   273,   770,    84,    84,   900,
02221      903,    84,   771,   907,    74,   905,    74,    74,   908,   909,
02222       74,   911,    74,  1053,   916,  -270,   920,    74,   939,   808,
02223      942,   808,   943,   944,   808,   945,   808,   843,    74,   769,
02224       74,   645,   646,   647,   648,   969,   947,   645,   646,   647,
02225      648,    84,   956,   950,   769,   952,   645,   646,   647,   648,
02226      957,   959,   973,  -271,   991,  1013,   999,  1002,  1004,  1007,
02227     1014,   264,   784,  1009,   808,   976,   770,  -596,  1024,    84,
02228     1026,   814,   940,  -597,   815,  1047,   817,   634,   366,   383,
02229       84,   770,   836,  1041,   873,   802,    74,    74,    74,    74,
02230       74,    74,    74,    74,  1034,   866,  1040,   287,  1003,  1005,
02231      395,    74,  1008,    74,  1010,  1011,    74,   401,   492,   990,
02232      885,   963,   961,   883,   430,     0,   716,   843,   597,     0,
02233        0,     0,   705,   210,   210,   208,     0,   210,     0,    84,
02234      564,    84,     0,     0,    74,     0,    74,    84,     0,    84,
02235       74,    74,     0,     0,   769,     0,   645,   646,   647,   648,
02236      649,     0,     0,   244,   246,    74,     0,     0,   210,   210,
02237      650,     0,   879,   880,     0,   215,     0,  1046,  1048,  1049,
02238     1050,   300,   301,     0,     0,     0,     0,     0,     0,     0,
02239        0,   651,    74,    74,     0,     0,     0,     0,   653,   654,
02240     1054,     0,     0,     0,     0,     0,    74,     0,     0,     0,
02241        0,   910,     0,     0,     0,     0,     0,     0,     0,     0,
02242      405,     0,   655,   407,   408,   409,     0,     0,     0,     0,
02243       74,     0,     0,     0,     0,     0,   919,     0,     0,     0,
02244       74,     0,     0,   926,   927,     0,     0,   929,   800,     0,
02245      645,   646,   647,   648,   801,     0,     0,  -618,     0,     0,
02246       74,     0,     0,     0,   650,  -618,  -618,  -618,     0,     0,
02247     -618,  -618,  -618,   327,  -618,     0,     0,     0,     0,     0,
02248        0,     0,     0,  -618,  -618,   651,     0,   955,   340,   341,
02249        0,   652,   653,   654,  -618,  -618,   327,  -618,  -618,  -618,
02250     -618,  -618,     0,     0,     0,     0,     0,     0,     0,     0,
02251        0,   340,   341,     0,     0,   981,   655,     0,   210,   656,
02252        0,   210,   210,   210,   300,   347,   348,   349,   350,   351,
02253      352,     0,     0,     0,     0,     0,     0,   231,     0,     0,
02254      514,   210,  -618,   210,   210,   525,   345,   346,   347,   348,
02255      349,   350,   351,   352,     0,     0,   327,     0,     0,     0,
02256       74,     0,    74,     0,     0,  -618,     0,     0,     0,     0,
02257       74,   340,   341,     0,     0,  1018,     0,  1019,     0,     0,
02258        0,     0,    74,  1020,    74,    74,     0,  -618,  -618,     0,
02259     -618,     0,     0,   227,  -618,     0,  -618,     0,  -618,     0,
02260        0,     0,     0,     0,     0,     0,     0,     0,     0,   348,
02261      349,   350,   351,   352,     0,    74,     0,     0,     0,     0,
02262        0,     0,    74,     0,     0,     0,     0,     0,     0,     0,
02263      607,   609,     0,     0,     0,     0,     0,     0,   210,   264,
02264        0,     0,     0,   524,   527,   528,   529,   530,   531,   532,
02265      533,   534,   535,   536,   537,   538,   539,   540,   541,   542,
02266      543,   544,   545,   546,   547,   548,   549,   550,   551,   552,
02267        0,   210,     0,     0,   609,     0,    74,   264,     0,    74,
02268        0,    74,     0,     0,     0,     0,     0,    74,     0,     0,
02269       74,    74,     0,     0,     0,     0,     0,    74,    74,     0,
02270      110,     0,   110,     0,     0,     0,     0,     0,     0,     0,
02271        0,     0,     0,     0,     0,     0,     0,     0,     0,   602,
02272      604,     0,    74,     0,     0,    74,    74,   606,   210,   210,
02273        0,   692,     0,   210,    74,   602,   604,   210,     0,   644,
02274        0,   645,   646,   647,   648,   649,     0,   110,     0,     0,
02275        0,   275,     0,     0,     0,   650,   626,     0,     0,     0,
02276        0,   631,     0,     0,     0,     0,     0,    74,    74,     0,
02277        0,     0,   210,     0,     0,   210,   651,   275,     0,     0,
02278        0,     0,   652,   653,   654,     0,     0,   210,     0,   370,
02279      380,   380,   380,     0,     0,   525,     0,     0,     0,     0,
02280        0,     0,     0,     0,     0,     0,    74,   655,     0,     0,
02281      656,     0,     0,   682,   683,     0,     0,     0,     0,     0,
02282       74,     0,     0,   657,     0,     0,     0,   753,     0,   210,
02283        0,    74,     0,     0,    74,     0,     0,     0,    74,    74,
02284      609,   264,    74,   644,     0,   645,   646,   647,   648,   649,
02285        0,   111,     0,   111,     0,     0,     0,     0,     0,   650,
02286        0,     0,     0,     0,     0,     0,     0,     0,   768,     0,
02287        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02288      651,     0,    74,     0,     0,     0,   652,   653,   654,     0,
02289        0,     0,     0,   210,     0,     0,     0,   210,   111,     0,
02290        0,   110,   276,     0,     0,     0,     0,     0,     0,   210,
02291       74,   655,   819,   644,   656,   645,   646,   647,   648,   649,
02292        0,    74,     0,     0,     0,   210,     0,   743,   276,   650,
02293        0,     0,     0,   837,     0,   110,     0,     0,   210,   210,
02294      371,   381,   381,   381,     0,     0,   110,     0,   110,     0,
02295      651,     0,     0,     0,     0,     0,   652,   653,   654,     0,
02296        0,     0,     0,     0,     0,     0,   210,     0,     0,   275,
02297       74,     0,    74,     0,     0,     0,     0,     0,    74,     0,
02298       74,   655,     0,     0,   656,     0,   872,     0,     0,   800,
02299        0,   645,   646,   647,   648,   801,     0,     0,     0,     0,
02300        0,     0,     0,     0,   110,   650,    74,     0,     0,   110,
02301      210,     0,     0,     0,   606,   821,     0,   824,   826,     0,
02302        0,   110,   275,     0,   832,   834,   651,     0,     0,     0,
02303        0,   210,   652,   653,   654,     0,   114,   912,   114,     0,
02304        0,     0,     0,     0,     0,    81,     0,    81,     0,     0,
02305        0,     0,   111,     0,   110,     0,     0,   655,     0,     0,
02306      656,   769,     0,   645,   646,   647,   648,   801,   867,     0,
02307      928,     0,   824,   826,     0,   832,   834,   650,     0,     0,
02308        0,     0,     0,   114,   210,     0,   111,   277,   264,     0,
02309        0,     0,    81,     0,     0,     0,     0,   111,   651,   111,
02310        0,     0,     0,     0,     0,   653,   654,     0,     0,     0,
02311        0,     0,     0,   277,     0,     0,     0,     0,     0,     0,
02312      276,     0,     0,     0,     0,   372,   382,   382,     0,   655,
02313        0,     0,     0,     0,   367,   210,     0,     0,   110,   913,
02314        0,     0,     0,     0,     0,     0,     0,   915,   110,     0,
02315        0,     0,     0,     0,     0,   111,     0,     0,     0,     0,
02316      111,     0,     0,     0,     0,     0,   275,     0,   210,     0,
02317        0,     0,   111,   276,   327,   328,   329,   330,   331,   332,
02318      333,   334,     0,   336,   337,   915,   210,     0,     0,   340,
02319      341,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02320        0,     0,     0,     0,     0,   111,     0,     0,     0,     0,
02321        0,     0,     0,   113,     0,   113,   275,     0,     0,     0,
02322        0,     0,   343,   344,   345,   346,   347,   348,   349,   350,
02323      351,   352,     0,     0,     0,     0,     0,   114,     0,     0,
02324        0,     0,     0,     0,     0,     0,    81,     0,     0,     0,
02325        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02326      113,     0,     0,     0,     0,     0,     0,     0,   110,     0,
02327      110,   114,     0,     0,     0,     0,     0,     0,     0,     0,
02328       81,     0,   114,     0,   114,     0,     0,     0,     0,   111,
02329        0,    81,   110,    81,     0,     0,     0,     0,     0,   111,
02330        0,     0,     0,     0,     0,   277,     0,     0,     0,     0,
02331        0,     0,     0,     0,     0,     0,     0,   276,     0,     0,
02332        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02333      110,     0,     0,   210,     0,   275,     0,     0,     0,     0,
02334      114,     0,     0,     0,     0,   114,     0,     0,     0,    81,
02335        0,     0,     0,     0,    81,     0,     0,   114,   277,     0,
02336        0,     0,     0,     0,     0,     0,    81,   276,     0,   523,
02337        0,     0,     0,     0,     0,     0,     0,   698,     0,     0,
02338        0,     0,     0,     0,   110,     0,     0,   110,     0,   110,
02339      114,     0,     0,     0,   275,     0,     0,     0,     0,    81,
02340        0,   327,   328,   329,   330,   331,   332,   333,   334,   335,
02341      336,   337,   338,   339,   113,     0,   340,   341,     0,   111,
02342        0,   111,     0,     0,     0,     0,     0,     0,     0,     0,
02343        0,     0,     0,     0,   110,     0,     0,     0,     0,     0,
02344        0,     0,   110,   111,     0,     0,     0,   342,   113,   343,
02345      344,   345,   346,   347,   348,   349,   350,   351,   352,   113,
02346        0,   113,     0,     0,     0,     0,     0,  -245,     0,     0,
02347        0,     0,     0,     0,   114,   110,   110,     0,     0,     0,
02348        0,   111,     0,    81,   114,     0,   276,     0,     0,     0,
02349        0,     0,     0,    81,     0,     0,     0,     0,     0,   380,
02350        0,     0,   277,     0,     0,     0,     0,     0,     0,     0,
02351        0,     0,     0,     0,   110,     0,     0,   113,     0,     0,
02352        0,     0,   113,     0,     0,     0,     0,   327,  -619,  -619,
02353     -619,  -619,   332,   333,   113,   111,  -619,  -619,   111,   110,
02354      111,     0,   340,   341,     0,   276,   110,   110,     0,     0,
02355      110,     0,   277,     0,     0,     0,     0,     0,     0,     0,
02356        0,     0,     0,     0,     0,     0,     0,   113,     0,     0,
02357        0,     0,     0,     0,     0,   343,   344,   345,   346,   347,
02358      348,   349,   350,   351,   352,   111,     0,     0,     0,     0,
02359      110,   380,     0,   111,     0,     0,     0,     0,     0,     0,
02360        0,     0,     0,     0,   114,     0,   114,     0,     0,     0,
02361        0,     0,     0,    81,   977,    81,     0,     0,   110,     0,
02362        0,     0,     0,     0,     0,     0,   111,   111,   114,   110,
02363        0,     0,     0,     0,     0,     0,     0,    81,     0,     0,
02364        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02365      381,   113,     0,     0,     0,     0,     0,     0,     0,     0,
02366        0,   113,     0,     0,     0,   111,   114,     0,     0,     0,
02367        0,   277,     0,     0,     0,    81,     0,     0,   110,     0,
02368      110,     0,     0,     0,     0,     0,   110,     0,   110,     0,
02369      111,     0,     0,     0,     0,     0,     0,   111,   111,     0,
02370        0,   111,     0,     0,     0,     0,     0,     0,     0,     0,
02371      799,     0,     0,     0,     0,     0,     0,     0,     0,   751,
02372      114,     0,     0,   114,     0,   114,     0,     0,     0,    81,
02373      277,     0,    81,     0,    81,     0,     0,     0,     0,     0,
02374      523,   111,   381,   327,   328,   329,   330,   331,   332,   333,
02375      334,   335,   336,   337,   338,   339,     0,     0,   340,   341,
02376        0,     0,     0,     0,     0,   978,     0,     0,     0,   111,
02377      114,     0,     0,     0,     0,     0,     0,     0,   114,    81,
02378      111,   113,     0,   113,     0,     0,     0,    81,     0,   342,
02379        0,   343,   344,   345,   346,   347,   348,   349,   350,   351,
02380      352,     0,     0,     0,     0,   113,     0,     0,     0,     0,
02381        0,   114,   114,     0,     0,     0,     0,     0,     0,     0,
02382       81,    81,     0,     0,     0,     0,     0,     0,     0,   111,
02383        0,   111,     0,     0,     0,   382,     0,   111,   698,   111,
02384        0,     0,     0,   113,     0,     0,     0,     0,     0,     0,
02385      114,     0,     0,     0,     0,     0,     0,     0,     0,    81,
02386        0,     0,   327,   328,   329,   330,   331,   332,   333,   334,
02387      335,   336,   337,   338,   339,   114,     0,   340,   341,     0,
02388        0,     0,   114,   114,    81,     0,   114,     0,     0,     0,
02389        0,    81,    81,     0,     0,    81,     0,   113,     0,     0,
02390      113,     0,   113,     0,     0,     0,     0,     0,   342,     0,
02391      343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
02392        0,     0,     0,     0,     0,     0,   114,   382,   327,   328,
02393      329,   330,   331,   332,   333,    81,     0,   336,   337,     0,
02394        0,     0,     0,   340,   341,     0,     0,   113,     0,     0,
02395      979,     0,     0,     0,   114,   113,     0,     0,     0,   975,
02396        0,     0,     0,    81,     0,   114,     0,     0,     0,     0,
02397        0,     0,     0,     0,    81,     0,   343,   344,   345,   346,
02398      347,   348,   349,   350,   351,   352,     0,     0,   113,   113,
02399      327,   328,   329,   330,   331,   332,   333,   334,   335,   336,
02400      337,   338,   339,     0,     0,   340,   341,     0,     0,     0,
02401        0,     0,     0,     0,   114,     0,   114,     0,     0,     0,
02402        0,     0,   114,    81,   114,    81,     0,   113,     0,     0,
02403        0,    81,     0,    81,     0,     0,   342,     0,   343,   344,
02404      345,   346,   347,   348,   349,   350,   351,   352,     0,     0,
02405        0,     0,   113,     0,     0,     0,     0,     0,     0,   113,
02406      113,  -618,     4,   113,     5,     6,     7,     8,     9,     0,
02407        0,     0,    10,    11,     0,     0,     0,    12,     0,    13,
02408       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02409        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02410       27,     0,     0,   113,     0,     0,    28,    29,    30,    31,
02411       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02412       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02413        0,   113,     0,     0,     0,     0,     0,     0,     0,     0,
02414        0,     0,   113,     0,     0,     0,     0,    48,     0,     0,
02415       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02416       55,    56,    57,    58,    59,    60,    61,    62,  -600,     0,
02417        0,     0,     0,     0,     0,     0,  -600,  -600,  -600,     0,
02418        0,  -600,  -600,  -600,     0,  -600,     0,    63,    64,    65,
02419        0,   113,     0,   113,  -600,  -600,  -600,  -600,     0,   113,
02420     -618,   113,  -618,     0,     0,  -600,  -600,     0,  -600,  -600,
02421     -600,  -600,  -600,     0,     0,   327,   328,   329,   330,   331,
02422      332,   333,   334,   335,   336,   337,  -619,  -619,     0,     0,
02423      340,   341,     0,     0,     0,     0,  -600,  -600,  -600,  -600,
02424     -600,  -600,  -600,  -600,  -600,  -600,  -600,  -600,  -600,     0,
02425        0,  -600,  -600,  -600,     0,   755,  -600,     0,     0,     0,
02426        0,     0,  -600,   343,   344,   345,   346,   347,   348,   349,
02427      350,   351,   352,     0,     0,     0,  -600,     0,     0,  -600,
02428        0,  -106,  -600,  -600,  -600,  -600,  -600,  -600,  -600,  -600,
02429     -600,  -600,  -600,  -600,     0,     0,     0,     0,  -600,  -600,
02430     -600,  -600,  -600,  -503,     0,  -600,  -600,  -600,     0,  -600,
02431        0,  -503,  -503,  -503,     0,     0,  -503,  -503,  -503,     0,
02432     -503,     0,     0,     0,     0,     0,     0,     0,  -503,     0,
02433     -503,  -503,  -503,     0,     0,     0,     0,     0,     0,     0,
02434     -503,  -503,     0,  -503,  -503,  -503,  -503,  -503,     0,     0,
02435        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02436        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02437        0,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,
02438     -503,  -503,  -503,  -503,     0,     0,  -503,  -503,  -503,     0,
02439     -503,  -503,     0,     0,     0,     0,     0,  -503,     0,     0,
02440        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02441        0,  -503,     0,     0,  -503,     0,  -503,  -503,  -503,  -503,
02442     -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,  -503,     0,
02443        0,     0,     0,     0,  -503,  -503,  -503,  -503,  -506,     0,
02444     -503,  -503,  -503,     0,  -503,     0,  -506,  -506,  -506,     0,
02445        0,  -506,  -506,  -506,     0,  -506,     0,     0,     0,     0,
02446        0,     0,     0,  -506,     0,  -506,  -506,  -506,     0,     0,
02447        0,     0,     0,     0,     0,  -506,  -506,     0,  -506,  -506,
02448     -506,  -506,  -506,     0,     0,     0,     0,     0,     0,     0,
02449        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02450        0,     0,     0,     0,     0,     0,  -506,  -506,  -506,  -506,
02451     -506,  -506,  -506,  -506,  -506,  -506,  -506,  -506,  -506,     0,
02452        0,  -506,  -506,  -506,     0,  -506,  -506,     0,     0,     0,
02453        0,     0,  -506,     0,     0,     0,     0,     0,     0,     0,
02454        0,     0,     0,     0,     0,     0,  -506,     0,     0,  -506,
02455        0,  -506,  -506,  -506,  -506,  -506,  -506,  -506,  -506,  -506,
02456     -506,  -506,  -506,  -506,     0,     0,     0,     0,     0,  -506,
02457     -506,  -506,  -506,  -601,     0,  -506,  -506,  -506,     0,  -506,
02458        0,  -601,  -601,  -601,     0,     0,  -601,  -601,  -601,     0,
02459     -601,     0,     0,     0,     0,     0,     0,     0,     0,  -601,
02460     -601,  -601,  -601,     0,     0,     0,     0,     0,     0,     0,
02461     -601,  -601,     0,  -601,  -601,  -601,  -601,  -601,     0,     0,
02462        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02463        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02464        0,  -601,  -601,  -601,  -601,  -601,  -601,  -601,  -601,  -601,
02465     -601,  -601,  -601,  -601,     0,     0,  -601,  -601,  -601,     0,
02466        0,  -601,     0,     0,     0,     0,     0,  -601,     0,     0,
02467        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02468        0,  -601,     0,     0,  -601,     0,     0,  -601,  -601,  -601,
02469     -601,  -601,  -601,  -601,  -601,  -601,  -601,  -601,  -601,     0,
02470        0,     0,     0,  -601,  -601,  -601,  -601,  -601,  -602,     0,
02471     -601,  -601,  -601,     0,  -601,     0,  -602,  -602,  -602,     0,
02472        0,  -602,  -602,  -602,     0,  -602,     0,     0,     0,     0,
02473        0,     0,     0,     0,  -602,  -602,  -602,  -602,     0,     0,
02474        0,     0,     0,     0,     0,  -602,  -602,     0,  -602,  -602,
02475     -602,  -602,  -602,     0,     0,     0,     0,     0,     0,     0,
02476        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02477        0,     0,     0,     0,     0,     0,  -602,  -602,  -602,  -602,
02478     -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,     0,
02479        0,  -602,  -602,  -602,     0,     0,  -602,     0,     0,     0,
02480        0,     0,  -602,     0,     0,     0,     0,     0,     0,     0,
02481        0,     0,     0,     0,     0,     0,  -602,     0,     0,  -602,
02482        0,     0,  -602,  -602,  -602,  -602,  -602,  -602,  -602,  -602,
02483     -602,  -602,  -602,  -602,     0,     0,     0,     0,  -602,  -602,
02484     -602,  -602,  -602,  -293,     0,  -602,  -602,  -602,     0,  -602,
02485        0,  -293,  -293,  -293,     0,     0,  -293,  -293,  -293,     0,
02486     -293,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02487     -293,  -293,  -293,     0,     0,     0,     0,     0,     0,     0,
02488     -293,  -293,     0,  -293,  -293,  -293,  -293,  -293,     0,     0,
02489        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02490        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02491        0,  -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,
02492     -293,  -293,  -293,  -293,     0,     0,  -293,  -293,  -293,     0,
02493      756,  -293,     0,     0,     0,     0,     0,  -293,     0,     0,
02494        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02495        0,  -293,     0,     0,  -293,     0,  -108,  -293,  -293,  -293,
02496     -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,     0,
02497        0,     0,     0,     0,  -293,  -293,  -293,  -293,  -430,     0,
02498     -293,  -293,  -293,     0,  -293,     0,  -430,  -430,  -430,     0,
02499        0,  -430,  -430,  -430,     0,  -430,     0,     0,     0,     0,
02500        0,     0,     0,     0,  -430,  -430,  -430,     0,     0,     0,
02501        0,     0,     0,     0,     0,  -430,  -430,     0,  -430,  -430,
02502     -430,  -430,  -430,     0,     0,     0,     0,     0,     0,     0,
02503        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02504        0,     0,     0,     0,     0,     0,  -430,  -430,  -430,  -430,
02505     -430,  -430,  -430,  -430,  -430,  -430,  -430,  -430,  -430,     0,
02506        0,  -430,  -430,  -430,     0,     0,  -430,     0,     0,     0,
02507        0,     0,  -430,     0,     0,     0,     0,     0,     0,     0,
02508        0,     0,     0,     0,     0,     0,  -430,     0,     0,     0,
02509        0,     0,  -430,     0,  -430,  -430,  -430,  -430,  -430,  -430,
02510     -430,  -430,  -430,  -430,     0,     0,     0,     0,  -430,  -430,
02511     -430,  -430,  -430,  -285,   227,  -430,  -430,  -430,     0,  -430,
02512        0,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,     0,
02513     -285,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02514     -285,  -285,  -285,     0,     0,     0,     0,     0,     0,     0,
02515     -285,  -285,     0,  -285,  -285,  -285,  -285,  -285,     0,     0,
02516        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02517        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02518        0,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,
02519     -285,  -285,  -285,  -285,     0,     0,  -285,  -285,  -285,     0,
02520        0,  -285,     0,     0,     0,     0,     0,  -285,     0,     0,
02521        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02522        0,  -285,     0,     0,  -285,     0,     0,  -285,  -285,  -285,
02523     -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,  -285,     0,
02524        0,     0,     0,     0,  -285,  -285,  -285,  -285,  -420,     0,
02525     -285,  -285,  -285,     0,  -285,     0,  -420,  -420,  -420,     0,
02526        0,  -420,  -420,  -420,     0,  -420,     0,     0,     0,     0,
02527        0,     0,     0,     0,  -420,  -420,  -420,     0,     0,     0,
02528        0,     0,     0,     0,     0,  -420,  -420,     0,  -420,  -420,
02529     -420,  -420,  -420,     0,     0,     0,     0,     0,     0,     0,
02530        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02531        0,     0,     0,     0,     0,     0,  -420,  -420,  -420,  -420,
02532     -420,  -420,  -420,  -420,  -420,  -420,  -420,  -420,  -420,     0,
02533        0,  -420,  -420,  -420,     0,     0,  -420,     0,     0,     0,
02534        0,     0,  -420,     0,     0,     0,     0,     0,     0,     0,
02535        0,     0,     0,     0,     0,     0,  -420,     0,     0,     0,
02536        0,     0,  -420,     0,  -420,  -420,  -420,  -420,  -420,  -420,
02537     -420,  -420,  -420,  -420,     0,     0,     0,     0,  -420,  -420,
02538     -420,  -420,  -420,  -300,  -420,  -420,  -420,  -420,     0,  -420,
02539        0,  -300,  -300,  -300,     0,     0,  -300,  -300,  -300,     0,
02540     -300,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02541     -300,  -300,     0,     0,     0,     0,     0,     0,     0,     0,
02542     -300,  -300,     0,  -300,  -300,  -300,  -300,  -300,     0,     0,
02543        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02544        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02545        0,  -300,  -300,  -300,  -300,  -300,  -300,  -300,  -300,  -300,
02546     -300,  -300,  -300,  -300,     0,     0,  -300,  -300,  -300,     0,
02547        0,  -300,     0,     0,     0,     0,     0,  -300,     0,     0,
02548        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02549        0,  -300,     0,     0,     0,     0,     0,  -300,     0,  -300,
02550     -300,  -300,  -300,  -300,  -300,  -300,  -300,  -300,  -300,     0,
02551        0,     0,     0,     0,  -300,  -300,  -300,  -300,  -600,   224,
02552     -300,  -300,  -300,     0,  -300,     0,  -600,  -600,  -600,     0,
02553        0,     0,  -600,  -600,     0,  -600,     0,     0,     0,     0,
02554        0,     0,     0,     0,  -600,     0,     0,     0,     0,     0,
02555        0,     0,     0,     0,     0,  -600,  -600,     0,  -600,  -600,
02556     -600,  -600,  -600,     0,     0,     0,     0,     0,     0,     0,
02557        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02558        0,     0,     0,     0,     0,     0,  -600,  -600,  -600,  -600,
02559     -600,  -600,  -600,  -600,  -600,  -600,  -600,  -600,  -600,     0,
02560        0,  -600,  -600,  -600,     0,   700,     0,     0,     0,     0,
02561        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02562        0,     0,     0,     0,     0,     0,  -600,     0,     0,     0,
02563        0,  -106,  -600,     0,  -600,  -600,  -600,  -600,  -600,  -600,
02564     -600,  -600,  -600,  -600,     0,     0,     0,     0,  -600,  -600,
02565     -600,  -600,   -97,  -293,     0,  -600,     0,  -600,     0,  -600,
02566        0,  -293,  -293,  -293,     0,     0,     0,  -293,  -293,     0,
02567     -293,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02568        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02569     -293,  -293,     0,  -293,  -293,  -293,  -293,  -293,     0,     0,
02570        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02571        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02572        0,  -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,
02573     -293,  -293,  -293,  -293,     0,     0,  -293,  -293,  -293,     0,
02574      701,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02575        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02576        0,  -293,     0,     0,     0,     0,  -108,  -293,     0,  -293,
02577     -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,  -293,     0,
02578        0,     0,     0,     0,  -293,  -293,  -293,   -99,     0,     0,
02579     -293,     0,  -293,   248,  -293,     5,     6,     7,     8,     9,
02580     -618,  -618,  -618,    10,    11,     0,     0,  -618,    12,     0,
02581       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02582        0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02583        0,    27,     0,     0,     0,     0,     0,    28,    29,   249,
02584       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02585        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02586        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02587        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02588        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02589       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02590        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02591        0,     0,     0,     0,     0,     0,     0,     0,    63,    64,
02592       65,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02593        0,  -618,   248,  -618,     5,     6,     7,     8,     9,     0,
02594        0,  -618,    10,    11,     0,  -618,  -618,    12,     0,    13,
02595       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02596        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02597       27,     0,     0,     0,     0,     0,    28,    29,   249,    31,
02598       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02599       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02600        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02601        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02602       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02603       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02604        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02605        0,     0,     0,     0,     0,     0,     0,    63,    64,    65,
02606        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02607     -618,   248,  -618,     5,     6,     7,     8,     9,     0,     0,
02608     -618,    10,    11,     0,     0,  -618,    12,  -618,    13,    14,
02609       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
02610       20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
02611        0,     0,     0,     0,     0,    28,    29,   249,    31,    32,
02612       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
02613       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02614        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02615        0,     0,     0,     0,     0,     0,    48,     0,     0,    49,
02616       50,     0,    51,    52,     0,    53,     0,     0,    54,    55,
02617       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02618        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02619        0,     0,     0,     0,     0,     0,    63,    64,    65,     0,
02620        0,     0,     0,     0,     0,     0,     0,     0,     0,  -618,
02621      248,  -618,     5,     6,     7,     8,     9,     0,     0,  -618,
02622       10,    11,     0,     0,  -618,    12,     0,    13,    14,    15,
02623       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02624       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
02625        0,     0,     0,     0,    28,    29,   249,    31,    32,    33,
02626       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02627        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02628        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02629        0,     0,     0,     0,     0,    48,     0,     0,    49,    50,
02630        0,    51,    52,     0,    53,     0,     0,    54,    55,    56,
02631       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02632        0,     0,     0,   248,     0,     5,     6,     7,     8,     9,
02633        0,  -618,  -618,    10,    11,    63,    64,    65,    12,     0,
02634       13,    14,    15,    16,    17,    18,    19,     0,  -618,     0,
02635     -618,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02636        0,    27,     0,     0,     0,     0,     0,    28,    29,   249,
02637       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02638        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02639        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02640        0,     0,     0,     0,     0,     0,     0,     0,    48,     0,
02641        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
02642       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02643        0,     0,     0,     0,     0,     0,   248,     0,     5,     6,
02644        7,     8,     9,     0,     0,     0,    10,    11,    63,    64,
02645       65,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02646        0,  -618,     0,  -618,     0,    20,    21,    22,    23,    24,
02647       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02648       28,    29,   249,    31,    32,    33,    34,    35,    36,    37,
02649       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02650        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02651        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02652        0,    48,     0,     0,   250,    50,     0,    51,    52,     0,
02653       53,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02654       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02655        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02656        0,    63,    64,    65,     0,     0,     0,     0,     0,     0,
02657        0,     0,  -618,     0,  -618,   248,  -618,     5,     6,     7,
02658        8,     9,     0,     0,     0,    10,    11,     0,     0,     0,
02659       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02660        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02661       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02662       29,   249,    31,    32,    33,    34,    35,    36,    37,    38,
02663       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02664       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02665        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02666       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02667        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02668       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02669        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02670       63,    64,    65,     0,     0,     0,     0,     0,     0,     0,
02671        0,  -618,     0,  -618,   248,  -618,     5,     6,     7,     8,
02672        9,     0,     0,     0,    10,    11,     0,     0,     0,    12,
02673        0,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02674        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02675        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02676      249,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02677       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02678       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02679        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02680        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02681        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02682        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02683        0,     0,     0,     0,     0,     0,     0,     0,     0,    63,
02684       64,    65,     0,     0,  -618,     4,     0,     5,     6,     7,
02685        8,     9,  -618,     0,  -618,    10,    11,     0,     0,     0,
02686       12,     0,    13,    14,    15,    16,    17,    18,    19,     0,
02687        0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
02688       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
02689       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
02690       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
02691       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02692        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02693       48,     0,     0,    49,    50,     0,    51,    52,     0,    53,
02694        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
02695       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02696        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02697       63,    64,    65,     0,     0,  -618,     0,     0,     0,     0,
02698        0,     0,     0,  -618,   248,  -618,     5,     6,     7,     8,
02699        9,     0,     0,  -618,    10,    11,     0,     0,     0,    12,
02700        0,    13,    14,    15,    16,    17,    18,    19,     0,     0,
02701        0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
02702        0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
02703      249,    31,    32,    33,    34,    35,    36,    37,    38,    39,
02704       40,     0,    41,    42,     0,    43,    44,    45,     0,    46,
02705       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02706        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
02707        0,     0,    49,    50,     0,    51,    52,     0,    53,     0,
02708        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02709        0,     0,     0,     0,     0,     0,     0,   248,     0,     5,
02710        6,     7,     8,     9,     0,     0,     0,    10,    11,    63,
02711       64,    65,    12,     0,    13,    14,    15,    16,    17,    18,
02712       19,     0,  -618,     0,  -618,     0,    20,    21,    22,    23,
02713       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
02714        0,    28,    29,   249,    31,    32,    33,    34,    35,    36,
02715       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02716       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02717        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02718        0,     0,    48,     0,     0,    49,    50,     0,    51,    52,
02719        0,    53,     0,     0,    54,    55,    56,    57,    58,    59,
02720       60,    61,    62,     0,  -618,     0,     0,     0,     0,     0,
02721        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02722       10,    11,    63,    64,    65,    12,     0,    13,    14,    15,
02723       16,    17,    18,    19,     0,  -618,     0,  -618,     0,    20,
02724       21,    22,    23,    24,    25,    26,     0,     0,   200,     0,
02725        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02726       34,    35,    36,    37,    38,    39,    40,   201,    41,    42,
02727        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02728        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02729        0,     0,     0,     0,     0,   202,     0,     0,   203,    50,
02730        0,    51,    52,     0,   204,   205,   206,    54,    55,    56,
02731       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02732        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02733        0,     0,     0,    10,    11,    63,   207,    65,    12,     0,
02734       13,    14,    15,    16,    17,    18,    19,     0,     0,     0,
02735      231,     0,    20,    21,    22,    23,    24,    25,    26,     0,
02736        0,    27,     0,     0,     0,     0,     0,     0,    29,     0,
02737        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02738        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02739        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02740        0,     0,     0,     0,     0,     0,     0,     0,   202,     0,
02741        0,   203,    50,     0,    51,    52,     0,     0,     0,     0,
02742       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02743        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02744        7,     0,     9,     0,     0,     0,    10,    11,    63,    64,
02745       65,    12,     0,    13,    14,    15,    16,    17,    18,    19,
02746        0,   302,     0,   303,     0,    20,    21,    22,    23,    24,
02747       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02748        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02749       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02750        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02751        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02752        0,   202,     0,     0,   203,    50,     0,    51,    52,     0,
02753        0,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02754       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02755        0,     5,     6,     7,     8,     9,     0,     0,     0,    10,
02756       11,    63,    64,    65,    12,     0,    13,    14,    15,    16,
02757       17,    18,    19,     0,     0,     0,   231,     0,    20,    21,
02758       22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
02759        0,     0,     0,    28,    29,    30,    31,    32,    33,    34,
02760       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02761       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02762        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02763        0,     0,     0,     0,    48,     0,     0,    49,    50,     0,
02764       51,    52,     0,    53,     0,     0,    54,    55,    56,    57,
02765       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02766        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02767        0,     0,    10,    11,    63,    64,    65,    12,     0,    13,
02768       14,    15,    16,    17,    18,    19,     0,   498,     0,     0,
02769        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02770       27,     0,     0,     0,     0,     0,    28,    29,   249,    31,
02771       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02772       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02773        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02774        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02775       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02776       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02777        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02778        0,     0,     0,     0,     0,     0,     0,    63,    64,    65,
02779        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02780      498,   118,   119,   120,   121,   122,   123,   124,   125,   126,
02781      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02782      137,   138,   139,   140,   141,     0,     0,     0,   142,   143,
02783      144,   384,   385,   386,   387,   149,   150,   151,     0,     0,
02784        0,     0,     0,   152,   153,   154,   155,   388,   389,   390,
02785      391,   160,    37,    38,   392,    40,     0,     0,     0,     0,
02786        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
02787      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
02788      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
02789        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
02790        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02791        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
02792      185,   186,   187,   188,     0,   189,   190,     0,     0,     0,
02793        0,     0,     0,   191,   393,   118,   119,   120,   121,   122,
02794      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02795      133,   134,   135,   136,   137,   138,   139,   140,   141,     0,
02796        0,     0,   142,   143,   144,   145,   146,   147,   148,   149,
02797      150,   151,     0,     0,     0,     0,     0,   152,   153,   154,
02798      155,   156,   157,   158,   159,   160,   280,   281,   161,   282,
02799        0,     0,     0,     0,     0,     0,     0,     0,   162,   163,
02800      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
02801      172,     0,     0,   173,   174,   175,   176,     0,     0,     0,
02802        0,     0,     0,     0,     0,     0,     0,   177,   178,     0,
02803        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02804        0,     0,     0,     0,     0,     0,     0,     0,   179,   180,
02805      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
02806      190,     0,     0,     0,     0,     0,     0,   191,   118,   119,
02807      120,   121,   122,   123,   124,   125,   126,   127,   128,   129,
02808      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
02809      140,   141,     0,     0,     0,   142,   143,   144,   145,   146,
02810      147,   148,   149,   150,   151,     0,     0,     0,     0,     0,
02811      152,   153,   154,   155,   156,   157,   158,   159,   160,   233,
02812        0,   161,     0,     0,     0,     0,     0,     0,     0,     0,
02813        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
02814        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
02815        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02816      177,   178,     0,     0,    55,     0,     0,     0,     0,     0,
02817        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02818        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
02819      188,     0,   189,   190,     0,     0,     0,     0,     0,     0,
02820      191,   118,   119,   120,   121,   122,   123,   124,   125,   126,
02821      127,   128,   129,   130,   131,   132,   133,   134,   135,   136,
02822      137,   138,   139,   140,   141,     0,     0,     0,   142,   143,
02823      144,   145,   146,   147,   148,   149,   150,   151,     0,     0,
02824        0,     0,     0,   152,   153,   154,   155,   156,   157,   158,
02825      159,   160,     0,     0,   161,     0,     0,     0,     0,     0,
02826        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
02827      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
02828      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
02829        0,     0,     0,   177,   178,     0,     0,    55,     0,     0,
02830        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02831        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
02832      185,   186,   187,   188,     0,   189,   190,     0,     0,     0,
02833        0,     0,     0,   191,   118,   119,   120,   121,   122,   123,
02834      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
02835      134,   135,   136,   137,   138,   139,   140,   141,     0,     0,
02836        0,   142,   143,   144,   145,   146,   147,   148,   149,   150,
02837      151,     0,     0,     0,     0,     0,   152,   153,   154,   155,
02838      156,   157,   158,   159,   160,     0,     0,   161,     0,     0,
02839        0,     0,     0,     0,     0,     0,     0,   162,   163,   164,
02840      165,   166,   167,   168,   169,   170,     0,     0,   171,   172,
02841        0,     0,   173,   174,   175,   176,     0,     0,     0,     0,
02842        0,     0,     0,     0,     0,     0,   177,   178,     0,     0,
02843        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02844        0,     0,     0,     0,     0,     0,     0,   179,   180,   181,
02845      182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
02846        5,     6,     7,     0,     9,     0,   191,     0,    10,    11,
02847        0,     0,     0,    12,     0,    13,    14,    15,   238,   239,
02848       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
02849       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02850        0,     0,     0,   268,     0,     0,    32,    33,    34,    35,
02851       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
02852       44,    45,     0,     0,     0,     0,     0,     0,     0,     0,
02853        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02854        0,     0,     0,   269,     0,     0,   203,    50,     0,    51,
02855       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
02856       59,    60,    61,    62,     0,     0,     0,     0,     0,     5,
02857        6,     7,     0,     9,     0,     0,     0,    10,    11,     0,
02858        0,     0,    12,   270,    13,    14,    15,   238,   239,    18,
02859       19,   271,     0,     0,     0,     0,   240,   241,   242,    23,
02860       24,    25,    26,     0,     0,   200,     0,     0,     0,     0,
02861        0,     0,   268,     0,     0,    32,    33,    34,    35,    36,
02862       37,    38,    39,    40,     0,    41,    42,     0,    43,    44,
02863       45,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02864        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02865        0,     0,   269,     0,     0,   203,    50,     0,    51,    52,
02866        0,     0,     0,     0,    54,    55,    56,    57,    58,    59,
02867       60,    61,    62,     0,     0,     0,     0,     0,     5,     6,
02868        7,     8,     9,     0,     0,     0,    10,    11,     0,     0,
02869        0,    12,   270,    13,    14,    15,    16,    17,    18,    19,
02870      518,     0,     0,     0,     0,    20,    21,    22,    23,    24,
02871       25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
02872       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
02873       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02874        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02875        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02876        0,    48,     0,     0,    49,    50,     0,    51,    52,     0,
02877       53,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02878       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02879        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02880       11,    63,    64,    65,    12,     0,    13,    14,    15,    16,
02881       17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
02882       22,    23,    24,    25,    26,     0,     0,   200,     0,     0,
02883        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02884       35,    36,    37,    38,    39,    40,   201,    41,    42,     0,
02885       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02886        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02887        0,     0,     0,     0,   202,     0,     0,   203,    50,     0,
02888       51,    52,     0,   204,   205,   206,    54,    55,    56,    57,
02889       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
02890        0,     0,     0,     0,     5,     6,     7,     8,     9,     0,
02891        0,     0,    10,    11,    63,   207,    65,    12,     0,    13,
02892       14,    15,    16,    17,    18,    19,     0,     0,     0,     0,
02893        0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
02894       27,     0,     0,     0,     0,     0,    28,    29,     0,    31,
02895       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
02896       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
02897        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02898        0,     0,     0,     0,     0,     0,     0,    48,     0,     0,
02899       49,    50,     0,    51,    52,     0,    53,     0,     0,    54,
02900       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
02901        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
02902        0,     9,     0,     0,     0,    10,    11,    63,    64,    65,
02903       12,     0,    13,    14,    15,   238,   239,    18,    19,     0,
02904        0,     0,     0,     0,   240,   241,   242,    23,    24,    25,
02905       26,     0,     0,   200,     0,     0,     0,     0,     0,     0,
02906       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
02907       39,    40,   201,    41,    42,     0,    43,    44,    45,     0,
02908       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
02909        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02910      202,     0,     0,   203,    50,     0,    51,    52,     0,   608,
02911      205,   206,    54,    55,    56,    57,    58,    59,    60,    61,
02912       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02913        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
02914       63,   207,    65,    12,     0,    13,    14,    15,   238,   239,
02915       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
02916       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
02917        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
02918       36,    37,    38,    39,    40,   201,    41,    42,     0,    43,
02919       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
02920        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02921        0,     0,     0,   202,     0,     0,   203,    50,     0,    51,
02922       52,     0,   204,   205,     0,    54,    55,    56,    57,    58,
02923       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
02924        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
02925        0,    10,    11,    63,   207,    65,    12,     0,    13,    14,
02926       15,   238,   239,    18,    19,     0,     0,     0,     0,     0,
02927      240,   241,   242,    23,    24,    25,    26,     0,     0,   200,
02928        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
02929       33,    34,    35,    36,    37,    38,    39,    40,   201,    41,
02930       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
02931        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02932        0,     0,     0,     0,     0,     0,   202,     0,     0,   203,
02933       50,     0,    51,    52,     0,     0,   205,   206,    54,    55,
02934       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
02935        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
02936        9,     0,     0,     0,    10,    11,    63,   207,    65,    12,
02937        0,    13,    14,    15,   238,   239,    18,    19,     0,     0,
02938        0,     0,     0,   240,   241,   242,    23,    24,    25,    26,
02939        0,     0,   200,     0,     0,     0,     0,     0,     0,    29,
02940        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
02941       40,   201,    41,    42,     0,    43,    44,    45,     0,    46,
02942       47,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02943        0,     0,     0,     0,     0,     0,     0,     0,     0,   202,
02944        0,     0,   203,    50,     0,    51,    52,     0,   608,   205,
02945        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
02946        0,     0,     0,     0,     0,     0,     0,     0,     0,     5,
02947        6,     7,     0,     9,     0,     0,     0,    10,    11,    63,
02948      207,    65,    12,     0,    13,    14,    15,   238,   239,    18,
02949       19,     0,     0,     0,     0,     0,   240,   241,   242,    23,
02950       24,    25,    26,     0,     0,   200,     0,     0,     0,     0,
02951        0,     0,    29,     0,     0,    32,    33,    34,    35,    36,
02952       37,    38,    39,    40,   201,    41,    42,     0,    43,    44,
02953       45,     0,    46,    47,     0,     0,     0,     0,     0,     0,
02954        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02955        0,     0,   202,     0,     0,   203,    50,     0,    51,    52,
02956        0,     0,   205,     0,    54,    55,    56,    57,    58,    59,
02957       60,    61,    62,     0,     0,     0,     0,     0,     0,     0,
02958        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
02959       10,    11,    63,   207,    65,    12,     0,    13,    14,    15,
02960       16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
02961       21,    22,    23,    24,    25,    26,     0,     0,   200,     0,
02962        0,     0,     0,     0,     0,    29,     0,     0,    32,    33,
02963       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
02964        0,    43,    44,    45,     0,    46,    47,     0,     0,     0,
02965        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02966        0,     0,     0,     0,     0,   202,     0,     0,   203,    50,
02967        0,    51,    52,     0,   512,     0,     0,    54,    55,    56,
02968       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
02969        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
02970        0,     0,     0,    10,    11,    63,   207,    65,    12,     0,
02971       13,    14,    15,   238,   239,    18,    19,     0,     0,     0,
02972        0,     0,   240,   241,   242,    23,    24,    25,    26,     0,
02973        0,   200,     0,     0,     0,     0,     0,     0,    29,     0,
02974        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
02975        0,    41,    42,     0,    43,    44,    45,     0,    46,    47,
02976        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02977        0,     0,     0,     0,     0,     0,     0,     0,   202,     0,
02978        0,   203,    50,     0,    51,    52,     0,   204,     0,     0,
02979       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
02980        0,     0,     0,     0,     0,     0,     0,     0,     5,     6,
02981        7,     0,     9,     0,     0,     0,    10,    11,    63,   207,
02982       65,    12,     0,    13,    14,    15,   238,   239,    18,    19,
02983        0,     0,     0,     0,     0,   240,   241,   242,    23,    24,
02984       25,    26,     0,     0,   200,     0,     0,     0,     0,     0,
02985        0,    29,     0,     0,    32,    33,    34,    35,    36,    37,
02986       38,    39,    40,     0,    41,    42,     0,    43,    44,    45,
02987        0,    46,    47,     0,     0,     0,     0,     0,     0,     0,
02988        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02989        0,   202,     0,     0,   203,    50,     0,    51,    52,     0,
02990      818,     0,     0,    54,    55,    56,    57,    58,    59,    60,
02991       61,    62,     0,     0,     0,     0,     0,     0,     0,     0,
02992        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
02993       11,    63,   207,    65,    12,     0,    13,    14,    15,   238,
02994      239,    18,    19,     0,     0,     0,     0,     0,   240,   241,
02995      242,    23,    24,    25,    26,     0,     0,   200,     0,     0,
02996        0,     0,     0,     0,    29,     0,     0,    32,    33,    34,
02997       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
02998       43,    44,    45,     0,    46,    47,     0,     0,     0,     0,
02999        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03000        0,     0,     0,     0,   202,     0,     0,   203,    50,     0,
03001       51,    52,     0,   512,     0,     0,    54,    55,    56,    57,
03002       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
03003        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
03004        0,     0,    10,    11,    63,   207,    65,    12,     0,    13,
03005       14,    15,   238,   239,    18,    19,     0,     0,     0,     0,
03006        0,   240,   241,   242,    23,    24,    25,    26,     0,     0,
03007      200,     0,     0,     0,     0,     0,     0,    29,     0,     0,
03008       32,    33,    34,    35,    36,    37,    38,    39,    40,     0,
03009       41,    42,     0,    43,    44,    45,     0,    46,    47,     0,
03010        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03011        0,     0,     0,     0,     0,     0,     0,   202,     0,     0,
03012      203,    50,     0,    51,    52,     0,   608,     0,     0,    54,
03013       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
03014        0,     0,     0,     0,     0,     0,     0,     5,     6,     7,
03015        0,     9,     0,     0,     0,    10,    11,    63,   207,    65,
03016       12,     0,    13,    14,    15,   238,   239,    18,    19,     0,
03017        0,     0,     0,     0,   240,   241,   242,    23,    24,    25,
03018       26,     0,     0,   200,     0,     0,     0,     0,     0,     0,
03019       29,     0,     0,    32,    33,    34,    35,    36,    37,    38,
03020       39,    40,     0,    41,    42,     0,    43,    44,    45,     0,
03021       46,    47,     0,     0,     0,     0,     0,     0,     0,     0,
03022        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03023      202,     0,     0,   203,    50,     0,    51,    52,     0,     0,
03024        0,     0,    54,    55,    56,    57,    58,    59,    60,    61,
03025       62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03026        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
03027       63,   207,    65,    12,     0,    13,    14,    15,    16,    17,
03028       18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
03029       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
03030        0,     0,     0,    29,     0,     0,    32,    33,    34,    35,
03031       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
03032       44,    45,     0,    46,    47,     0,     0,     0,     0,     0,
03033        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03034        0,     0,     0,   202,     0,     0,   203,    50,     0,    51,
03035       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
03036       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
03037        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
03038        0,    10,    11,    63,    64,    65,    12,     0,    13,    14,
03039       15,    16,    17,    18,    19,     0,     0,     0,     0,     0,
03040       20,    21,    22,    23,    24,    25,    26,     0,     0,   200,
03041        0,     0,     0,     0,     0,     0,    29,     0,     0,    32,
03042       33,    34,    35,    36,    37,    38,    39,    40,     0,    41,
03043       42,     0,    43,    44,    45,     0,    46,    47,     0,     0,
03044        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03045        0,     0,     0,     0,     0,     0,   202,     0,     0,   203,
03046       50,     0,    51,    52,     0,     0,     0,     0,    54,    55,
03047       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
03048        0,     0,     0,     0,     0,     0,     5,     6,     7,     0,
03049        9,     0,     0,     0,    10,    11,    63,   207,    65,    12,
03050        0,    13,    14,    15,   238,   239,    18,    19,     0,     0,
03051        0,     0,     0,   240,   241,   242,    23,    24,    25,    26,
03052        0,     0,   200,     0,     0,     0,     0,     0,     0,   268,
03053        0,     0,    32,    33,    34,    35,    36,    37,    38,    39,
03054       40,     0,    41,    42,     0,    43,    44,    45,     0,     0,
03055        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03056        0,     0,     0,     0,     0,     0,     0,     0,     0,   269,
03057        0,     0,   323,    50,     0,    51,    52,     0,   324,     0,
03058        0,    54,    55,    56,    57,    58,    59,    60,    61,    62,
03059        0,     0,     0,     0,     0,     5,     6,     7,     0,     9,
03060        0,     0,     0,    10,    11,     0,     0,     0,    12,   270,
03061       13,    14,    15,   238,   239,    18,    19,     0,     0,     0,
03062        0,     0,   240,   241,   242,    23,    24,    25,    26,     0,
03063        0,   200,     0,     0,     0,     0,     0,     0,   268,     0,
03064        0,    32,    33,    34,    35,    36,    37,    38,    39,    40,
03065        0,    41,    42,     0,    43,    44,    45,     0,     0,     0,
03066        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03067        0,     0,     0,     0,     0,     0,     0,     0,   365,     0,
03068        0,    49,    50,     0,    51,    52,     0,    53,     0,     0,
03069       54,    55,    56,    57,    58,    59,    60,    61,    62,     0,
03070        0,     0,     0,     0,     5,     6,     7,     0,     9,     0,
03071        0,     0,    10,    11,     0,     0,     0,    12,   270,    13,
03072       14,    15,   238,   239,    18,    19,     0,     0,     0,     0,
03073        0,   240,   241,   242,    23,    24,    25,    26,     0,     0,
03074      200,     0,     0,     0,     0,     0,     0,   268,     0,     0,
03075       32,    33,    34,   373,    36,    37,    38,   374,    40,     0,
03076       41,    42,     0,    43,    44,    45,     0,     0,     0,     0,
03077        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03078        0,     0,     0,     0,   375,     0,     0,   376,     0,     0,
03079      203,    50,     0,    51,    52,     0,     0,     0,     0,    54,
03080       55,    56,    57,    58,    59,    60,    61,    62,     0,     0,
03081        0,     0,     0,     5,     6,     7,     0,     9,     0,     0,
03082        0,    10,    11,     0,     0,     0,    12,   270,    13,    14,
03083       15,   238,   239,    18,    19,     0,     0,     0,     0,     0,
03084      240,   241,   242,    23,    24,    25,    26,     0,     0,   200,
03085        0,     0,     0,     0,     0,     0,   268,     0,     0,    32,
03086       33,    34,   373,    36,    37,    38,   374,    40,     0,    41,
03087       42,     0,    43,    44,    45,     0,     0,     0,     0,     0,
03088        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03089        0,     0,     0,     0,     0,     0,   376,     0,     0,   203,
03090       50,     0,    51,    52,     0,     0,     0,     0,    54,    55,
03091       56,    57,    58,    59,    60,    61,    62,     0,     0,     0,
03092        0,     0,     5,     6,     7,     0,     9,     0,     0,     0,
03093       10,    11,     0,     0,     0,    12,   270,    13,    14,    15,
03094      238,   239,    18,    19,     0,     0,     0,     0,     0,   240,
03095      241,   242,    23,    24,    25,    26,     0,     0,   200,     0,
03096        0,     0,     0,     0,     0,   268,     0,     0,    32,    33,
03097       34,    35,    36,    37,    38,    39,    40,     0,    41,    42,
03098        0,    43,    44,    45,     0,     0,     0,     0,     0,     0,
03099        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03100        0,     0,     0,     0,     0,   269,     0,     0,   323,    50,
03101        0,    51,    52,     0,     0,     0,     0,    54,    55,    56,
03102       57,    58,    59,    60,    61,    62,     0,     0,     0,     0,
03103        0,     5,     6,     7,     0,     9,     0,     0,     0,    10,
03104       11,     0,     0,     0,    12,   270,    13,    14,    15,   238,
03105      239,    18,    19,     0,     0,     0,     0,     0,   240,   241,
03106      242,    23,    24,    25,    26,     0,     0,   200,     0,     0,
03107        0,     0,     0,     0,   268,     0,     0,    32,    33,    34,
03108       35,    36,    37,    38,    39,    40,     0,    41,    42,     0,
03109       43,    44,    45,     0,     0,     0,     0,     0,     0,     0,
03110        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03111        0,     0,     0,     0,   894,     0,     0,   203,    50,     0,
03112       51,    52,     0,     0,     0,     0,    54,    55,    56,    57,
03113       58,    59,    60,    61,    62,     0,     0,     0,     0,     0,
03114        5,     6,     7,     0,     9,     0,     0,     0,    10,    11,
03115        0,     0,     0,    12,   270,    13,    14,    15,   238,   239,
03116       18,    19,     0,     0,     0,     0,     0,   240,   241,   242,
03117       23,    24,    25,    26,     0,     0,   200,     0,     0,     0,
03118        0,     0,     0,   268,     0,     0,    32,    33,    34,    35,
03119       36,    37,    38,    39,    40,     0,    41,    42,     0,    43,
03120       44,    45,     0,     0,     0,     0,     0,     0,     0,     0,
03121        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03122        0,     0,     0,   974,     0,     0,   203,    50,     0,    51,
03123       52,     0,     0,     0,     0,    54,    55,    56,    57,    58,
03124       59,    60,    61,    62,     0,     0,     0,     0,     0,     0,
03125      553,   554,     0,     0,   555,     0,     0,     0,     0,     0,
03126        0,     0,     0,   270,   162,   163,   164,   165,   166,   167,
03127      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
03128      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
03129        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
03130        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03131        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
03132      185,   186,   187,   188,     0,   189,   190,   561,   562,     0,
03133        0,   563,     0,   191,     0,     0,     0,     0,     0,     0,
03134        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
03135        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
03136        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03137      177,   178,     0,     0,     0,     0,     0,     0,     0,     0,
03138        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03139        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
03140      188,     0,   189,   190,   598,   562,     0,     0,   599,     0,
03141      191,     0,     0,     0,     0,     0,     0,     0,   162,   163,
03142      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
03143      172,     0,     0,   173,   174,   175,   176,     0,     0,     0,
03144        0,     0,     0,     0,     0,     0,     0,   177,   178,     0,
03145        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03146        0,     0,     0,     0,     0,     0,     0,     0,   179,   180,
03147      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
03148      190,   612,   554,     0,     0,   613,     0,   191,     0,     0,
03149        0,     0,     0,     0,     0,   162,   163,   164,   165,   166,
03150      167,   168,   169,   170,     0,     0,   171,   172,     0,     0,
03151      173,   174,   175,   176,     0,     0,     0,     0,     0,     0,
03152        0,     0,     0,     0,   177,   178,     0,     0,     0,     0,
03153        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03154        0,     0,     0,     0,     0,   179,   180,   181,   182,   183,
03155      184,   185,   186,   187,   188,     0,   189,   190,   615,   562,
03156        0,     0,   616,     0,   191,     0,     0,     0,     0,     0,
03157        0,     0,   162,   163,   164,   165,   166,   167,   168,   169,
03158      170,     0,     0,   171,   172,     0,     0,   173,   174,   175,
03159      176,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03160        0,   177,   178,     0,     0,     0,     0,     0,     0,     0,
03161        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03162        0,     0,   179,   180,   181,   182,   183,   184,   185,   186,
03163      187,   188,     0,   189,   190,   639,   554,     0,     0,   640,
03164        0,   191,     0,     0,     0,     0,     0,     0,     0,   162,
03165      163,   164,   165,   166,   167,   168,   169,   170,     0,     0,
03166      171,   172,     0,     0,   173,   174,   175,   176,     0,     0,
03167        0,     0,     0,     0,     0,     0,     0,     0,   177,   178,
03168        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03169        0,     0,     0,     0,     0,     0,     0,     0,     0,   179,
03170      180,   181,   182,   183,   184,   185,   186,   187,   188,     0,
03171      189,   190,   642,   562,     0,     0,   643,     0,   191,     0,
03172        0,     0,     0,     0,     0,     0,   162,   163,   164,   165,
03173      166,   167,   168,   169,   170,     0,     0,   171,   172,     0,
03174        0,   173,   174,   175,   176,     0,     0,     0,     0,     0,
03175        0,     0,     0,     0,     0,   177,   178,     0,     0,     0,
03176        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03177        0,     0,     0,     0,     0,     0,   179,   180,   181,   182,
03178      183,   184,   185,   186,   187,   188,     0,   189,   190,   727,
03179      554,     0,     0,   728,     0,   191,     0,     0,     0,     0,
03180        0,     0,     0,   162,   163,   164,   165,   166,   167,   168,
03181      169,   170,     0,     0,   171,   172,     0,     0,   173,   174,
03182      175,   176,     0,     0,     0,     0,     0,     0,     0,     0,
03183        0,     0,   177,   178,     0,     0,     0,     0,     0,     0,
03184        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03185        0,     0,     0,   179,   180,   181,   182,   183,   184,   185,
03186      186,   187,   188,     0,   189,   190,   730,   562,     0,     0,
03187      731,     0,   191,     0,     0,     0,     0,     0,     0,     0,
03188      162,   163,   164,   165,   166,   167,   168,   169,   170,     0,
03189        0,   171,   172,     0,     0,   173,   174,   175,   176,     0,
03190        0,     0,     0,     0,     0,     0,     0,     0,     0,   177,
03191      178,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03192        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03193      179,   180,   181,   182,   183,   184,   185,   186,   187,   188,
03194        0,   189,   190,   737,   554,     0,     0,   738,     0,   191,
03195        0,     0,     0,     0,     0,     0,     0,   162,   163,   164,
03196      165,   166,   167,   168,   169,   170,     0,     0,   171,   172,
03197        0,     0,   173,   174,   175,   176,     0,     0,     0,     0,
03198        0,     0,     0,     0,     0,     0,   177,   178,     0,     0,
03199        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03200        0,     0,     0,     0,     0,     0,     0,   179,   180,   181,
03201      182,   183,   184,   185,   186,   187,   188,     0,   189,   190,
03202     1000,   554,     0,     0,  1001,     0,   191,     0,     0,     0,
03203        0,     0,     0,     0,   162,   163,   164,   165,   166,   167,
03204      168,   169,   170,     0,     0,   171,   172,     0,     0,   173,
03205      174,   175,   176,     0,     0,     0,     0,     0,     0,     0,
03206        0,     0,     0,   177,   178,     0,     0,     0,     0,     0,
03207        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03208        0,     0,     0,     0,   179,   180,   181,   182,   183,   184,
03209      185,   186,   187,   188,     0,   189,   190,  1035,   554,     0,
03210        0,  1036,     0,   191,     0,     0,     0,     0,     0,     0,
03211        0,   162,   163,   164,   165,   166,   167,   168,   169,   170,
03212        0,     0,   171,   172,     0,     0,   173,   174,   175,   176,
03213        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03214      177,   178,     0,     0,     0,     0,     0,     0,     0,     0,
03215        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03216        0,   179,   180,   181,   182,   183,   184,   185,   186,   187,
03217      188,     0,   189,   190,  1038,   562,     0,     0,  1039,     0,
03218      191,     0,     0,     0,     0,     0,     0,     0,   162,   163,
03219      164,   165,   166,   167,   168,   169,   170,     0,     0,   171,
03220      172,     0,     0,   173,   174,   175,   176,     0,     0,     0,
03221        0,     0,     0,     0,     0,     0,     0,   177,   178,   327,
03222      328,   329,   330,   331,   332,   333,   334,   335,   336,   337,
03223      338,   339,     0,     0,   340,   341,     0,     0,   179,   180,
03224      181,   182,   183,   184,   185,   186,   187,   188,     0,   189,
03225      190,     0,     0,     0,     0,     0,     0,   191,     0,     0,
03226        0,     0,     0,     0,     0,   342,     0,   343,   344,   345,
03227      346,   347,   348,   349,   350,   351,   352,     0,     0,     0,
03228        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03229        0,     0,   231
03230 };
03231 
03232 static const yytype_int16 yycheck[] =
03233 {
03234        2,    96,    74,    55,    28,    67,    79,    50,   220,   230,
03235        8,   359,    27,   326,    29,     8,   326,    87,   354,   262,
03236       90,     8,   472,   266,   651,    16,    17,    22,    90,    20,
03237       28,   353,    53,   355,   255,    28,   614,     2,   259,     4,
03238      575,    28,    94,    86,    87,     4,   420,    90,   376,    51,
03239       52,     2,   594,     4,   440,   574,    67,   577,    79,    53,
03240      472,    90,   780,   641,   468,    16,    17,   788,    55,    20,
03241       91,    92,    93,   876,    16,    17,    49,   399,    20,    74,
03242      416,   715,    25,    64,   458,   719,    25,    13,    26,   668,
03243       25,    25,   412,   415,    25,   417,   250,    27,    49,    50,
03244      420,   874,    53,   508,    29,    76,   511,    94,    85,    51,
03245       25,   685,     0,    64,   518,    85,    61,   903,    16,    17,
03246       68,   443,    20,   776,    61,    25,    37,    38,    79,    13,
03247      139,   141,   141,    25,   470,    86,    87,    97,   907,    90,
03248       91,    92,    93,   770,   771,   130,   596,   118,    56,   471,
03249      803,   729,    13,    51,    52,   132,   133,    16,    17,   136,
03250      120,    20,   740,   133,    26,   110,   939,    37,    38,   323,
03251      286,   243,   288,   110,   290,   123,   124,   125,   294,    25,
03252      898,    52,    13,    13,   140,    56,   111,   230,   991,   232,
03253      252,   134,   130,   136,   736,   134,   140,   136,   271,   134,
03254      134,   422,   744,   134,   724,   426,   780,   657,   134,   139,
03255      431,   141,   214,   139,   788,   141,  1002,   429,   220,   134,
03256      993,   741,   685,   252,   945,   227,   447,    25,   807,   808,
03257      141,   452,   950,   224,   134,   226,   227,   307,   308,   309,
03258      310,   252,   134,  1012,   580,   657,   632,   874,   622,   876,
03259      271,  1024,   203,   268,    13,   139,   592,   141,     1,   581,
03260      670,    87,   672,   591,   307,   308,   309,   310,   130,   312,
03261      313,   593,    87,   224,   136,   226,   227,   250,   139,   230,
03262      141,   232,   224,   248,   226,   690,   237,   113,   134,  1007,
03263      360,   361,   696,   743,    28,   929,   517,   248,   113,   250,
03264      362,   621,   622,   324,    15,   136,    17,   886,   139,   139,
03265      141,   141,   939,   940,   134,   113,   378,   360,   361,   782,
03266      271,   141,   140,   786,   898,   845,   224,   847,   226,   903,
03267      324,   743,   375,   362,    49,   854,   134,   857,    85,   137,
03268      321,   306,   862,   141,    61,   326,   311,   306,    25,   140,
03269      323,   113,   354,   134,    61,   306,   307,   308,   309,   310,
03270      311,   312,   313,   354,   991,   224,   993,   226,   355,   485,
03271      321,   945,   323,   324,   117,   326,   492,   725,    87,   321,
03272      139,   134,   141,    61,   326,   964,   133,   697,   141,   931,
03273      107,    87,   109,   636,   929,   468,   139,  1024,   141,   611,
03274      107,   714,   109,   354,   113,   356,   926,   927,   113,   360,
03275      361,   134,   399,   437,   416,    87,   100,   113,   141,    85,
03276       87,   402,   403,   140,   375,   416,   428,   429,  1002,   107,
03277      417,   109,   110,   140,    85,   898,   113,   900,   440,   437,
03278      903,   113,   905,    87,   437,   518,   113,   468,   990,   134,
03279      437,   402,   403,    58,    26,    85,   443,   134,    56,  1037,
03280      137,    87,    61,    68,   141,   416,    65,   133,   470,   989,
03281       26,   136,    85,   883,   884,   440,   141,   113,   888,   470,
03282      890,   891,   133,    85,   471,   557,   936,   113,   203,   440,
03283       85,    96,    97,   565,    58,   869,   136,   518,   134,   450,
03284     1020,   113,  1022,   133,    68,   507,   508,    85,   107,   511,
03285      109,   573,   574,    85,   412,   120,   703,   468,    88,   470,
03286      133,   742,   237,   710,    61,   587,   134,   542,   600,    85,
03287      132,   133,    96,    97,    87,   250,   136,   132,   133,  1002,
03288      761,  1004,   134,    85,  1007,   560,  1009,    61,   760,   869,
03289      130,   685,   595,   774,   132,   133,   120,   455,   130,   136,
03290      132,   133,    85,   558,   637,    61,   568,   518,   136,   917,
03291      107,   566,   109,   110,   130,   923,   132,   133,   580,    61,
03292      136,   605,   625,    68,  1047,   995,   996,   997,   998,   580,
03293      592,   133,    68,   107,   581,   109,   110,    26,   600,   614,
03294      113,   592,   685,    59,    60,   600,   593,   605,   323,   611,
03295      133,   107,   605,   109,   110,   137,   637,   138,   605,   570,
03296       85,   572,   131,   696,    85,   107,   641,   109,   110,   580,
03297      632,    85,   704,   134,   576,  1045,    59,    60,    56,   711,
03298      861,   592,   110,   594,   595,   121,   122,   123,   124,   125,
03299       54,    87,   873,   748,   788,   110,    85,   791,    85,    63,
03300       64,    87,   732,    85,   666,   735,   668,   632,   133,    26,
03301      685,   733,   133,   110,   625,   696,   110,   113,   132,   133,
03302     1016,   632,     2,   745,     4,    85,   637,   113,   690,   732,
03303       14,    15,   735,    68,   746,  1017,    16,    17,   134,   782,
03304       20,   130,    94,   132,   133,   132,   133,   136,   134,   711,
03305      132,   133,   714,   715,   729,   717,   697,   719,    68,   700,
03306      701,    87,   134,   621,    17,   740,   707,   708,    85,    49,
03307       50,   139,   132,   133,    56,   686,    25,   134,   689,    85,
03308      691,   137,    85,   134,    64,   696,   697,   113,   131,   700,
03309      701,   130,   134,   134,   140,    85,   707,   708,   760,   746,
03310       52,   776,    54,    55,    56,    57,    86,    87,   134,   903,
03311       90,   905,   714,   130,   844,   132,   133,    85,   140,   136,
03312      801,   732,    85,   134,   735,   736,   132,   133,   803,   132,
03313      133,    85,   854,   744,   856,    52,   134,    54,    55,    56,
03314       57,   844,   132,   133,   113,   807,   808,    87,   134,    87,
03315       10,   945,     8,   947,    13,   898,   113,   900,   952,    87,
03316      903,   136,   905,   134,   132,   133,   777,   778,   134,   132,
03317      133,   131,    52,   113,    87,   113,   134,   839,   132,   133,
03318      842,   115,   134,    54,    55,   113,    57,   810,   811,   830,
03319      801,   134,    63,    64,   134,   570,   134,   572,    52,    52,
03320      113,    54,    55,    56,    57,   816,   134,   134,  1002,    52,
03321     1004,   134,   893,   138,    15,  1009,   134,   134,   134,   830,
03322      131,   134,   113,   203,   886,    40,    41,    42,    43,    44,
03323      841,   118,  1026,   844,   134,   916,    89,   848,   849,   134,
03324      134,   852,    95,   139,   224,   134,   226,   227,    10,   131,
03325      230,    10,   232,  1047,    88,   134,     9,   237,   134,  1002,
03326      137,  1004,    10,   131,  1007,   134,  1009,   929,   248,    52,
03327      250,    54,    55,    56,    57,    52,   134,    54,    55,    56,
03328       57,   892,   893,   134,    52,   134,    54,    55,    56,    57,
03329       56,   118,   131,   134,   134,   970,   108,   134,   134,   134,
03330       56,    52,   964,   134,  1047,   916,    89,   136,   134,   920,
03331      134,   686,    95,   136,   689,   134,   691,   450,    91,    93,
03332      931,    89,   711,  1019,   770,   685,   306,   307,   308,   309,
03333      310,   311,   312,   313,  1012,   749,  1018,    57,   961,   962,
03334       94,   321,   965,   323,   967,   968,   326,    99,   294,   936,
03335      782,   900,   898,   780,  1016,    -1,  1018,  1019,   396,    -1,
03336       -1,    -1,  1037,    16,    17,  1016,    -1,    20,    -1,   980,
03337     1017,   982,    -1,    -1,   354,    -1,   356,   988,    -1,   990,
03338      360,   361,    -1,    -1,    52,    -1,    54,    55,    56,    57,
03339       58,    -1,    -1,    46,    47,   375,    -1,    -1,    51,    52,
03340       68,    -1,   777,   778,    -1,  1016,    -1,  1030,  1031,  1032,
03341     1033,    64,    65,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03342       -1,    89,   402,   403,    -1,    -1,    -1,    -1,    96,    97,
03343     1053,    -1,    -1,    -1,    -1,    -1,   416,    -1,    -1,    -1,
03344       -1,   816,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03345      201,    -1,   120,   204,   205,   206,    -1,    -1,    -1,    -1,
03346      440,    -1,    -1,    -1,    -1,    -1,   841,    -1,    -1,    -1,
03347      450,    -1,    -1,   848,   849,    -1,    -1,   852,    52,    -1,
03348       54,    55,    56,    57,    58,    -1,    -1,     0,    -1,    -1,
03349      470,    -1,    -1,    -1,    68,     8,     9,    10,    -1,    -1,
03350       13,    14,    15,    68,    17,    -1,    -1,    -1,    -1,    -1,
03351       -1,    -1,    -1,    26,    27,    89,    -1,   892,    83,    84,
03352       -1,    95,    96,    97,    37,    38,    68,    40,    41,    42,
03353       43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03354       -1,    83,    84,    -1,    -1,   920,   120,    -1,   201,   123,
03355       -1,   204,   205,   206,   207,   120,   121,   122,   123,   124,
03356      125,    -1,    -1,    -1,    -1,    -1,    -1,   141,    -1,    -1,
03357      321,   224,    85,   226,   227,   326,   118,   119,   120,   121,
03358      122,   123,   124,   125,    -1,    -1,    68,    -1,    -1,    -1,
03359      570,    -1,   572,    -1,    -1,   108,    -1,    -1,    -1,    -1,
03360      580,    83,    84,    -1,    -1,   980,    -1,   982,    -1,    -1,
03361       -1,    -1,   592,   988,   594,   595,    -1,   130,   131,    -1,
03362      133,    -1,    -1,   136,   137,    -1,   139,    -1,   141,    -1,
03363       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,
03364      122,   123,   124,   125,    -1,   625,    -1,    -1,    -1,    -1,
03365       -1,    -1,   632,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03366      411,   412,    -1,    -1,    -1,    -1,    -1,    -1,   321,   420,
03367       -1,    -1,    -1,   326,   327,   328,   329,   330,   331,   332,
03368      333,   334,   335,   336,   337,   338,   339,   340,   341,   342,
03369      343,   344,   345,   346,   347,   348,   349,   350,   351,   352,
03370       -1,   354,    -1,    -1,   455,    -1,   686,   458,    -1,   689,
03371       -1,   691,    -1,    -1,    -1,    -1,    -1,   697,    -1,    -1,
03372      700,   701,    -1,    -1,    -1,    -1,    -1,   707,   708,    -1,
03373        2,    -1,     4,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03374       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   402,
03375      403,    -1,   732,    -1,    -1,   735,   736,   410,   411,   412,
03376       -1,   512,    -1,   416,   744,   418,   419,   420,    -1,    52,
03377       -1,    54,    55,    56,    57,    58,    -1,    49,    -1,    -1,
03378       -1,    53,    -1,    -1,    -1,    68,   439,    -1,    -1,    -1,
03379       -1,   444,    -1,    -1,    -1,    -1,    -1,   777,   778,    -1,
03380       -1,    -1,   455,    -1,    -1,   458,    89,    79,    -1,    -1,
03381       -1,    -1,    95,    96,    97,    -1,    -1,   470,    -1,    91,
03382       92,    93,    94,    -1,    -1,   576,    -1,    -1,    -1,    -1,
03383       -1,    -1,    -1,    -1,    -1,    -1,   816,   120,    -1,    -1,
03384      123,    -1,    -1,   496,   497,    -1,    -1,    -1,    -1,    -1,
03385      830,    -1,    -1,   136,    -1,    -1,    -1,   608,    -1,   512,
03386       -1,   841,    -1,    -1,   844,    -1,    -1,    -1,   848,   849,
03387      621,   622,   852,    52,    -1,    54,    55,    56,    57,    58,
03388       -1,     2,    -1,     4,    -1,    -1,    -1,    -1,    -1,    68,
03389       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   649,    -1,
03390       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03391       89,    -1,   892,    -1,    -1,    -1,    95,    96,    97,    -1,
03392       -1,    -1,    -1,   576,    -1,    -1,    -1,   580,    49,    -1,
03393       -1,   203,    53,    -1,    -1,    -1,    -1,    -1,    -1,   592,
03394      920,   120,   693,    52,   123,    54,    55,    56,    57,    58,
03395       -1,   931,    -1,    -1,    -1,   608,    -1,   136,    79,    68,
03396       -1,    -1,    -1,   714,    -1,   237,    -1,    -1,   621,   622,
03397       91,    92,    93,    94,    -1,    -1,   248,    -1,   250,    -1,
03398       89,    -1,    -1,    -1,    -1,    -1,    95,    96,    97,    -1,
03399       -1,    -1,    -1,    -1,    -1,    -1,   649,    -1,    -1,   271,
03400      980,    -1,   982,    -1,    -1,    -1,    -1,    -1,   988,    -1,
03401      990,   120,    -1,    -1,   123,    -1,   767,    -1,    -1,    52,
03402       -1,    54,    55,    56,    57,    58,    -1,    -1,    -1,    -1,
03403       -1,    -1,    -1,    -1,   306,    68,  1016,    -1,    -1,   311,
03404      693,    -1,    -1,    -1,   697,   698,    -1,   700,   701,    -1,
03405       -1,   323,   324,    -1,   707,   708,    89,    -1,    -1,    -1,
03406       -1,   714,    95,    96,    97,    -1,     2,   818,     4,    -1,
03407       -1,    -1,    -1,    -1,    -1,     2,    -1,     4,    -1,    -1,
03408       -1,    -1,   203,    -1,   356,    -1,    -1,   120,    -1,    -1,
03409      123,    52,    -1,    54,    55,    56,    57,    58,   751,    -1,
03410      851,    -1,   755,   756,    -1,   758,   759,    68,    -1,    -1,
03411       -1,    -1,    -1,    49,   767,    -1,   237,    53,   869,    -1,
03412       -1,    -1,    49,    -1,    -1,    -1,    -1,   248,    89,   250,
03413       -1,    -1,    -1,    -1,    -1,    96,    97,    -1,    -1,    -1,
03414       -1,    -1,    -1,    79,    -1,    -1,    -1,    -1,    -1,    -1,
03415      271,    -1,    -1,    -1,    -1,    91,    92,    93,    -1,   120,
03416       -1,    -1,    -1,    -1,    91,   818,    -1,    -1,   440,   822,
03417       -1,    -1,    -1,    -1,    -1,    -1,    -1,   830,   450,    -1,
03418       -1,    -1,    -1,    -1,    -1,   306,    -1,    -1,    -1,    -1,
03419      311,    -1,    -1,    -1,    -1,    -1,   468,    -1,   851,    -1,
03420       -1,    -1,   323,   324,    68,    69,    70,    71,    72,    73,
03421       74,    75,    -1,    77,    78,   868,   869,    -1,    -1,    83,
03422       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03423       -1,    -1,    -1,    -1,    -1,   356,    -1,    -1,    -1,    -1,
03424       -1,    -1,    -1,     2,    -1,     4,   518,    -1,    -1,    -1,
03425       -1,    -1,   116,   117,   118,   119,   120,   121,   122,   123,
03426      124,   125,    -1,    -1,    -1,    -1,    -1,   203,    -1,    -1,
03427       -1,    -1,    -1,    -1,    -1,    -1,   203,    -1,    -1,    -1,
03428       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03429       49,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   570,    -1,
03430      572,   237,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03431      237,    -1,   248,    -1,   250,    -1,    -1,    -1,    -1,   440,
03432       -1,   248,   594,   250,    -1,    -1,    -1,    -1,    -1,   450,
03433       -1,    -1,    -1,    -1,    -1,   271,    -1,    -1,    -1,    -1,
03434       -1,    -1,    -1,    -1,    -1,    -1,    -1,   468,    -1,    -1,
03435       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03436      632,    -1,    -1,  1016,    -1,   637,    -1,    -1,    -1,    -1,
03437      306,    -1,    -1,    -1,    -1,   311,    -1,    -1,    -1,   306,
03438       -1,    -1,    -1,    -1,   311,    -1,    -1,   323,   324,    -1,
03439       -1,    -1,    -1,    -1,    -1,    -1,   323,   518,    -1,   326,
03440       -1,    -1,    -1,    -1,    -1,    -1,    -1,    44,    -1,    -1,
03441       -1,    -1,    -1,    -1,   686,    -1,    -1,   689,    -1,   691,
03442      356,    -1,    -1,    -1,   696,    -1,    -1,    -1,    -1,   356,
03443       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03444       77,    78,    79,    80,   203,    -1,    83,    84,    -1,   570,
03445       -1,   572,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03446       -1,    -1,    -1,    -1,   736,    -1,    -1,    -1,    -1,    -1,
03447       -1,    -1,   744,   594,    -1,    -1,    -1,   114,   237,   116,
03448      117,   118,   119,   120,   121,   122,   123,   124,   125,   248,
03449       -1,   250,    -1,    -1,    -1,    -1,    -1,   134,    -1,    -1,
03450       -1,    -1,    -1,    -1,   440,   777,   778,    -1,    -1,    -1,
03451       -1,   632,    -1,   440,   450,    -1,   637,    -1,    -1,    -1,
03452       -1,    -1,    -1,   450,    -1,    -1,    -1,    -1,    -1,   801,
03453       -1,    -1,   468,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03454       -1,    -1,    -1,    -1,   816,    -1,    -1,   306,    -1,    -1,
03455       -1,    -1,   311,    -1,    -1,    -1,    -1,    68,    69,    70,
03456       71,    72,    73,    74,   323,   686,    77,    78,   689,   841,
03457      691,    -1,    83,    84,    -1,   696,   848,   849,    -1,    -1,
03458      852,    -1,   518,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03459       -1,    -1,    -1,    -1,    -1,    -1,    -1,   356,    -1,    -1,
03460       -1,    -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,
03461      121,   122,   123,   124,   125,   736,    -1,    -1,    -1,    -1,
03462      892,   893,    -1,   744,    -1,    -1,    -1,    -1,    -1,    -1,
03463       -1,    -1,    -1,    -1,   570,    -1,   572,    -1,    -1,    -1,
03464       -1,    -1,    -1,   570,   916,   572,    -1,    -1,   920,    -1,
03465       -1,    -1,    -1,    -1,    -1,    -1,   777,   778,   594,   931,
03466       -1,    -1,    -1,    -1,    -1,    -1,    -1,   594,    -1,    -1,
03467       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03468      801,   440,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03469       -1,   450,    -1,    -1,    -1,   816,   632,    -1,    -1,    -1,
03470       -1,   637,    -1,    -1,    -1,   632,    -1,    -1,   980,    -1,
03471      982,    -1,    -1,    -1,    -1,    -1,   988,    -1,   990,    -1,
03472      841,    -1,    -1,    -1,    -1,    -1,    -1,   848,   849,    -1,
03473       -1,   852,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03474      676,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    44,
03475      686,    -1,    -1,   689,    -1,   691,    -1,    -1,    -1,   686,
03476      696,    -1,   689,    -1,   691,    -1,    -1,    -1,    -1,    -1,
03477      697,   892,   893,    68,    69,    70,    71,    72,    73,    74,
03478       75,    76,    77,    78,    79,    80,    -1,    -1,    83,    84,
03479       -1,    -1,    -1,    -1,    -1,   916,    -1,    -1,    -1,   920,
03480      736,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   744,   736,
03481      931,   570,    -1,   572,    -1,    -1,    -1,   744,    -1,   114,
03482       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
03483      125,    -1,    -1,    -1,    -1,   594,    -1,    -1,    -1,    -1,
03484       -1,   777,   778,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03485      777,   778,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   980,
03486       -1,   982,    -1,    -1,    -1,   801,    -1,   988,    44,   990,
03487       -1,    -1,    -1,   632,    -1,    -1,    -1,    -1,    -1,    -1,
03488      816,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   816,
03489       -1,    -1,    68,    69,    70,    71,    72,    73,    74,    75,
03490       76,    77,    78,    79,    80,   841,    -1,    83,    84,    -1,
03491       -1,    -1,   848,   849,   841,    -1,   852,    -1,    -1,    -1,
03492       -1,   848,   849,    -1,    -1,   852,    -1,   686,    -1,    -1,
03493      689,    -1,   691,    -1,    -1,    -1,    -1,    -1,   114,    -1,
03494      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
03495       -1,    -1,    -1,    -1,    -1,    -1,   892,   893,    68,    69,
03496       70,    71,    72,    73,    74,   892,    -1,    77,    78,    -1,
03497       -1,    -1,    -1,    83,    84,    -1,    -1,   736,    -1,    -1,
03498      916,    -1,    -1,    -1,   920,   744,    -1,    -1,    -1,   916,
03499       -1,    -1,    -1,   920,    -1,   931,    -1,    -1,    -1,    -1,
03500       -1,    -1,    -1,    -1,   931,    -1,   116,   117,   118,   119,
03501      120,   121,   122,   123,   124,   125,    -1,    -1,   777,   778,
03502       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03503       78,    79,    80,    -1,    -1,    83,    84,    -1,    -1,    -1,
03504       -1,    -1,    -1,    -1,   980,    -1,   982,    -1,    -1,    -1,
03505       -1,    -1,   988,   980,   990,   982,    -1,   816,    -1,    -1,
03506       -1,   988,    -1,   990,    -1,    -1,   114,    -1,   116,   117,
03507      118,   119,   120,   121,   122,   123,   124,   125,    -1,    -1,
03508       -1,    -1,   841,    -1,    -1,    -1,    -1,    -1,    -1,   848,
03509      849,     0,     1,   852,     3,     4,     5,     6,     7,    -1,
03510       -1,    -1,    11,    12,    -1,    -1,    -1,    16,    -1,    18,
03511       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03512       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03513       39,    -1,    -1,   892,    -1,    -1,    45,    46,    47,    48,
03514       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03515       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03516       -1,   920,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03517       -1,    -1,   931,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03518       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03519       99,   100,   101,   102,   103,   104,   105,   106,     0,    -1,
03520       -1,    -1,    -1,    -1,    -1,    -1,     8,     9,    10,    -1,
03521       -1,    13,    14,    15,    -1,    17,    -1,   126,   127,   128,
03522       -1,   980,    -1,   982,    26,    27,    28,    29,    -1,   988,
03523      139,   990,   141,    -1,    -1,    37,    38,    -1,    40,    41,
03524       42,    43,    44,    -1,    -1,    68,    69,    70,    71,    72,
03525       73,    74,    75,    76,    77,    78,    79,    80,    -1,    -1,
03526       83,    84,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03527       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03528       -1,    83,    84,    85,    -1,    87,    88,    -1,    -1,    -1,
03529       -1,    -1,    94,   116,   117,   118,   119,   120,   121,   122,
03530      123,   124,   125,    -1,    -1,    -1,   108,    -1,    -1,   111,
03531       -1,   113,   114,   115,   116,   117,   118,   119,   120,   121,
03532      122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,   131,
03533      132,   133,   134,     0,    -1,   137,   138,   139,    -1,   141,
03534       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03535       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    25,    -1,
03536       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03537       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03538       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03539       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03540       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03541       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03542       87,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
03543       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03544       -1,   108,    -1,    -1,   111,    -1,   113,   114,   115,   116,
03545      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03546       -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,    -1,
03547      137,   138,   139,    -1,   141,    -1,     8,     9,    10,    -1,
03548       -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03549       -1,    -1,    -1,    25,    -1,    27,    28,    29,    -1,    -1,
03550       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03551       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03552       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03553       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03554       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03555       -1,    83,    84,    85,    -1,    87,    88,    -1,    -1,    -1,
03556       -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03557       -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,   111,
03558       -1,   113,   114,   115,   116,   117,   118,   119,   120,   121,
03559      122,   123,   124,   125,    -1,    -1,    -1,    -1,    -1,   131,
03560      132,   133,   134,     0,    -1,   137,   138,   139,    -1,   141,
03561       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03562       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    26,
03563       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03564       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03565       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03566       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03567       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03568       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03569       -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
03570       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03571       -1,   108,    -1,    -1,   111,    -1,    -1,   114,   115,   116,
03572      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03573       -1,    -1,    -1,   130,   131,   132,   133,   134,     0,    -1,
03574      137,   138,   139,    -1,   141,    -1,     8,     9,    10,    -1,
03575       -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03576       -1,    -1,    -1,    -1,    26,    27,    28,    29,    -1,    -1,
03577       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03578       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03579       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03580       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03581       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03582       -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,    -1,
03583       -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03584       -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,   111,
03585       -1,    -1,   114,   115,   116,   117,   118,   119,   120,   121,
03586      122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,   131,
03587      132,   133,   134,     0,    -1,   137,   138,   139,    -1,   141,
03588       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03589       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03590       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03591       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03592       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03593       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03594       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03595       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03596       87,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
03597       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03598       -1,   108,    -1,    -1,   111,    -1,   113,   114,   115,   116,
03599      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03600       -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,    -1,
03601      137,   138,   139,    -1,   141,    -1,     8,     9,    10,    -1,
03602       -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03603       -1,    -1,    -1,    -1,    26,    27,    28,    -1,    -1,    -1,
03604       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03605       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03606       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03607       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03608       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03609       -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,    -1,
03610       -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03611       -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,    -1,
03612       -1,    -1,   114,    -1,   116,   117,   118,   119,   120,   121,
03613      122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,   131,
03614      132,   133,   134,     0,   136,   137,   138,   139,    -1,   141,
03615       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03616       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03617       27,    28,    29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03618       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03619       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03620       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03621       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03622       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03623       -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
03624       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03625       -1,   108,    -1,    -1,   111,    -1,    -1,   114,   115,   116,
03626      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03627       -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,    -1,
03628      137,   138,   139,    -1,   141,    -1,     8,     9,    10,    -1,
03629       -1,    13,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03630       -1,    -1,    -1,    -1,    26,    27,    28,    -1,    -1,    -1,
03631       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03632       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03633       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03634       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03635       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03636       -1,    83,    84,    85,    -1,    -1,    88,    -1,    -1,    -1,
03637       -1,    -1,    94,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03638       -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,    -1,
03639       -1,    -1,   114,    -1,   116,   117,   118,   119,   120,   121,
03640      122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,   131,
03641      132,   133,   134,     0,   136,   137,   138,   139,    -1,   141,
03642       -1,     8,     9,    10,    -1,    -1,    13,    14,    15,    -1,
03643       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03644       27,    28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03645       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03646       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03647       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03648       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03649       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03650       -1,    88,    -1,    -1,    -1,    -1,    -1,    94,    -1,    -1,
03651       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03652       -1,   108,    -1,    -1,    -1,    -1,    -1,   114,    -1,   116,
03653      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03654       -1,    -1,    -1,    -1,   131,   132,   133,   134,     0,   136,
03655      137,   138,   139,    -1,   141,    -1,     8,     9,    10,    -1,
03656       -1,    -1,    14,    15,    -1,    17,    -1,    -1,    -1,    -1,
03657       -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,
03658       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
03659       42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03660       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03661       -1,    -1,    -1,    -1,    -1,    -1,    68,    69,    70,    71,
03662       72,    73,    74,    75,    76,    77,    78,    79,    80,    -1,
03663       -1,    83,    84,    85,    -1,    87,    -1,    -1,    -1,    -1,
03664       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03665       -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,    -1,
03666       -1,   113,   114,    -1,   116,   117,   118,   119,   120,   121,
03667      122,   123,   124,   125,    -1,    -1,    -1,    -1,   130,   131,
03668      132,   133,   134,     0,    -1,   137,    -1,   139,    -1,   141,
03669       -1,     8,     9,    10,    -1,    -1,    -1,    14,    15,    -1,
03670       17,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03671       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03672       37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
03673       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03674       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03675       -1,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03676       77,    78,    79,    80,    -1,    -1,    83,    84,    85,    -1,
03677       87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03678       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03679       -1,   108,    -1,    -1,    -1,    -1,   113,   114,    -1,   116,
03680      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
03681       -1,    -1,    -1,    -1,   131,   132,   133,   134,    -1,    -1,
03682      137,    -1,   139,     1,   141,     3,     4,     5,     6,     7,
03683        8,     9,    10,    11,    12,    -1,    -1,    15,    16,    -1,
03684       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03685       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03686       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03687       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03688       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03689       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03690       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03691       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03692       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03693       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03694       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,
03695      128,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03696       -1,   139,     1,   141,     3,     4,     5,     6,     7,    -1,
03697       -1,    10,    11,    12,    -1,    14,    15,    16,    -1,    18,
03698       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03699       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03700       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03701       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03702       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03703       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03704       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03705       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03706       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03707       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03708       -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,
03709       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03710      139,     1,   141,     3,     4,     5,     6,     7,    -1,    -1,
03711       10,    11,    12,    -1,    -1,    15,    16,    17,    18,    19,
03712       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
03713       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
03714       -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
03715       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
03716       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
03717       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03718       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
03719       90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,
03720      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
03721       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03722       -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,    -1,
03723       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   139,
03724        1,   141,     3,     4,     5,     6,     7,    -1,    -1,    10,
03725       11,    12,    -1,    -1,    15,    16,    -1,    18,    19,    20,
03726       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
03727       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03728       -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
03729       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
03730       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03731       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03732       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03733       -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,   100,
03734      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03735       -1,    -1,    -1,     1,    -1,     3,     4,     5,     6,     7,
03736       -1,     9,    10,    11,    12,   126,   127,   128,    16,    -1,
03737       18,    19,    20,    21,    22,    23,    24,    -1,   139,    -1,
03738      141,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03739       -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03740       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03741       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03742       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03743       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03744       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
03745       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03746       -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,     4,
03747        5,     6,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03748      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03749       -1,   139,    -1,   141,    -1,    30,    31,    32,    33,    34,
03750       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03751       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03752       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03753       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03754       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03755       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03756       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03757      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03758       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03759       -1,   126,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
03760       -1,    -1,   137,    -1,   139,     1,   141,     3,     4,     5,
03761        6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,
03762       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03763       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03764       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03765       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03766       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03767       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03768       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03769       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03770       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03771      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03772       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03773      126,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03774       -1,   137,    -1,   139,     1,   141,     3,     4,     5,     6,
03775        7,    -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,
03776       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03777       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03778       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03779       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03780       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03781       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03782       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03783       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03784       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03785       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03786       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,
03787      127,   128,    -1,    -1,   131,     1,    -1,     3,     4,     5,
03788        6,     7,   139,    -1,   141,    11,    12,    -1,    -1,    -1,
03789       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
03790       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
03791       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
03792       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
03793       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
03794       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03795       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03796       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
03797       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
03798      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03799       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03800      126,   127,   128,    -1,    -1,   131,    -1,    -1,    -1,    -1,
03801       -1,    -1,    -1,   139,     1,   141,     3,     4,     5,     6,
03802        7,    -1,    -1,    10,    11,    12,    -1,    -1,    -1,    16,
03803       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
03804       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
03805       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
03806       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
03807       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    66,
03808       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03809       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
03810       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
03811       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03812       -1,    -1,    -1,    -1,    -1,    -1,    -1,     1,    -1,     3,
03813        4,     5,     6,     7,    -1,    -1,    -1,    11,    12,   126,
03814      127,   128,    16,    -1,    18,    19,    20,    21,    22,    23,
03815       24,    -1,   139,    -1,   141,    -1,    30,    31,    32,    33,
03816       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03817       -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
03818       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03819       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
03820       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03821       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03822       -1,    95,    -1,    -1,    98,    99,   100,   101,   102,   103,
03823      104,   105,   106,    -1,   108,    -1,    -1,    -1,    -1,    -1,
03824       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
03825       11,    12,   126,   127,   128,    16,    -1,    18,    19,    20,
03826       21,    22,    23,    24,    -1,   139,    -1,   141,    -1,    30,
03827       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
03828       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
03829       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
03830       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
03831       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03832       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
03833       -1,    92,    93,    -1,    95,    96,    97,    98,    99,   100,
03834      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
03835       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
03836       -1,    -1,    -1,    11,    12,   126,   127,   128,    16,    -1,
03837       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
03838      141,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
03839       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
03840       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03841       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
03842       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03843       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
03844       -1,    89,    90,    -1,    92,    93,    -1,    -1,    -1,    -1,
03845       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
03846       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03847        5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,
03848      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
03849       -1,   139,    -1,   141,    -1,    30,    31,    32,    33,    34,
03850       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03851       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
03852       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03853       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03854       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03855       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03856       -1,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03857      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03858       -1,     3,     4,     5,     6,     7,    -1,    -1,    -1,    11,
03859       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03860       22,    23,    24,    -1,    -1,    -1,   141,    -1,    30,    31,
03861       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03862       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03863       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
03864       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03865       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03866       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03867       92,    93,    -1,    95,    -1,    -1,    98,    99,   100,   101,
03868      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03869       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03870       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03871       19,    20,    21,    22,    23,    24,    -1,   139,    -1,    -1,
03872       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03873       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03874       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03875       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
03876       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03877       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
03878       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
03879       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
03880       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03881       -1,    -1,    -1,    -1,    -1,    -1,    -1,   126,   127,   128,
03882       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03883      139,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03884       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03885       22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
03886       32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
03887       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03888       52,    53,    54,    55,    56,    57,    -1,    -1,    -1,    -1,
03889       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
03890       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03891       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03892       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
03893       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03894       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
03895      122,   123,   124,   125,    -1,   127,   128,    -1,    -1,    -1,
03896       -1,    -1,    -1,   135,   136,     3,     4,     5,     6,     7,
03897        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03898       18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
03899       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
03900       38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
03901       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
03902       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
03903       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
03904       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
03905       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,
03906       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03907       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,
03908      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
03909      128,    -1,    -1,    -1,    -1,    -1,    -1,   135,     3,     4,
03910        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
03911       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03912       25,    26,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03913       35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
03914       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03915       -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03916       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
03917       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
03918       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03919       95,    96,    -1,    -1,    99,    -1,    -1,    -1,    -1,    -1,
03920       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03921       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
03922      125,    -1,   127,   128,    -1,    -1,    -1,    -1,    -1,    -1,
03923      135,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03924       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03925       22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
03926       32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
03927       -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
03928       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
03929       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
03930       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
03931       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03932       -1,    -1,    -1,    95,    96,    -1,    -1,    99,    -1,    -1,
03933       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03934       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
03935      122,   123,   124,   125,    -1,   127,   128,    -1,    -1,    -1,
03936       -1,    -1,    -1,   135,     3,     4,     5,     6,     7,     8,
03937        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03938       19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
03939       -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03940       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
03941       49,    50,    51,    52,    53,    -1,    -1,    56,    -1,    -1,
03942       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,
03943       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
03944       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
03945       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,
03946       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03947       -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,
03948      119,   120,   121,   122,   123,   124,   125,    -1,   127,   128,
03949        3,     4,     5,    -1,     7,    -1,   135,    -1,    11,    12,
03950       -1,    -1,    -1,    16,    -1,    18,    19,    20,    21,    22,
03951       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
03952       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
03953       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
03954       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
03955       63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03956       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03957       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
03958       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
03959      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,     3,
03960        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,    -1,
03961       -1,    -1,    16,   126,    18,    19,    20,    21,    22,    23,
03962       24,   134,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
03963       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
03964       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
03965       54,    55,    56,    57,    -1,    59,    60,    -1,    62,    63,
03966       64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03967       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03968       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
03969       -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,   103,
03970      104,   105,   106,    -1,    -1,    -1,    -1,    -1,     3,     4,
03971        5,     6,     7,    -1,    -1,    -1,    11,    12,    -1,    -1,
03972       -1,    16,   126,    18,    19,    20,    21,    22,    23,    24,
03973      134,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
03974       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
03975       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
03976       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
03977       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03978       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03979       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
03980       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
03981      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03982       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
03983       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
03984       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
03985       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
03986       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
03987       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03988       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
03989       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03990       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
03991       92,    93,    -1,    95,    96,    97,    98,    99,   100,   101,
03992      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
03993       -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,    -1,
03994       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
03995       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
03996       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
03997       39,    -1,    -1,    -1,    -1,    -1,    45,    46,    -1,    48,
03998       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
03999       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
04000       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04001       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
04002       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
04003       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
04004       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
04005       -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,   128,
04006       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
04007       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
04008       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
04009       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
04010       56,    57,    58,    59,    60,    -1,    62,    63,    64,    -1,
04011       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04012       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04013       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,
04014       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
04015      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04016        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04017      126,   127,   128,    16,    -1,    18,    19,    20,    21,    22,
04018       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04019       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04020       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04021       53,    54,    55,    56,    57,    58,    59,    60,    -1,    62,
04022       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
04023       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04024       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
04025       93,    -1,    95,    96,    -1,    98,    99,   100,   101,   102,
04026      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
04027       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04028       -1,    11,    12,   126,   127,   128,    16,    -1,    18,    19,
04029       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04030       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04031       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04032       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
04033       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
04034       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04035       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
04036       90,    -1,    92,    93,    -1,    -1,    96,    97,    98,    99,
04037      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
04038       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
04039        7,    -1,    -1,    -1,    11,    12,   126,   127,   128,    16,
04040       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
04041       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
04042       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
04043       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
04044       57,    58,    59,    60,    -1,    62,    63,    64,    -1,    66,
04045       67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04046       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
04047       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    96,
04048       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
04049       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
04050        4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,
04051      127,   128,    16,    -1,    18,    19,    20,    21,    22,    23,
04052       24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
04053       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
04054       -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,    53,
04055       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
04056       64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,
04057       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04058       -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,
04059       -1,    -1,    96,    -1,    98,    99,   100,   101,   102,   103,
04060      104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04061       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
04062       11,    12,   126,   127,   128,    16,    -1,    18,    19,    20,
04063       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
04064       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
04065       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
04066       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
04067       -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,
04068       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04069       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
04070       -1,    92,    93,    -1,    95,    -1,    -1,    98,    99,   100,
04071      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
04072       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
04073       -1,    -1,    -1,    11,    12,   126,   127,   128,    16,    -1,
04074       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
04075       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
04076       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
04077       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
04078       -1,    59,    60,    -1,    62,    63,    64,    -1,    66,    67,
04079       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04080       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
04081       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
04082       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
04083       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
04084        5,    -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,
04085      128,    16,    -1,    18,    19,    20,    21,    22,    23,    24,
04086       -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
04087       35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
04088       -1,    46,    -1,    -1,    49,    50,    51,    52,    53,    54,
04089       55,    56,    57,    -1,    59,    60,    -1,    62,    63,    64,
04090       -1,    66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04091       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04092       -1,    86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,
04093       95,    -1,    -1,    98,    99,   100,   101,   102,   103,   104,
04094      105,   106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04095       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
04096       12,   126,   127,   128,    16,    -1,    18,    19,    20,    21,
04097       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
04098       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
04099       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
04100       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
04101       62,    63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,
04102       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04103       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
04104       92,    93,    -1,    95,    -1,    -1,    98,    99,   100,   101,
04105      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
04106       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04107       -1,    -1,    11,    12,   126,   127,   128,    16,    -1,    18,
04108       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04109       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04110       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04111       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04112       59,    60,    -1,    62,    63,    64,    -1,    66,    67,    -1,
04113       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04114       -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
04115       89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,    98,
04116       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
04117       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
04118       -1,     7,    -1,    -1,    -1,    11,    12,   126,   127,   128,
04119       16,    -1,    18,    19,    20,    21,    22,    23,    24,    -1,
04120       -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
04121       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
04122       46,    -1,    -1,    49,    50,    51,    52,    53,    54,    55,
04123       56,    57,    -1,    59,    60,    -1,    62,    63,    64,    -1,
04124       66,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04125       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04126       86,    -1,    -1,    89,    90,    -1,    92,    93,    -1,    -1,
04127       -1,    -1,    98,    99,   100,   101,   102,   103,   104,   105,
04128      106,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04129        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04130      126,   127,   128,    16,    -1,    18,    19,    20,    21,    22,
04131       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04132       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04133       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04134       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
04135       63,    64,    -1,    66,    67,    -1,    -1,    -1,    -1,    -1,
04136       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04137       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
04138       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
04139      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
04140       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04141       -1,    11,    12,   126,   127,   128,    16,    -1,    18,    19,
04142       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04143       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04144       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04145       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04146       60,    -1,    62,    63,    64,    -1,    66,    67,    -1,    -1,
04147       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04148       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
04149       90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,
04150      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
04151       -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,
04152        7,    -1,    -1,    -1,    11,    12,   126,   127,   128,    16,
04153       -1,    18,    19,    20,    21,    22,    23,    24,    -1,    -1,
04154       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
04155       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,
04156       -1,    -1,    49,    50,    51,    52,    53,    54,    55,    56,
04157       57,    -1,    59,    60,    -1,    62,    63,    64,    -1,    -1,
04158       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04159       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
04160       -1,    -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,
04161       -1,    98,    99,   100,   101,   102,   103,   104,   105,   106,
04162       -1,    -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,
04163       -1,    -1,    -1,    11,    12,    -1,    -1,    -1,    16,   126,
04164       18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
04165       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
04166       -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,
04167       -1,    49,    50,    51,    52,    53,    54,    55,    56,    57,
04168       -1,    59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,
04169       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04170       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,
04171       -1,    89,    90,    -1,    92,    93,    -1,    95,    -1,    -1,
04172       98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
04173       -1,    -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,
04174       -1,    -1,    11,    12,    -1,    -1,    -1,    16,   126,    18,
04175       19,    20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
04176       -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
04177       39,    -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,
04178       49,    50,    51,    52,    53,    54,    55,    56,    57,    -1,
04179       59,    60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,
04180       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04181       -1,    -1,    -1,    -1,    83,    -1,    -1,    86,    -1,    -1,
04182       89,    90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,
04183       99,   100,   101,   102,   103,   104,   105,   106,    -1,    -1,
04184       -1,    -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,
04185       -1,    11,    12,    -1,    -1,    -1,    16,   126,    18,    19,
04186       20,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
04187       30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
04188       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,
04189       50,    51,    52,    53,    54,    55,    56,    57,    -1,    59,
04190       60,    -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,
04191       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04192       -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,
04193       90,    -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,
04194      100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
04195       -1,    -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,
04196       11,    12,    -1,    -1,    -1,    16,   126,    18,    19,    20,
04197       21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
04198       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
04199       -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,
04200       51,    52,    53,    54,    55,    56,    57,    -1,    59,    60,
04201       -1,    62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,
04202       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04203       -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,
04204       -1,    92,    93,    -1,    -1,    -1,    -1,    98,    99,   100,
04205      101,   102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,
04206       -1,     3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,
04207       12,    -1,    -1,    -1,    16,   126,    18,    19,    20,    21,
04208       22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
04209       32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
04210       -1,    -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,
04211       52,    53,    54,    55,    56,    57,    -1,    59,    60,    -1,
04212       62,    63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04213       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04214       -1,    -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,
04215       92,    93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,
04216      102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
04217        3,     4,     5,    -1,     7,    -1,    -1,    -1,    11,    12,
04218       -1,    -1,    -1,    16,   126,    18,    19,    20,    21,    22,
04219       23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
04220       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
04221       -1,    -1,    -1,    46,    -1,    -1,    49,    50,    51,    52,
04222       53,    54,    55,    56,    57,    -1,    59,    60,    -1,    62,
04223       63,    64,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04224       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04225       -1,    -1,    -1,    86,    -1,    -1,    89,    90,    -1,    92,
04226       93,    -1,    -1,    -1,    -1,    98,    99,   100,   101,   102,
04227      103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,    -1,
04228       52,    53,    -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,
04229       -1,    -1,    -1,   126,    66,    67,    68,    69,    70,    71,
04230       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
04231       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04232       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
04233       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04234       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
04235      122,   123,   124,   125,    -1,   127,   128,    52,    53,    -1,
04236       -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,
04237       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04238       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04239       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04240       95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04241       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04242       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
04243      125,    -1,   127,   128,    52,    53,    -1,    -1,    56,    -1,
04244      135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
04245       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
04246       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
04247       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,
04248       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04249       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,
04250      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
04251      128,    52,    53,    -1,    -1,    56,    -1,   135,    -1,    -1,
04252       -1,    -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,
04253       71,    72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,
04254       81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,
04255       -1,    -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,
04256       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04257       -1,    -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,
04258      121,   122,   123,   124,   125,    -1,   127,   128,    52,    53,
04259       -1,    -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,
04260       -1,    -1,    66,    67,    68,    69,    70,    71,    72,    73,
04261       74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,
04262       84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04263       -1,    95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04264       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04265       -1,    -1,   116,   117,   118,   119,   120,   121,   122,   123,
04266      124,   125,    -1,   127,   128,    52,    53,    -1,    -1,    56,
04267       -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,
04268       67,    68,    69,    70,    71,    72,    73,    74,    -1,    -1,
04269       77,    78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,
04270       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,
04271       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04272       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,
04273      117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
04274      127,   128,    52,    53,    -1,    -1,    56,    -1,   135,    -1,
04275       -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,    69,
04276       70,    71,    72,    73,    74,    -1,    -1,    77,    78,    -1,
04277       -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,    -1,
04278       -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,    -1,
04279       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04280       -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,   119,
04281      120,   121,   122,   123,   124,   125,    -1,   127,   128,    52,
04282       53,    -1,    -1,    56,    -1,   135,    -1,    -1,    -1,    -1,
04283       -1,    -1,    -1,    66,    67,    68,    69,    70,    71,    72,
04284       73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,    82,
04285       83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04286       -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,    -1,
04287       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04288       -1,    -1,    -1,   116,   117,   118,   119,   120,   121,   122,
04289      123,   124,   125,    -1,   127,   128,    52,    53,    -1,    -1,
04290       56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04291       66,    67,    68,    69,    70,    71,    72,    73,    74,    -1,
04292       -1,    77,    78,    -1,    -1,    81,    82,    83,    84,    -1,
04293       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,
04294       96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04295       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04296      116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
04297       -1,   127,   128,    52,    53,    -1,    -1,    56,    -1,   135,
04298       -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,    68,
04299       69,    70,    71,    72,    73,    74,    -1,    -1,    77,    78,
04300       -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,    -1,
04301       -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    -1,    -1,
04302       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04303       -1,    -1,    -1,    -1,    -1,    -1,    -1,   116,   117,   118,
04304      119,   120,   121,   122,   123,   124,   125,    -1,   127,   128,
04305       52,    53,    -1,    -1,    56,    -1,   135,    -1,    -1,    -1,
04306       -1,    -1,    -1,    -1,    66,    67,    68,    69,    70,    71,
04307       72,    73,    74,    -1,    -1,    77,    78,    -1,    -1,    81,
04308       82,    83,    84,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04309       -1,    -1,    -1,    95,    96,    -1,    -1,    -1,    -1,    -1,
04310       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04311       -1,    -1,    -1,    -1,   116,   117,   118,   119,   120,   121,
04312      122,   123,   124,   125,    -1,   127,   128,    52,    53,    -1,
04313       -1,    56,    -1,   135,    -1,    -1,    -1,    -1,    -1,    -1,
04314       -1,    66,    67,    68,    69,    70,    71,    72,    73,    74,
04315       -1,    -1,    77,    78,    -1,    -1,    81,    82,    83,    84,
04316       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04317       95,    96,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04318       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04319       -1,   116,   117,   118,   119,   120,   121,   122,   123,   124,
04320      125,    -1,   127,   128,    52,    53,    -1,    -1,    56,    -1,
04321      135,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    66,    67,
04322       68,    69,    70,    71,    72,    73,    74,    -1,    -1,    77,
04323       78,    -1,    -1,    81,    82,    83,    84,    -1,    -1,    -1,
04324       -1,    -1,    -1,    -1,    -1,    -1,    -1,    95,    96,    68,
04325       69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
04326       79,    80,    -1,    -1,    83,    84,    -1,    -1,   116,   117,
04327      118,   119,   120,   121,   122,   123,   124,   125,    -1,   127,
04328      128,    -1,    -1,    -1,    -1,    -1,    -1,   135,    -1,    -1,
04329       -1,    -1,    -1,    -1,    -1,   114,    -1,   116,   117,   118,
04330      119,   120,   121,   122,   123,   124,   125,    -1,    -1,    -1,
04331       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
04332       -1,    -1,   141
04333 };
04334 
04335 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
04336    symbol of state STATE-NUM.  */
04337 static const yytype_uint16 yystos[] =
04338 {
04339        0,   143,   144,     0,     1,     3,     4,     5,     6,     7,
04340       11,    12,    16,    18,    19,    20,    21,    22,    23,    24,
04341       30,    31,    32,    33,    34,    35,    36,    39,    45,    46,
04342       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
04343       57,    59,    60,    62,    63,    64,    66,    67,    86,    89,
04344       90,    92,    93,    95,    98,    99,   100,   101,   102,   103,
04345      104,   105,   106,   126,   127,   128,   145,   146,   147,   154,
04346      156,   157,   159,   160,   163,   164,   165,   167,   168,   169,
04347      171,   172,   182,   196,   214,   215,   216,   217,   218,   219,
04348      220,   221,   222,   223,   224,   249,   250,   264,   265,   266,
04349      267,   268,   269,   270,   273,   275,   276,   288,   290,   291,
04350      292,   293,   294,   295,   296,   327,   338,   147,     3,     4,
04351        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
04352       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
04353       25,    26,    30,    31,    32,    33,    34,    35,    36,    37,
04354       38,    39,    45,    46,    47,    48,    49,    50,    51,    52,
04355       53,    56,    66,    67,    68,    69,    70,    71,    72,    73,
04356       74,    77,    78,    81,    82,    83,    84,    95,    96,   116,
04357      117,   118,   119,   120,   121,   122,   123,   124,   125,   127,
04358      128,   135,   175,   176,   177,   178,   180,   181,   288,   290,
04359       39,    58,    86,    89,    95,    96,    97,   127,   164,   172,
04360      182,   184,   189,   192,   194,   214,   292,   293,   295,   296,
04361      325,   326,   189,   189,   136,   190,   191,   136,   186,   190,
04362      136,   141,   332,    54,   177,   332,   148,   130,    21,    22,
04363       30,    31,    32,   163,   182,   214,   182,    56,     1,    47,
04364       89,   150,   151,   152,   154,   166,   167,   338,   157,   198,
04365      185,   194,   325,   338,   184,   324,   325,   338,    46,    86,
04366      126,   134,   171,   196,   214,   292,   293,   296,   242,   243,
04367       54,    55,    57,   175,   280,   289,   279,   280,   281,   140,
04368      271,   140,   277,   140,   274,   140,   278,    59,    60,   159,
04369      182,   182,   139,   141,   331,   336,   337,    40,    41,    42,
04370       43,    44,    37,    38,    26,   130,   186,   190,   255,    28,
04371      247,   113,   134,    89,    95,   168,   113,    68,    69,    70,
04372       71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
04373       83,    84,   114,   116,   117,   118,   119,   120,   121,   122,
04374      123,   124,   125,    85,   132,   133,   197,   157,   158,   158,
04375      201,   203,   158,   331,   337,    86,   165,   172,   214,   230,
04376      292,   293,   296,    52,    56,    83,    86,   173,   174,   214,
04377      292,   293,   296,   174,    33,    34,    35,    36,    49,    50,
04378       51,    52,    56,   136,   175,   294,   322,    85,   133,   330,
04379      255,   267,    87,    87,   134,   184,    56,   184,   184,   184,
04380      113,    88,   134,   193,   338,    85,   132,   133,    87,    87,
04381      134,   193,   189,   332,   333,   189,   188,   189,   194,   325,
04382      338,   157,   333,   157,    54,    63,    64,   155,   136,   183,
04383      130,   150,    85,   133,    87,   154,   153,   166,   137,   331,
04384      337,   333,   199,   333,   138,   134,   141,   335,   134,   335,
04385      131,   335,   332,    56,    59,    60,   168,   170,   134,    85,
04386      132,   133,   244,    61,   107,   109,   110,   282,   110,   282,
04387      110,    65,   282,   110,   110,   272,   282,   110,    61,   110,
04388      110,   110,   272,   110,    61,   110,    68,    68,   139,   147,
04389      158,   158,   158,   158,   154,   157,   157,   257,   256,    94,
04390      161,   248,    95,   159,   184,   194,   195,   166,   134,   171,
04391      134,   156,   159,   172,   182,   184,   195,   182,   182,   182,
04392      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
04393      182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
04394      182,   182,   182,    52,    53,    56,   180,   254,   328,   329,
04395      188,    52,    53,    56,   180,   253,   328,   149,   150,    13,
04396      226,   336,   226,   158,   158,   331,    17,   258,    56,    85,
04397      132,   133,    25,   157,    52,    56,   173,     1,   117,   297,
04398      336,    85,   132,   133,   210,   323,   211,   330,    52,    56,
04399      328,   159,   182,   159,   182,   179,   182,   184,    95,   184,
04400      192,   325,    52,    56,   188,    52,    56,   326,   333,   137,
04401      333,   134,   134,   333,   177,   200,   182,   145,   131,   328,
04402      328,   182,   130,   333,   152,   333,   325,   134,   170,    52,
04403       56,   188,    52,    56,    52,    54,    55,    56,    57,    58,
04404       68,    89,    95,    96,    97,   120,   123,   136,   245,   300,
04405      302,   303,   304,   305,   306,   307,   310,   311,   312,   313,
04406      316,   317,   318,   319,   320,   284,   283,   140,   282,   140,
04407      140,   140,   182,   182,    76,   118,   237,   238,   338,   237,
04408      162,   237,   184,   134,   333,   170,   134,   113,    44,   332,
04409       87,    87,   186,   190,   252,   332,   334,    87,    87,   186,
04410      190,   251,    10,   225,     8,   260,   338,   150,    13,   150,
04411       27,   227,   336,   227,   258,   194,   225,    52,    56,   188,
04412       52,    56,   205,   208,   336,   298,   207,    52,    56,   173,
04413      188,   149,   157,   136,   299,   302,   212,   186,   187,   190,
04414      338,    44,   177,   184,   193,    87,    87,   334,    87,    87,
04415      325,   157,   131,   145,   335,   168,   334,   113,   184,    52,
04416       89,    95,   231,   232,   233,   304,   302,    29,   111,   246,
04417      134,   301,   134,   321,   338,    52,   134,   321,   134,   301,
04418       52,   134,   301,    52,   285,    54,    55,    57,   287,   296,
04419       52,    58,   234,   236,   239,   306,   308,   309,   312,   314,
04420      315,   318,   320,   332,   150,   150,   237,   150,    95,   184,
04421      170,   182,   115,   159,   182,   159,   182,   161,   186,   138,
04422       87,   159,   182,   159,   182,   161,   187,   184,   195,   261,
04423      338,    15,   229,   338,    14,   228,   229,   229,   202,   204,
04424      225,   134,   226,   334,   158,   336,   158,   149,   334,   225,
04425      333,   302,   149,   336,   175,   255,   247,   182,    87,   134,
04426      333,   131,   184,   233,   134,   304,   134,   333,   239,   150,
04427      150,   300,   305,   316,   318,   307,   312,   320,   306,   313,
04428      318,   306,   286,   113,    86,   214,   239,   118,   134,   235,
04429      134,   321,   321,   134,   235,   134,   235,   139,    10,   131,
04430      150,    10,   184,   182,   159,   182,    88,   262,   338,   150,
04431        9,   263,   338,   158,   225,   225,   150,   150,   184,   150,
04432      227,   209,   336,   225,   333,   225,   213,   333,   232,   134,
04433       95,   231,   137,    10,   131,   134,   301,   134,   301,   321,
04434      134,   301,   134,   301,   301,   150,   214,    56,    85,   118,
04435      234,   315,   318,   308,   312,   306,   314,   318,   306,    52,
04436      240,   241,   303,   131,    86,   172,   214,   292,   293,   296,
04437      226,   150,   226,   225,   225,   229,   258,   259,   206,   149,
04438      299,   134,   232,   134,   304,   306,   318,   306,   306,   108,
04439       52,    56,   134,   235,   134,   235,   321,   134,   235,   134,
04440      235,   235,   134,   332,    56,    85,   132,   133,   150,   150,
04441      150,   225,   149,   232,   134,   301,   134,   301,   301,   301,
04442      306,   318,   306,   306,   241,    52,    56,   188,    52,    56,
04443      260,   228,   225,   225,   232,   306,   235,   134,   235,   235,
04444      235,   334,   301,   306,   235
04445 };
04446 
04447 #define yyerrok         (yyerrstatus = 0)
04448 #define yyclearin       (yychar = YYEMPTY)
04449 #define YYEMPTY         (-2)
04450 #define YYEOF           0
04451 
04452 #define YYACCEPT        goto yyacceptlab
04453 #define YYABORT         goto yyabortlab
04454 #define YYERROR         goto yyerrorlab
04455 
04456 
04457 /* Like YYERROR except do call yyerror.  This remains here temporarily
04458    to ease the transition to the new meaning of YYERROR, for GCC.
04459    Once GCC version 2 has supplanted version 1, this can go.  */
04460 
04461 #define YYFAIL          goto yyerrlab
04462 
04463 #define YYRECOVERING()  (!!yyerrstatus)
04464 
04465 #define YYBACKUP(Token, Value)                                  \
04466 do                                                              \
04467   if (yychar == YYEMPTY && yylen == 1)                          \
04468     {                                                           \
04469       yychar = (Token);                                         \
04470       yylval = (Value);                                         \
04471       yytoken = YYTRANSLATE (yychar);                           \
04472       YYPOPSTACK (1);                                           \
04473       goto yybackup;                                            \
04474     }                                                           \
04475   else                                                          \
04476     {                                                           \
04477       parser_yyerror (parser, YY_("syntax error: cannot back up")); \
04478       YYERROR;                                                  \
04479     }                                                           \
04480 while (YYID (0))
04481 
04482 
04483 #define YYTERROR        1
04484 #define YYERRCODE       256
04485 
04486 
04487 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04488    If N is 0, then set CURRENT to the empty location which ends
04489    the previous symbol: RHS[0] (always defined).  */
04490 
04491 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04492 #ifndef YYLLOC_DEFAULT
04493 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04494     do                                                                  \
04495       if (YYID (N))                                                    \
04496         {                                                               \
04497           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04498           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
04499           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
04500           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
04501         }                                                               \
04502       else                                                              \
04503         {                                                               \
04504           (Current).first_line   = (Current).last_line   =              \
04505             YYRHSLOC (Rhs, 0).last_line;                                \
04506           (Current).first_column = (Current).last_column =              \
04507             YYRHSLOC (Rhs, 0).last_column;                              \
04508         }                                                               \
04509     while (YYID (0))
04510 #endif
04511 
04512 
04513 /* YY_LOCATION_PRINT -- Print the location on the stream.
04514    This macro was not mandated originally: define only if we know
04515    we won't break user code: when these are the locations we know.  */
04516 
04517 #ifndef YY_LOCATION_PRINT
04518 # if YYLTYPE_IS_TRIVIAL
04519 #  define YY_LOCATION_PRINT(File, Loc)                  \
04520      fprintf (File, "%d.%d-%d.%d",                      \
04521               (Loc).first_line, (Loc).first_column,     \
04522               (Loc).last_line,  (Loc).last_column)
04523 # else
04524 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04525 # endif
04526 #endif
04527 
04528 
04529 /* YYLEX -- calling `yylex' with the right arguments.  */
04530 
04531 #ifdef YYLEX_PARAM
04532 # define YYLEX yylex (&yylval, YYLEX_PARAM)
04533 #else
04534 # define YYLEX yylex (&yylval)
04535 #endif
04536 
04537 /* Enable debugging if requested.  */
04538 #if YYDEBUG
04539 
04540 # ifndef YYFPRINTF
04541 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04542 #  define YYFPRINTF fprintf
04543 # endif
04544 
04545 # define YYDPRINTF(Args)                        \
04546 do {                                            \
04547   if (yydebug)                                  \
04548     YYFPRINTF Args;                             \
04549 } while (YYID (0))
04550 
04551 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
04552 do {                                                                      \
04553   if (yydebug)                                                            \
04554     {                                                                     \
04555       YYFPRINTF (stderr, "%s ", Title);                                   \
04556       yy_symbol_print (stderr,                                            \
04557                   Type, Value, parser); \
04558       YYFPRINTF (stderr, "\n");                                           \
04559     }                                                                     \
04560 } while (YYID (0))
04561 
04562 
04563 /*--------------------------------.
04564 | Print this symbol on YYOUTPUT.  |
04565 `--------------------------------*/
04566 
04567 /*ARGSUSED*/
04568 #if (defined __STDC__ || defined __C99__FUNC__ \
04569      || defined __cplusplus || defined _MSC_VER)
04570 static void
04571 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04572 #else
04573 static void
04574 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
04575     FILE *yyoutput;
04576     int yytype;
04577     YYSTYPE const * const yyvaluep;
04578     struct parser_params *parser;
04579 #endif
04580 {
04581   if (!yyvaluep)
04582     return;
04583   YYUSE (parser);
04584 # ifdef YYPRINT
04585   if (yytype < YYNTOKENS)
04586     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04587 # else
04588   YYUSE (yyoutput);
04589 # endif
04590   switch (yytype)
04591     {
04592       default:
04593         break;
04594     }
04595 }
04596 
04597 
04598 /*--------------------------------.
04599 | Print this symbol on YYOUTPUT.  |
04600 `--------------------------------*/
04601 
04602 #if (defined __STDC__ || defined __C99__FUNC__ \
04603      || defined __cplusplus || defined _MSC_VER)
04604 static void
04605 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
04606 #else
04607 static void
04608 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
04609     FILE *yyoutput;
04610     int yytype;
04611     YYSTYPE const * const yyvaluep;
04612     struct parser_params *parser;
04613 #endif
04614 {
04615   if (yytype < YYNTOKENS)
04616     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04617   else
04618     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04619 
04620   yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
04621   YYFPRINTF (yyoutput, ")");
04622 }
04623 
04624 /*------------------------------------------------------------------.
04625 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04626 | TOP (included).                                                   |
04627 `------------------------------------------------------------------*/
04628 
04629 #if (defined __STDC__ || defined __C99__FUNC__ \
04630      || defined __cplusplus || defined _MSC_VER)
04631 static void
04632 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
04633 #else
04634 static void
04635 yy_stack_print (bottom, top)
04636     yytype_int16 *bottom;
04637     yytype_int16 *top;
04638 #endif
04639 {
04640   YYFPRINTF (stderr, "Stack now");
04641   for (; bottom <= top; ++bottom)
04642     YYFPRINTF (stderr, " %d", *bottom);
04643   YYFPRINTF (stderr, "\n");
04644 }
04645 
04646 # define YY_STACK_PRINT(Bottom, Top)                            \
04647 do {                                                            \
04648   if (yydebug)                                                  \
04649     yy_stack_print ((Bottom), (Top));                           \
04650 } while (YYID (0))
04651 
04652 
04653 /*------------------------------------------------.
04654 | Report that the YYRULE is going to be reduced.  |
04655 `------------------------------------------------*/
04656 
04657 #if (defined __STDC__ || defined __C99__FUNC__ \
04658      || defined __cplusplus || defined _MSC_VER)
04659 static void
04660 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
04661 #else
04662 static void
04663 yy_reduce_print (yyvsp, yyrule, parser)
04664     YYSTYPE *yyvsp;
04665     int yyrule;
04666     struct parser_params *parser;
04667 #endif
04668 {
04669   int yynrhs = yyr2[yyrule];
04670   int yyi;
04671   unsigned long int yylno = yyrline[yyrule];
04672   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04673              yyrule - 1, yylno);
04674   /* The symbols being reduced.  */
04675   for (yyi = 0; yyi < yynrhs; yyi++)
04676     {
04677       fprintf (stderr, "   $%d = ", yyi + 1);
04678       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04679                        &(yyvsp[(yyi + 1) - (yynrhs)])
04680                                        , parser);
04681       fprintf (stderr, "\n");
04682     }
04683 }
04684 
04685 # define YY_REDUCE_PRINT(Rule)          \
04686 do {                                    \
04687   if (yydebug)                          \
04688     yy_reduce_print (yyvsp, Rule, parser); \
04689 } while (YYID (0))
04690 
04691 /* Nonzero means print parse trace.  It is left uninitialized so that
04692    multiple parsers can coexist.  */
04693 #ifndef yydebug
04694 int yydebug;
04695 #endif
04696 #else /* !YYDEBUG */
04697 # define YYDPRINTF(Args)
04698 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04699 # define YY_STACK_PRINT(Bottom, Top)
04700 # define YY_REDUCE_PRINT(Rule)
04701 #endif /* !YYDEBUG */
04702 
04703 
04704 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04705 #ifndef YYINITDEPTH
04706 # define YYINITDEPTH 200
04707 #endif
04708 
04709 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04710    if the built-in stack extension method is used).
04711 
04712    Do not make this value too large; the results are undefined if
04713    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04714    evaluated with infinite-precision integer arithmetic.  */
04715 
04716 #ifndef YYMAXDEPTH
04717 # define YYMAXDEPTH 10000
04718 #endif
04719 
04720 
04721 
04722 #if YYERROR_VERBOSE
04723 
04724 # ifndef yystrlen
04725 #  if defined __GLIBC__ && defined _STRING_H
04726 #   define yystrlen strlen
04727 #  else
04728 /* Return the length of YYSTR.  */
04729 #if (defined __STDC__ || defined __C99__FUNC__ \
04730      || defined __cplusplus || defined _MSC_VER)
04731 static YYSIZE_T
04732 yystrlen (const char *yystr)
04733 #else
04734 static YYSIZE_T
04735 yystrlen (yystr)
04736     const char *yystr;
04737 #endif
04738 {
04739   YYSIZE_T yylen;
04740   for (yylen = 0; yystr[yylen]; yylen++)
04741     continue;
04742   return yylen;
04743 }
04744 #  endif
04745 # endif
04746 
04747 # ifndef yystpcpy
04748 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04749 #   define yystpcpy stpcpy
04750 #  else
04751 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04752    YYDEST.  */
04753 #if (defined __STDC__ || defined __C99__FUNC__ \
04754      || defined __cplusplus || defined _MSC_VER)
04755 static char *
04756 yystpcpy (char *yydest, const char *yysrc)
04757 #else
04758 static char *
04759 yystpcpy (yydest, yysrc)
04760     char *yydest;
04761     const char *yysrc;
04762 #endif
04763 {
04764   char *yyd = yydest;
04765   const char *yys = yysrc;
04766 
04767   while ((*yyd++ = *yys++) != '\0')
04768     continue;
04769 
04770   return yyd - 1;
04771 }
04772 #  endif
04773 # endif
04774 
04775 # ifndef yytnamerr
04776 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04777    quotes and backslashes, so that it's suitable for yyerror.  The
04778    heuristic is that double-quoting is unnecessary unless the string
04779    contains an apostrophe, a comma, or backslash (other than
04780    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04781    null, do not copy; instead, return the length of what the result
04782    would have been.  */
04783 static YYSIZE_T
04784 yytnamerr (char *yyres, const char *yystr)
04785 {
04786   if (*yystr == '"')
04787     {
04788       YYSIZE_T yyn = 0;
04789       char const *yyp = yystr;
04790 
04791       for (;;)
04792         switch (*++yyp)
04793           {
04794           case '\'':
04795           case ',':
04796             goto do_not_strip_quotes;
04797 
04798           case '\\':
04799             if (*++yyp != '\\')
04800               goto do_not_strip_quotes;
04801             /* Fall through.  */
04802           default:
04803             if (yyres)
04804               yyres[yyn] = *yyp;
04805             yyn++;
04806             break;
04807 
04808           case '"':
04809             if (yyres)
04810               yyres[yyn] = '\0';
04811             return yyn;
04812           }
04813     do_not_strip_quotes: ;
04814     }
04815 
04816   if (! yyres)
04817     return yystrlen (yystr);
04818 
04819   return yystpcpy (yyres, yystr) - yyres;
04820 }
04821 # endif
04822 
04823 /* Copy into YYRESULT an error message about the unexpected token
04824    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
04825    including the terminating null byte.  If YYRESULT is null, do not
04826    copy anything; just return the number of bytes that would be
04827    copied.  As a special case, return 0 if an ordinary "syntax error"
04828    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
04829    size calculation.  */
04830 static YYSIZE_T
04831 yysyntax_error (char *yyresult, int yystate, int yychar)
04832 {
04833   int yyn = yypact[yystate];
04834 
04835   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
04836     return 0;
04837   else
04838     {
04839       int yytype = YYTRANSLATE (yychar);
04840       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
04841       YYSIZE_T yysize = yysize0;
04842       YYSIZE_T yysize1;
04843       int yysize_overflow = 0;
04844       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04845       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04846       int yyx;
04847 
04848 # if 0
04849       /* This is so xgettext sees the translatable formats that are
04850          constructed on the fly.  */
04851       YY_("syntax error, unexpected %s");
04852       YY_("syntax error, unexpected %s, expecting %s");
04853       YY_("syntax error, unexpected %s, expecting %s or %s");
04854       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
04855       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
04856 # endif
04857       char *yyfmt;
04858       char const *yyf;
04859       static char const yyunexpected[] = "syntax error, unexpected %s";
04860       static char const yyexpecting[] = ", expecting %s";
04861       static char const yyor[] = " or %s";
04862       char yyformat[sizeof yyunexpected
04863                     + sizeof yyexpecting - 1
04864                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
04865                        * (sizeof yyor - 1))];
04866       char const *yyprefix = yyexpecting;
04867 
04868       /* Start YYX at -YYN if negative to avoid negative indexes in
04869          YYCHECK.  */
04870       int yyxbegin = yyn < 0 ? -yyn : 0;
04871 
04872       /* Stay within bounds of both yycheck and yytname.  */
04873       int yychecklim = YYLAST - yyn + 1;
04874       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04875       int yycount = 1;
04876 
04877       yyarg[0] = yytname[yytype];
04878       yyfmt = yystpcpy (yyformat, yyunexpected);
04879 
04880       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04881         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
04882           {
04883             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04884               {
04885                 yycount = 1;
04886                 yysize = yysize0;
04887                 yyformat[sizeof yyunexpected - 1] = '\0';
04888                 break;
04889               }
04890             yyarg[yycount++] = yytname[yyx];
04891             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04892             yysize_overflow |= (yysize1 < yysize);
04893             yysize = yysize1;
04894             yyfmt = yystpcpy (yyfmt, yyprefix);
04895             yyprefix = yyor;
04896           }
04897 
04898       yyf = YY_(yyformat);
04899       yysize1 = yysize + yystrlen (yyf);
04900       yysize_overflow |= (yysize1 < yysize);
04901       yysize = yysize1;
04902 
04903       if (yysize_overflow)
04904         return YYSIZE_MAXIMUM;
04905 
04906       if (yyresult)
04907         {
04908           /* Avoid sprintf, as that infringes on the user's name space.
04909              Don't have undefined behavior even if the translation
04910              produced a string with the wrong number of "%s"s.  */
04911           char *yyp = yyresult;
04912           int yyi = 0;
04913           while ((*yyp = *yyf) != '\0')
04914             {
04915               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
04916                 {
04917                   yyp += yytnamerr (yyp, yyarg[yyi++]);
04918                   yyf += 2;
04919                 }
04920               else
04921                 {
04922                   yyp++;
04923                   yyf++;
04924                 }
04925             }
04926         }
04927       return yysize;
04928     }
04929 }
04930 #endif /* YYERROR_VERBOSE */
04931 
04932 
04933 /*-----------------------------------------------.
04934 | Release the memory associated to this symbol.  |
04935 `-----------------------------------------------*/
04936 
04937 /*ARGSUSED*/
04938 #if (defined __STDC__ || defined __C99__FUNC__ \
04939      || defined __cplusplus || defined _MSC_VER)
04940 static void
04941 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
04942 #else
04943 static void
04944 yydestruct (yymsg, yytype, yyvaluep, parser)
04945     const char *yymsg;
04946     int yytype;
04947     YYSTYPE *yyvaluep;
04948     struct parser_params *parser;
04949 #endif
04950 {
04951   YYUSE (yyvaluep);
04952   YYUSE (parser);
04953 
04954   if (!yymsg)
04955     yymsg = "Deleting";
04956   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04957 
04958   switch (yytype)
04959     {
04960 
04961       default:
04962         break;
04963     }
04964 }
04965 
04966 
04967 /* Prevent warnings from -Wmissing-prototypes.  */
04968 
04969 #ifdef YYPARSE_PARAM
04970 #if defined __STDC__ || defined __cplusplus
04971 int yyparse (void *YYPARSE_PARAM);
04972 #else
04973 int yyparse ();
04974 #endif
04975 #else /* ! YYPARSE_PARAM */
04976 #if defined __STDC__ || defined __cplusplus
04977 int yyparse (struct parser_params *parser);
04978 #else
04979 int yyparse ();
04980 #endif
04981 #endif /* ! YYPARSE_PARAM */
04982 
04983 
04984 
04985 
04986 
04987 
04988 /*----------.
04989 | yyparse.  |
04990 `----------*/
04991 
04992 #ifdef YYPARSE_PARAM
04993 #if (defined __STDC__ || defined __C99__FUNC__ \
04994      || defined __cplusplus || defined _MSC_VER)
04995 int
04996 yyparse (void *YYPARSE_PARAM)
04997 #else
04998 int
04999 yyparse (YYPARSE_PARAM)
05000     void *YYPARSE_PARAM;
05001 #endif
05002 #else /* ! YYPARSE_PARAM */
05003 #if (defined __STDC__ || defined __C99__FUNC__ \
05004      || defined __cplusplus || defined _MSC_VER)
05005 int
05006 yyparse (struct parser_params *parser)
05007 #else
05008 int
05009 yyparse (parser)
05010     struct parser_params *parser;
05011 #endif
05012 #endif
05013 {
05014   /* The look-ahead symbol.  */
05015 int yychar;
05016 
05017 /* The semantic value of the look-ahead symbol.  */
05018 YYSTYPE yylval;
05019 
05020 /* Number of syntax errors so far.  */
05021 int yynerrs;
05022 
05023   int yystate;
05024   int yyn;
05025   int yyresult;
05026   /* Number of tokens to shift before error messages enabled.  */
05027   int yyerrstatus;
05028   /* Look-ahead token as an internal (translated) token number.  */
05029   int yytoken = 0;
05030 #if YYERROR_VERBOSE
05031   /* Buffer for error messages, and its allocated size.  */
05032   char yymsgbuf[128];
05033   char *yymsg = yymsgbuf;
05034   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
05035 #endif
05036 
05037   /* Three stacks and their tools:
05038      `yyss': related to states,
05039      `yyvs': related to semantic values,
05040      `yyls': related to locations.
05041 
05042      Refer to the stacks thru separate pointers, to allow yyoverflow
05043      to reallocate them elsewhere.  */
05044 
05045   /* The state stack.  */
05046   yytype_int16 yyssa[YYINITDEPTH];
05047   yytype_int16 *yyss = yyssa;
05048   yytype_int16 *yyssp;
05049 
05050   /* The semantic value stack.  */
05051   YYSTYPE yyvsa[YYINITDEPTH];
05052   YYSTYPE *yyvs = yyvsa;
05053   YYSTYPE *yyvsp;
05054 
05055 
05056 
05057 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
05058 
05059   YYSIZE_T yystacksize = YYINITDEPTH;
05060 
05061   /* The variables used to return semantic value and location from the
05062      action routines.  */
05063   YYSTYPE yyval;
05064 
05065 
05066   /* The number of symbols on the RHS of the reduced rule.
05067      Keep to zero when no symbol should be popped.  */
05068   int yylen = 0;
05069 
05070   YYDPRINTF ((stderr, "Starting parse\n"));
05071 
05072   yystate = 0;
05073   yyerrstatus = 0;
05074   yynerrs = 0;
05075   yychar = YYEMPTY;             /* Cause a token to be read.  */
05076 
05077   /* Initialize stack pointers.
05078      Waste one element of value and location stack
05079      so that they stay on the same level as the state stack.
05080      The wasted elements are never initialized.  */
05081 
05082   yyssp = yyss;
05083   yyvsp = yyvs;
05084 
05085   goto yysetstate;
05086 
05087 /*------------------------------------------------------------.
05088 | yynewstate -- Push a new state, which is found in yystate.  |
05089 `------------------------------------------------------------*/
05090  yynewstate:
05091   /* In all cases, when you get here, the value and location stacks
05092      have just been pushed.  So pushing a state here evens the stacks.  */
05093   yyssp++;
05094 
05095  yysetstate:
05096   *yyssp = yystate;
05097 
05098   if (yyss + yystacksize - 1 <= yyssp)
05099     {
05100       /* Get the current used size of the three stacks, in elements.  */
05101       YYSIZE_T yysize = yyssp - yyss + 1;
05102 
05103 #ifdef yyoverflow
05104       {
05105         /* Give user a chance to reallocate the stack.  Use copies of
05106            these so that the &'s don't force the real ones into
05107            memory.  */
05108         YYSTYPE *yyvs1 = yyvs;
05109         yytype_int16 *yyss1 = yyss;
05110 
05111 
05112         /* Each stack pointer address is followed by the size of the
05113            data in use in that stack, in bytes.  This used to be a
05114            conditional around just the two extra args, but that might
05115            be undefined if yyoverflow is a macro.  */
05116         yyoverflow (YY_("memory exhausted"),
05117                     &yyss1, yysize * sizeof (*yyssp),
05118                     &yyvs1, yysize * sizeof (*yyvsp),
05119 
05120                     &yystacksize);
05121 
05122         yyss = yyss1;
05123         yyvs = yyvs1;
05124       }
05125 #else /* no yyoverflow */
05126 # ifndef YYSTACK_RELOCATE
05127       goto yyexhaustedlab;
05128 # else
05129       /* Extend the stack our own way.  */
05130       if (YYMAXDEPTH <= yystacksize)
05131         goto yyexhaustedlab;
05132       yystacksize *= 2;
05133       if (YYMAXDEPTH < yystacksize)
05134         yystacksize = YYMAXDEPTH;
05135 
05136       {
05137         yytype_int16 *yyss1 = yyss;
05138         union yyalloc *yyptr =
05139           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
05140         if (! yyptr)
05141           goto yyexhaustedlab;
05142         YYSTACK_RELOCATE (yyss);
05143         YYSTACK_RELOCATE (yyvs);
05144 
05145 #  undef YYSTACK_RELOCATE
05146         if (yyss1 != yyssa)
05147           YYSTACK_FREE (yyss1);
05148       }
05149 # endif
05150 #endif /* no yyoverflow */
05151 
05152       yyssp = yyss + yysize - 1;
05153       yyvsp = yyvs + yysize - 1;
05154 
05155 
05156       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
05157                   (unsigned long int) yystacksize));
05158 
05159       if (yyss + yystacksize - 1 <= yyssp)
05160         YYABORT;
05161     }
05162 
05163   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
05164 
05165   goto yybackup;
05166 
05167 /*-----------.
05168 | yybackup.  |
05169 `-----------*/
05170 yybackup:
05171 
05172   /* Do appropriate processing given the current state.  Read a
05173      look-ahead token if we need one and don't already have one.  */
05174 
05175   /* First try to decide what to do without reference to look-ahead token.  */
05176   yyn = yypact[yystate];
05177   if (yyn == YYPACT_NINF)
05178     goto yydefault;
05179 
05180   /* Not known => get a look-ahead token if don't already have one.  */
05181 
05182   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
05183   if (yychar == YYEMPTY)
05184     {
05185       YYDPRINTF ((stderr, "Reading a token: "));
05186       yychar = YYLEX;
05187     }
05188 
05189   if (yychar <= YYEOF)
05190     {
05191       yychar = yytoken = YYEOF;
05192       YYDPRINTF ((stderr, "Now at end of input.\n"));
05193     }
05194   else
05195     {
05196       yytoken = YYTRANSLATE (yychar);
05197       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
05198     }
05199 
05200   /* If the proper action on seeing token YYTOKEN is to reduce or to
05201      detect an error, take that action.  */
05202   yyn += yytoken;
05203   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
05204     goto yydefault;
05205   yyn = yytable[yyn];
05206   if (yyn <= 0)
05207     {
05208       if (yyn == 0 || yyn == YYTABLE_NINF)
05209         goto yyerrlab;
05210       yyn = -yyn;
05211       goto yyreduce;
05212     }
05213 
05214   if (yyn == YYFINAL)
05215     YYACCEPT;
05216 
05217   /* Count tokens shifted since error; after three, turn off error
05218      status.  */
05219   if (yyerrstatus)
05220     yyerrstatus--;
05221 
05222   /* Shift the look-ahead token.  */
05223   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
05224 
05225   /* Discard the shifted token unless it is eof.  */
05226   if (yychar != YYEOF)
05227     yychar = YYEMPTY;
05228 
05229   yystate = yyn;
05230   *++yyvsp = yylval;
05231 
05232   goto yynewstate;
05233 
05234 
05235 /*-----------------------------------------------------------.
05236 | yydefault -- do the default action for the current state.  |
05237 `-----------------------------------------------------------*/
05238 yydefault:
05239   yyn = yydefact[yystate];
05240   if (yyn == 0)
05241     goto yyerrlab;
05242   goto yyreduce;
05243 
05244 
05245 /*-----------------------------.
05246 | yyreduce -- Do a reduction.  |
05247 `-----------------------------*/
05248 yyreduce:
05249   /* yyn is the number of a rule to reduce with.  */
05250   yylen = yyr2[yyn];
05251 
05252   /* If YYLEN is nonzero, implement the default value of the action:
05253      `$$ = $1'.
05254 
05255      Otherwise, the following line sets YYVAL to garbage.
05256      This behavior is undocumented and Bison
05257      users should not rely upon it.  Assigning to YYVAL
05258      unconditionally makes the parser a bit smaller, and it avoids a
05259      GCC warning that YYVAL may be used uninitialized.  */
05260   yyval = yyvsp[1-yylen];
05261 
05262 
05263   YY_REDUCE_PRINT (yyn);
05264   switch (yyn)
05265     {
05266         case 2:
05267 #line 850 "ripper.y"
05268     {
05269                         lex_state = EXPR_BEG;
05270 #if 0
05271                         local_push(compile_for_eval || rb_parse_in_main());
05272 #endif
05273                         local_push(0);
05274 
05275                     ;}
05276     break;
05277 
05278   case 3:
05279 #line 859 "ripper.y"
05280     {
05281 #if 0
05282                         if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
05283                             /* last expression should not be void */
05284                             if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
05285                             else {
05286                                 NODE *node = (yyvsp[(2) - (2)].val);
05287                                 while (node->nd_next) {
05288                                     node = node->nd_next;
05289                                 }
05290                                 void_expr(node->nd_head);
05291                             }
05292                         }
05293                         ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
05294 #endif
05295                         (yyval.val) = (yyvsp[(2) - (2)].val);
05296                         parser->result = dispatch1(program, (yyval.val));
05297 
05298                         local_pop();
05299                     ;}
05300     break;
05301 
05302   case 4:
05303 #line 882 "ripper.y"
05304     {
05305 #if 0
05306                         void_stmts((yyvsp[(1) - (2)].val));
05307                         fixup_nodes(&deferred_nodes);
05308 #endif
05309 
05310                         (yyval.val) = (yyvsp[(1) - (2)].val);
05311                     ;}
05312     break;
05313 
05314   case 5:
05315 #line 893 "ripper.y"
05316     {
05317 #if 0
05318                         (yyval.val) = NEW_BEGIN(0);
05319 #endif
05320                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05321                                                   dispatch0(void_stmt));
05322 
05323                     ;}
05324     break;
05325 
05326   case 6:
05327 #line 902 "ripper.y"
05328     {
05329 #if 0
05330                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05331 #endif
05332                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05333 
05334                     ;}
05335     break;
05336 
05337   case 7:
05338 #line 910 "ripper.y"
05339     {
05340 #if 0
05341                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05342 #endif
05343                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05344 
05345                     ;}
05346     break;
05347 
05348   case 8:
05349 #line 918 "ripper.y"
05350     {
05351                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05352                     ;}
05353     break;
05354 
05355   case 10:
05356 #line 925 "ripper.y"
05357     {
05358 #if 0
05359                         /* local_push(0); */
05360 #endif
05361 
05362                     ;}
05363     break;
05364 
05365   case 11:
05366 #line 932 "ripper.y"
05367     {
05368 #if 0
05369                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05370                                                             (yyvsp[(4) - (5)].val));
05371                         /* NEW_PREEXE($4)); */
05372                         /* local_pop(); */
05373                         (yyval.val) = NEW_BEGIN(0);
05374 #endif
05375                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05376 
05377                     ;}
05378     break;
05379 
05380   case 12:
05381 #line 949 "ripper.y"
05382     {
05383 #if 0
05384                         (yyval.val) = (yyvsp[(1) - (4)].val);
05385                         if ((yyvsp[(2) - (4)].val)) {
05386                             (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05387                         }
05388                         else if ((yyvsp[(3) - (4)].val)) {
05389                             rb_warn0("else without rescue is useless");
05390                             (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
05391                         }
05392                         if ((yyvsp[(4) - (4)].val)) {
05393                             if ((yyval.val)) {
05394                                 (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
05395                             }
05396                             else {
05397                                 (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
05398                             }
05399                         }
05400                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05401 #endif
05402                         (yyval.val) = dispatch4(bodystmt,
05403                                        escape_Qundef((yyvsp[(1) - (4)].val)),
05404                                        escape_Qundef((yyvsp[(2) - (4)].val)),
05405                                        escape_Qundef((yyvsp[(3) - (4)].val)),
05406                                        escape_Qundef((yyvsp[(4) - (4)].val)));
05407 
05408                     ;}
05409     break;
05410 
05411   case 13:
05412 #line 979 "ripper.y"
05413     {
05414 #if 0
05415                         void_stmts((yyvsp[(1) - (2)].val));
05416                         fixup_nodes(&deferred_nodes);
05417 #endif
05418 
05419                         (yyval.val) = (yyvsp[(1) - (2)].val);
05420                     ;}
05421     break;
05422 
05423   case 14:
05424 #line 990 "ripper.y"
05425     {
05426 #if 0
05427                         (yyval.val) = NEW_BEGIN(0);
05428 #endif
05429                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
05430                                                   dispatch0(void_stmt));
05431 
05432                     ;}
05433     break;
05434 
05435   case 15:
05436 #line 999 "ripper.y"
05437     {
05438 #if 0
05439                         (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
05440 #endif
05441                         (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
05442 
05443                     ;}
05444     break;
05445 
05446   case 16:
05447 #line 1007 "ripper.y"
05448     {
05449 #if 0
05450                         (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
05451 #endif
05452                         (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05453 
05454                     ;}
05455     break;
05456 
05457   case 17:
05458 #line 1015 "ripper.y"
05459     {
05460                         (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
05461                     ;}
05462     break;
05463 
05464   case 18:
05465 #line 1021 "ripper.y"
05466     {
05467                         (yyval.val) = (yyvsp[(1) - (1)].val);
05468                     ;}
05469     break;
05470 
05471   case 19:
05472 #line 1025 "ripper.y"
05473     {
05474                         yyerror("BEGIN is permitted only at toplevel");
05475 #if 0
05476                         /* local_push(0); */
05477 #endif
05478 
05479                     ;}
05480     break;
05481 
05482   case 20:
05483 #line 1033 "ripper.y"
05484     {
05485 #if 0
05486                         ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
05487                                                             (yyvsp[(4) - (5)].val));
05488                         /* NEW_PREEXE($4)); */
05489                         /* local_pop(); */
05490                         (yyval.val) = NEW_BEGIN(0);
05491 #endif
05492                         (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
05493 
05494                     ;}
05495     break;
05496 
05497   case 21:
05498 #line 1045 "ripper.y"
05499     {lex_state = EXPR_FNAME;;}
05500     break;
05501 
05502   case 22:
05503 #line 1046 "ripper.y"
05504     {
05505 #if 0
05506                         (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05507 #endif
05508                         (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
05509 
05510                     ;}
05511     break;
05512 
05513   case 23:
05514 #line 1054 "ripper.y"
05515     {
05516 #if 0
05517                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05518 #endif
05519                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05520 
05521                     ;}
05522     break;
05523 
05524   case 24:
05525 #line 1062 "ripper.y"
05526     {
05527 #if 0
05528                         char buf[2];
05529                         buf[0] = '$';
05530                         buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
05531                         (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
05532 #endif
05533                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05534 
05535                     ;}
05536     break;
05537 
05538   case 25:
05539 #line 1073 "ripper.y"
05540     {
05541 #if 0
05542                         yyerror("can't make alias for the number variables");
05543                         (yyval.val) = NEW_BEGIN(0);
05544 #endif
05545                         (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05546                         (yyval.val) = dispatch1(alias_error, (yyval.val));
05547 
05548                     ;}
05549     break;
05550 
05551   case 26:
05552 #line 1083 "ripper.y"
05553     {
05554 #if 0
05555                         (yyval.val) = (yyvsp[(2) - (2)].val);
05556 #endif
05557                         (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
05558 
05559                     ;}
05560     break;
05561 
05562   case 27:
05563 #line 1091 "ripper.y"
05564     {
05565 #if 0
05566                         (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05567                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05568 #endif
05569                         (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05570 
05571                     ;}
05572     break;
05573 
05574   case 28:
05575 #line 1100 "ripper.y"
05576     {
05577 #if 0
05578                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
05579                         fixpos((yyval.val), (yyvsp[(3) - (3)].val));
05580 #endif
05581                         (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05582 
05583                     ;}
05584     break;
05585 
05586   case 29:
05587 #line 1109 "ripper.y"
05588     {
05589 #if 0
05590                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05591                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05592                         }
05593                         else {
05594                             (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05595                         }
05596 #endif
05597                         (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05598 
05599                     ;}
05600     break;
05601 
05602   case 30:
05603 #line 1122 "ripper.y"
05604     {
05605 #if 0
05606                         if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
05607                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
05608                         }
05609                         else {
05610                             (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
05611                         }
05612 #endif
05613                         (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
05614 
05615                     ;}
05616     break;
05617 
05618   case 31:
05619 #line 1135 "ripper.y"
05620     {
05621 #if 0
05622                         NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
05623                         (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
05624 #endif
05625                         (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05626 
05627                     ;}
05628     break;
05629 
05630   case 32:
05631 #line 1144 "ripper.y"
05632     {
05633                         if (in_def || in_single) {
05634                             rb_warn0("END in method; use at_exit");
05635                         }
05636 #if 0
05637                         (yyval.val) = NEW_POSTEXE(NEW_NODE(
05638                             NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
05639 #endif
05640                         (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
05641 
05642                     ;}
05643     break;
05644 
05645   case 34:
05646 #line 1157 "ripper.y"
05647     {
05648 #if 0
05649                         value_expr((yyvsp[(3) - (3)].val));
05650                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05651                         (yyval.val) = (yyvsp[(1) - (3)].val);
05652 #endif
05653                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05654 
05655                     ;}
05656     break;
05657 
05658   case 35:
05659 #line 1167 "ripper.y"
05660     {
05661                         value_expr((yyvsp[(3) - (3)].val));
05662                         (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
05663                     ;}
05664     break;
05665 
05666   case 36:
05667 #line 1172 "ripper.y"
05668     {
05669 #if 0
05670                         NODE *args;
05671 
05672                         value_expr((yyvsp[(6) - (6)].val));
05673                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
05674                         args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
05675                         if ((yyvsp[(5) - (6)].val) == tOROP) {
05676                             (yyvsp[(5) - (6)].val) = 0;
05677                         }
05678                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
05679                             (yyvsp[(5) - (6)].val) = 1;
05680                         }
05681                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
05682                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
05683 #endif
05684                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
05685                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
05686 
05687                     ;}
05688     break;
05689 
05690   case 37:
05691 #line 1193 "ripper.y"
05692     {
05693                         value_expr((yyvsp[(5) - (5)].val));
05694                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05695                     ;}
05696     break;
05697 
05698   case 38:
05699 #line 1198 "ripper.y"
05700     {
05701                         value_expr((yyvsp[(5) - (5)].val));
05702                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05703                     ;}
05704     break;
05705 
05706   case 39:
05707 #line 1203 "ripper.y"
05708     {
05709 #if 0
05710                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05711                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05712 #endif
05713                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
05714                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05715 
05716                     ;}
05717     break;
05718 
05719   case 40:
05720 #line 1213 "ripper.y"
05721     {
05722                         value_expr((yyvsp[(5) - (5)].val));
05723                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
05724                     ;}
05725     break;
05726 
05727   case 41:
05728 #line 1218 "ripper.y"
05729     {
05730 #if 0
05731                         rb_backref_error((yyvsp[(1) - (3)].val));
05732                         (yyval.val) = NEW_BEGIN(0);
05733 #endif
05734                         (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
05735                         (yyval.val) = dispatch1(assign_error, (yyval.val));
05736 
05737                     ;}
05738     break;
05739 
05740   case 42:
05741 #line 1228 "ripper.y"
05742     {
05743 #if 0
05744                         value_expr((yyvsp[(3) - (3)].val));
05745                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05746 #endif
05747                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05748 
05749                     ;}
05750     break;
05751 
05752   case 43:
05753 #line 1237 "ripper.y"
05754     {
05755 #if 0
05756                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05757                         (yyval.val) = (yyvsp[(1) - (3)].val);
05758 #endif
05759                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05760 
05761                     ;}
05762     break;
05763 
05764   case 44:
05765 #line 1246 "ripper.y"
05766     {
05767 #if 0
05768                         (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
05769                         (yyval.val) = (yyvsp[(1) - (3)].val);
05770 #endif
05771                         (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05772 
05773                     ;}
05774     break;
05775 
05776   case 46:
05777 #line 1258 "ripper.y"
05778     {
05779 #if 0
05780                         value_expr((yyvsp[(3) - (3)].val));
05781                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05782 #endif
05783                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05784 
05785                     ;}
05786     break;
05787 
05788   case 47:
05789 #line 1267 "ripper.y"
05790     {
05791 #if 0
05792                         value_expr((yyvsp[(3) - (3)].val));
05793                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05794 #endif
05795                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05796 
05797                     ;}
05798     break;
05799 
05800   case 49:
05801 #line 1280 "ripper.y"
05802     {
05803 #if 0
05804                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05805 #endif
05806                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
05807 
05808                     ;}
05809     break;
05810 
05811   case 50:
05812 #line 1288 "ripper.y"
05813     {
05814 #if 0
05815                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
05816 #endif
05817                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
05818 
05819                     ;}
05820     break;
05821 
05822   case 51:
05823 #line 1296 "ripper.y"
05824     {
05825 #if 0
05826                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
05827 #endif
05828                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
05829 
05830                     ;}
05831     break;
05832 
05833   case 52:
05834 #line 1304 "ripper.y"
05835     {
05836 #if 0
05837                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
05838 #endif
05839                         (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
05840 
05841                     ;}
05842     break;
05843 
05844   case 54:
05845 #line 1315 "ripper.y"
05846     {
05847 #if 0
05848                         value_expr((yyvsp[(1) - (1)].val));
05849                         (yyval.val) = (yyvsp[(1) - (1)].val);
05850                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
05851 #endif
05852                         (yyval.val) = (yyvsp[(1) - (1)].val);
05853 
05854                     ;}
05855     break;
05856 
05857   case 58:
05858 #line 1332 "ripper.y"
05859     {
05860 #if 0
05861                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05862 #endif
05863                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
05864                         (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
05865 
05866                     ;}
05867     break;
05868 
05869   case 59:
05870 #line 1343 "ripper.y"
05871     {
05872                         (yyvsp[(1) - (1)].vars) = dyna_push();
05873 #if 0
05874                         (yyval.num) = ruby_sourceline;
05875 #endif
05876 
05877                     ;}
05878     break;
05879 
05880   case 60:
05881 #line 1353 "ripper.y"
05882     {
05883 #if 0
05884                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
05885                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
05886 #endif
05887                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
05888 
05889                         dyna_pop((yyvsp[(1) - (5)].vars));
05890                     ;}
05891     break;
05892 
05893   case 61:
05894 #line 1365 "ripper.y"
05895     {
05896 #if 0
05897                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
05898                         nd_set_line((yyval.val), tokline);
05899 #endif
05900 
05901                     ;}
05902     break;
05903 
05904   case 62:
05905 #line 1375 "ripper.y"
05906     {
05907 #if 0
05908                         (yyval.val) = (yyvsp[(1) - (2)].val);
05909                         (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
05910 #endif
05911                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
05912 
05913                     ;}
05914     break;
05915 
05916   case 63:
05917 #line 1384 "ripper.y"
05918     {
05919 #if 0
05920                         block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
05921                         (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
05922                         (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
05923                         (yyval.val) = (yyvsp[(3) - (3)].val);
05924                         fixpos((yyval.val), (yyvsp[(1) - (3)].val));
05925 #endif
05926                         (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
05927                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
05928 
05929                     ;}
05930     break;
05931 
05932   case 64:
05933 #line 1397 "ripper.y"
05934     {
05935 #if 0
05936                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05937                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05938 #endif
05939                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05940 
05941                     ;}
05942     break;
05943 
05944   case 65:
05945 #line 1406 "ripper.y"
05946     {
05947 #if 0
05948                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05949                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05950                         (yyval.val) = (yyvsp[(5) - (5)].val);
05951                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05952 #endif
05953                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05954                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05955 
05956                    ;}
05957     break;
05958 
05959   case 66:
05960 #line 1418 "ripper.y"
05961     {
05962 #if 0
05963                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05964                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
05965 #endif
05966                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
05967 
05968                     ;}
05969     break;
05970 
05971   case 67:
05972 #line 1427 "ripper.y"
05973     {
05974 #if 0
05975                         block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
05976                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05977                         (yyval.val) = (yyvsp[(5) - (5)].val);
05978                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
05979 #endif
05980                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
05981                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
05982 
05983                    ;}
05984     break;
05985 
05986   case 68:
05987 #line 1439 "ripper.y"
05988     {
05989 #if 0
05990                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
05991                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
05992 #endif
05993                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
05994 
05995                     ;}
05996     break;
05997 
05998   case 69:
05999 #line 1448 "ripper.y"
06000     {
06001 #if 0
06002                         (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
06003                         fixpos((yyval.val), (yyvsp[(2) - (2)].val));
06004 #endif
06005                         (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
06006 
06007                     ;}
06008     break;
06009 
06010   case 70:
06011 #line 1457 "ripper.y"
06012     {
06013 #if 0
06014                         (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
06015 #endif
06016                         (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
06017 
06018                     ;}
06019     break;
06020 
06021   case 71:
06022 #line 1465 "ripper.y"
06023     {
06024 #if 0
06025                         (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
06026 #endif
06027                         (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
06028 
06029                     ;}
06030     break;
06031 
06032   case 72:
06033 #line 1473 "ripper.y"
06034     {
06035 #if 0
06036                         (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
06037 #endif
06038                         (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
06039 
06040                     ;}
06041     break;
06042 
06043   case 74:
06044 #line 1484 "ripper.y"
06045     {
06046 #if 0
06047                         (yyval.val) = (yyvsp[(2) - (3)].val);
06048 #endif
06049                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06050 
06051                     ;}
06052     break;
06053 
06054   case 76:
06055 #line 1495 "ripper.y"
06056     {
06057 #if 0
06058                         (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
06059 #endif
06060                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06061 
06062                     ;}
06063     break;
06064 
06065   case 77:
06066 #line 1505 "ripper.y"
06067     {
06068 #if 0
06069                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
06070 #endif
06071                         (yyval.val) = (yyvsp[(1) - (1)].val);
06072 
06073                     ;}
06074     break;
06075 
06076   case 78:
06077 #line 1513 "ripper.y"
06078     {
06079 #if 0
06080                         (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
06081 #endif
06082                         (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
06083 
06084                     ;}
06085     break;
06086 
06087   case 79:
06088 #line 1521 "ripper.y"
06089     {
06090 #if 0
06091                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06092 #endif
06093                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06094 
06095                     ;}
06096     break;
06097 
06098   case 80:
06099 #line 1529 "ripper.y"
06100     {
06101 #if 0
06102                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
06103 #endif
06104                         (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06105                         (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
06106 
06107                     ;}
06108     break;
06109 
06110   case 81:
06111 #line 1538 "ripper.y"
06112     {
06113 #if 0
06114                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
06115 #endif
06116                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
06117 
06118                     ;}
06119     break;
06120 
06121   case 82:
06122 #line 1546 "ripper.y"
06123     {
06124 #if 0
06125                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
06126 #endif
06127                         (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
06128                         (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06129 
06130                     ;}
06131     break;
06132 
06133   case 83:
06134 #line 1555 "ripper.y"
06135     {
06136 #if 0
06137                         (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
06138 #endif
06139                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
06140 
06141                     ;}
06142     break;
06143 
06144   case 84:
06145 #line 1563 "ripper.y"
06146     {
06147 #if 0
06148                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
06149 #endif
06150                         (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
06151                         (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
06152 
06153                     ;}
06154     break;
06155 
06156   case 85:
06157 #line 1572 "ripper.y"
06158     {
06159 #if 0
06160                         (yyval.val) = NEW_MASGN(0, -1);
06161 #endif
06162                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06163 
06164                     ;}
06165     break;
06166 
06167   case 86:
06168 #line 1580 "ripper.y"
06169     {
06170 #if 0
06171                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
06172 #endif
06173                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
06174                         (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
06175 
06176                     ;}
06177     break;
06178 
06179   case 88:
06180 #line 1592 "ripper.y"
06181     {
06182 #if 0
06183                         (yyval.val) = (yyvsp[(2) - (3)].val);
06184 #endif
06185                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
06186 
06187                     ;}
06188     break;
06189 
06190   case 89:
06191 #line 1602 "ripper.y"
06192     {
06193 #if 0
06194                         (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
06195 #endif
06196                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
06197 
06198                     ;}
06199     break;
06200 
06201   case 90:
06202 #line 1610 "ripper.y"
06203     {
06204 #if 0
06205                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06206 #endif
06207                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
06208 
06209                     ;}
06210     break;
06211 
06212   case 91:
06213 #line 1620 "ripper.y"
06214     {
06215 #if 0
06216                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
06217 #endif
06218                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
06219 
06220                     ;}
06221     break;
06222 
06223   case 92:
06224 #line 1628 "ripper.y"
06225     {
06226 #if 0
06227                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06228 #endif
06229                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06230 
06231                     ;}
06232     break;
06233 
06234   case 93:
06235 #line 1638 "ripper.y"
06236     {
06237                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06238                     ;}
06239     break;
06240 
06241   case 94:
06242 #line 1642 "ripper.y"
06243     {
06244                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06245                     ;}
06246     break;
06247 
06248   case 95:
06249 #line 1646 "ripper.y"
06250     {
06251 #if 0
06252                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06253 #endif
06254                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06255 
06256                     ;}
06257     break;
06258 
06259   case 96:
06260 #line 1654 "ripper.y"
06261     {
06262 #if 0
06263                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06264 #endif
06265                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06266 
06267                     ;}
06268     break;
06269 
06270   case 97:
06271 #line 1662 "ripper.y"
06272     {
06273 #if 0
06274                         (yyval.val) = attrset((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 
06278                     ;}
06279     break;
06280 
06281   case 98:
06282 #line 1670 "ripper.y"
06283     {
06284 #if 0
06285                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06286 #endif
06287                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06288 
06289                     ;}
06290     break;
06291 
06292   case 99:
06293 #line 1678 "ripper.y"
06294     {
06295 #if 0
06296                         if (in_def || in_single)
06297                             yyerror("dynamic constant assignment");
06298                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06299 #endif
06300                         if (in_def || in_single)
06301                             yyerror("dynamic constant assignment");
06302                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06303 
06304                     ;}
06305     break;
06306 
06307   case 100:
06308 #line 1690 "ripper.y"
06309     {
06310 #if 0
06311                         if (in_def || in_single)
06312                             yyerror("dynamic constant assignment");
06313                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06314 #endif
06315                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06316 
06317                     ;}
06318     break;
06319 
06320   case 101:
06321 #line 1700 "ripper.y"
06322     {
06323 #if 0
06324                         rb_backref_error((yyvsp[(1) - (1)].val));
06325                         (yyval.val) = NEW_BEGIN(0);
06326 #endif
06327                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
06328                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06329 
06330                     ;}
06331     break;
06332 
06333   case 102:
06334 #line 1712 "ripper.y"
06335     {
06336                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06337 #if 0
06338                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06339 #endif
06340                         (yyval.val) = dispatch1(var_field, (yyval.val));
06341 
06342                     ;}
06343     break;
06344 
06345   case 103:
06346 #line 1721 "ripper.y"
06347     {
06348                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
06349 #if 0
06350                         if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
06351 #endif
06352                         (yyval.val) = dispatch1(var_field, (yyval.val));
06353 
06354                     ;}
06355     break;
06356 
06357   case 104:
06358 #line 1730 "ripper.y"
06359     {
06360 #if 0
06361                         (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
06362 #endif
06363                         (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
06364 
06365                     ;}
06366     break;
06367 
06368   case 105:
06369 #line 1738 "ripper.y"
06370     {
06371 #if 0
06372                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06373 #endif
06374                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06375 
06376                     ;}
06377     break;
06378 
06379   case 106:
06380 #line 1746 "ripper.y"
06381     {
06382 #if 0
06383                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06384 #endif
06385                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
06386 
06387                     ;}
06388     break;
06389 
06390   case 107:
06391 #line 1754 "ripper.y"
06392     {
06393 #if 0
06394                         (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06395 #endif
06396                         (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
06397 
06398                     ;}
06399     break;
06400 
06401   case 108:
06402 #line 1762 "ripper.y"
06403     {
06404 #if 0
06405                         if (in_def || in_single)
06406                             yyerror("dynamic constant assignment");
06407                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
06408 #endif
06409                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06410                         if (in_def || in_single) {
06411                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06412                         }
06413 
06414                     ;}
06415     break;
06416 
06417   case 109:
06418 #line 1775 "ripper.y"
06419     {
06420 #if 0
06421                         if (in_def || in_single)
06422                             yyerror("dynamic constant assignment");
06423                         (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
06424 #endif
06425                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
06426                         if (in_def || in_single) {
06427                             (yyval.val) = dispatch1(assign_error, (yyval.val));
06428                         }
06429 
06430                     ;}
06431     break;
06432 
06433   case 110:
06434 #line 1788 "ripper.y"
06435     {
06436 #if 0
06437                         rb_backref_error((yyvsp[(1) - (1)].val));
06438                         (yyval.val) = NEW_BEGIN(0);
06439 #endif
06440                         (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
06441 
06442                     ;}
06443     break;
06444 
06445   case 111:
06446 #line 1799 "ripper.y"
06447     {
06448 #if 0
06449                         yyerror("class/module name must be CONSTANT");
06450 #endif
06451                         (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
06452 
06453                     ;}
06454     break;
06455 
06456   case 113:
06457 #line 1810 "ripper.y"
06458     {
06459 #if 0
06460                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
06461 #endif
06462                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
06463 
06464                     ;}
06465     break;
06466 
06467   case 114:
06468 #line 1818 "ripper.y"
06469     {
06470 #if 0
06471                         (yyval.val) = NEW_COLON2(0, (yyval.val));
06472 #endif
06473                         (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
06474 
06475                     ;}
06476     break;
06477 
06478   case 115:
06479 #line 1826 "ripper.y"
06480     {
06481 #if 0
06482                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06483 #endif
06484                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06485 
06486                     ;}
06487     break;
06488 
06489   case 119:
06490 #line 1839 "ripper.y"
06491     {
06492                         lex_state = EXPR_ENDFN;
06493                         (yyval.val) = (yyvsp[(1) - (1)].val);
06494                     ;}
06495     break;
06496 
06497   case 120:
06498 #line 1844 "ripper.y"
06499     {
06500                         lex_state = EXPR_ENDFN;
06501 #if 0
06502                         (yyval.val) = (yyvsp[(1) - (1)].id);
06503 #endif
06504                         (yyval.val) = (yyvsp[(1) - (1)].val);
06505 
06506                     ;}
06507     break;
06508 
06509   case 123:
06510 #line 1859 "ripper.y"
06511     {
06512 #if 0
06513                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
06514 #endif
06515                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
06516 
06517                     ;}
06518     break;
06519 
06520   case 125:
06521 #line 1870 "ripper.y"
06522     {
06523 #if 0
06524                         (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
06525 #endif
06526                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
06527 
06528                     ;}
06529     break;
06530 
06531   case 126:
06532 #line 1877 "ripper.y"
06533     {lex_state = EXPR_FNAME;;}
06534     break;
06535 
06536   case 127:
06537 #line 1878 "ripper.y"
06538     {
06539 #if 0
06540                         (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
06541 #endif
06542                         rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
06543 
06544                     ;}
06545     break;
06546 
06547   case 128:
06548 #line 1887 "ripper.y"
06549     { ifndef_ripper((yyval.val) = '|'); ;}
06550     break;
06551 
06552   case 129:
06553 #line 1888 "ripper.y"
06554     { ifndef_ripper((yyval.val) = '^'); ;}
06555     break;
06556 
06557   case 130:
06558 #line 1889 "ripper.y"
06559     { ifndef_ripper((yyval.val) = '&'); ;}
06560     break;
06561 
06562   case 131:
06563 #line 1890 "ripper.y"
06564     { ifndef_ripper((yyval.val) = tCMP); ;}
06565     break;
06566 
06567   case 132:
06568 #line 1891 "ripper.y"
06569     { ifndef_ripper((yyval.val) = tEQ); ;}
06570     break;
06571 
06572   case 133:
06573 #line 1892 "ripper.y"
06574     { ifndef_ripper((yyval.val) = tEQQ); ;}
06575     break;
06576 
06577   case 134:
06578 #line 1893 "ripper.y"
06579     { ifndef_ripper((yyval.val) = tMATCH); ;}
06580     break;
06581 
06582   case 135:
06583 #line 1894 "ripper.y"
06584     { ifndef_ripper((yyval.val) = tNMATCH); ;}
06585     break;
06586 
06587   case 136:
06588 #line 1895 "ripper.y"
06589     { ifndef_ripper((yyval.val) = '>'); ;}
06590     break;
06591 
06592   case 137:
06593 #line 1896 "ripper.y"
06594     { ifndef_ripper((yyval.val) = tGEQ); ;}
06595     break;
06596 
06597   case 138:
06598 #line 1897 "ripper.y"
06599     { ifndef_ripper((yyval.val) = '<'); ;}
06600     break;
06601 
06602   case 139:
06603 #line 1898 "ripper.y"
06604     { ifndef_ripper((yyval.val) = tLEQ); ;}
06605     break;
06606 
06607   case 140:
06608 #line 1899 "ripper.y"
06609     { ifndef_ripper((yyval.val) = tNEQ); ;}
06610     break;
06611 
06612   case 141:
06613 #line 1900 "ripper.y"
06614     { ifndef_ripper((yyval.val) = tLSHFT); ;}
06615     break;
06616 
06617   case 142:
06618 #line 1901 "ripper.y"
06619     { ifndef_ripper((yyval.val) = tRSHFT); ;}
06620     break;
06621 
06622   case 143:
06623 #line 1902 "ripper.y"
06624     { ifndef_ripper((yyval.val) = '+'); ;}
06625     break;
06626 
06627   case 144:
06628 #line 1903 "ripper.y"
06629     { ifndef_ripper((yyval.val) = '-'); ;}
06630     break;
06631 
06632   case 145:
06633 #line 1904 "ripper.y"
06634     { ifndef_ripper((yyval.val) = '*'); ;}
06635     break;
06636 
06637   case 146:
06638 #line 1905 "ripper.y"
06639     { ifndef_ripper((yyval.val) = '*'); ;}
06640     break;
06641 
06642   case 147:
06643 #line 1906 "ripper.y"
06644     { ifndef_ripper((yyval.val) = '/'); ;}
06645     break;
06646 
06647   case 148:
06648 #line 1907 "ripper.y"
06649     { ifndef_ripper((yyval.val) = '%'); ;}
06650     break;
06651 
06652   case 149:
06653 #line 1908 "ripper.y"
06654     { ifndef_ripper((yyval.val) = tPOW); ;}
06655     break;
06656 
06657   case 150:
06658 #line 1909 "ripper.y"
06659     { ifndef_ripper((yyval.val) = tDSTAR); ;}
06660     break;
06661 
06662   case 151:
06663 #line 1910 "ripper.y"
06664     { ifndef_ripper((yyval.val) = '!'); ;}
06665     break;
06666 
06667   case 152:
06668 #line 1911 "ripper.y"
06669     { ifndef_ripper((yyval.val) = '~'); ;}
06670     break;
06671 
06672   case 153:
06673 #line 1912 "ripper.y"
06674     { ifndef_ripper((yyval.val) = tUPLUS); ;}
06675     break;
06676 
06677   case 154:
06678 #line 1913 "ripper.y"
06679     { ifndef_ripper((yyval.val) = tUMINUS); ;}
06680     break;
06681 
06682   case 155:
06683 #line 1914 "ripper.y"
06684     { ifndef_ripper((yyval.val) = tAREF); ;}
06685     break;
06686 
06687   case 156:
06688 #line 1915 "ripper.y"
06689     { ifndef_ripper((yyval.val) = tASET); ;}
06690     break;
06691 
06692   case 157:
06693 #line 1916 "ripper.y"
06694     { ifndef_ripper((yyval.val) = '`'); ;}
06695     break;
06696 
06697   case 199:
06698 #line 1934 "ripper.y"
06699     {
06700 #if 0
06701                         value_expr((yyvsp[(3) - (3)].val));
06702                         (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06703 #endif
06704                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06705 
06706                     ;}
06707     break;
06708 
06709   case 200:
06710 #line 1943 "ripper.y"
06711     {
06712 #if 0
06713                         value_expr((yyvsp[(3) - (5)].val));
06714                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06715                         (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06716 #endif
06717                         (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
06718 
06719                     ;}
06720     break;
06721 
06722   case 201:
06723 #line 1953 "ripper.y"
06724     {
06725                         value_expr((yyvsp[(3) - (3)].val));
06726                         (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06727                     ;}
06728     break;
06729 
06730   case 202:
06731 #line 1958 "ripper.y"
06732     {
06733 #if 0
06734                         value_expr((yyvsp[(3) - (5)].val));
06735                         (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
06736 #endif
06737                         (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
06738 
06739                         (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
06740                     ;}
06741     break;
06742 
06743   case 203:
06744 #line 1968 "ripper.y"
06745     {
06746 #if 0
06747                         NODE *args;
06748 
06749                         value_expr((yyvsp[(6) - (6)].val));
06750                         if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
06751                         if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
06752                             args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06753                         }
06754                         else {
06755                             args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
06756                         }
06757                         if ((yyvsp[(5) - (6)].val) == tOROP) {
06758                             (yyvsp[(5) - (6)].val) = 0;
06759                         }
06760                         else if ((yyvsp[(5) - (6)].val) == tANDOP) {
06761                             (yyvsp[(5) - (6)].val) = 1;
06762                         }
06763                         (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
06764                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
06765 #endif
06766                         (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
06767                         (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
06768 
06769                     ;}
06770     break;
06771 
06772   case 204:
06773 #line 1994 "ripper.y"
06774     {
06775                         value_expr((yyvsp[(5) - (5)].val));
06776                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06777                     ;}
06778     break;
06779 
06780   case 205:
06781 #line 1999 "ripper.y"
06782     {
06783                         value_expr((yyvsp[(5) - (5)].val));
06784                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06785                     ;}
06786     break;
06787 
06788   case 206:
06789 #line 2004 "ripper.y"
06790     {
06791                         value_expr((yyvsp[(5) - (5)].val));
06792                         (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06793                     ;}
06794     break;
06795 
06796   case 207:
06797 #line 2009 "ripper.y"
06798     {
06799 #if 0
06800                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06801                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06802 #endif
06803                         (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
06804                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
06805 
06806                     ;}
06807     break;
06808 
06809   case 208:
06810 #line 2019 "ripper.y"
06811     {
06812 #if 0
06813                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
06814                         (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06815 #endif
06816                         (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
06817                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
06818 
06819                     ;}
06820     break;
06821 
06822   case 209:
06823 #line 2029 "ripper.y"
06824     {
06825 #if 0
06826                         rb_backref_error((yyvsp[(1) - (3)].val));
06827                         (yyval.val) = NEW_BEGIN(0);
06828 #endif
06829                         (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
06830                         (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
06831                         (yyval.val) = dispatch1(assign_error, (yyval.val));
06832 
06833                     ;}
06834     break;
06835 
06836   case 210:
06837 #line 2040 "ripper.y"
06838     {
06839 #if 0
06840                         value_expr((yyvsp[(1) - (3)].val));
06841                         value_expr((yyvsp[(3) - (3)].val));
06842                         (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06843                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06844                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06845                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06846                         }
06847 #endif
06848                         (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06849 
06850                     ;}
06851     break;
06852 
06853   case 211:
06854 #line 2054 "ripper.y"
06855     {
06856 #if 0
06857                         value_expr((yyvsp[(1) - (3)].val));
06858                         value_expr((yyvsp[(3) - (3)].val));
06859                         (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06860                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
06861                             nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
06862                             deferred_nodes = list_append(deferred_nodes, (yyval.val));
06863                         }
06864 #endif
06865                         (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
06866 
06867                     ;}
06868     break;
06869 
06870   case 212:
06871 #line 2068 "ripper.y"
06872     {
06873 #if 0
06874                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
06875 #endif
06876                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
06877 
06878                     ;}
06879     break;
06880 
06881   case 213:
06882 #line 2076 "ripper.y"
06883     {
06884 #if 0
06885                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
06886 #endif
06887                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
06888 
06889                     ;}
06890     break;
06891 
06892   case 214:
06893 #line 2084 "ripper.y"
06894     {
06895 #if 0
06896                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
06897 #endif
06898                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
06899 
06900                     ;}
06901     break;
06902 
06903   case 215:
06904 #line 2092 "ripper.y"
06905     {
06906 #if 0
06907                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
06908 #endif
06909                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
06910 
06911                     ;}
06912     break;
06913 
06914   case 216:
06915 #line 2100 "ripper.y"
06916     {
06917 #if 0
06918                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
06919 #endif
06920                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
06921 
06922                     ;}
06923     break;
06924 
06925   case 217:
06926 #line 2108 "ripper.y"
06927     {
06928 #if 0
06929                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
06930 #endif
06931                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
06932 
06933                     ;}
06934     break;
06935 
06936   case 218:
06937 #line 2116 "ripper.y"
06938     {
06939 #if 0
06940                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
06941 #endif
06942                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
06943                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
06944 
06945                     ;}
06946     break;
06947 
06948   case 219:
06949 #line 2125 "ripper.y"
06950     {
06951 #if 0
06952                         (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
06953 #endif
06954                         (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
06955                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
06956 
06957                     ;}
06958     break;
06959 
06960   case 220:
06961 #line 2134 "ripper.y"
06962     {
06963 #if 0
06964                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
06965 #endif
06966                         (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
06967 
06968                     ;}
06969     break;
06970 
06971   case 221:
06972 #line 2142 "ripper.y"
06973     {
06974 #if 0
06975                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
06976 #endif
06977                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
06978 
06979                     ;}
06980     break;
06981 
06982   case 222:
06983 #line 2150 "ripper.y"
06984     {
06985 #if 0
06986                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
06987 #endif
06988                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
06989 
06990                     ;}
06991     break;
06992 
06993   case 223:
06994 #line 2158 "ripper.y"
06995     {
06996 #if 0
06997                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
06998 #endif
06999                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
07000 
07001                     ;}
07002     break;
07003 
07004   case 224:
07005 #line 2166 "ripper.y"
07006     {
07007 #if 0
07008                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
07009 #endif
07010                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
07011 
07012                     ;}
07013     break;
07014 
07015   case 225:
07016 #line 2174 "ripper.y"
07017     {
07018 #if 0
07019                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
07020 #endif
07021                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
07022 
07023                     ;}
07024     break;
07025 
07026   case 226:
07027 #line 2182 "ripper.y"
07028     {
07029 #if 0
07030                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
07031 #endif
07032                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
07033 
07034                     ;}
07035     break;
07036 
07037   case 227:
07038 #line 2190 "ripper.y"
07039     {
07040 #if 0
07041                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
07042 #endif
07043                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
07044 
07045                     ;}
07046     break;
07047 
07048   case 228:
07049 #line 2198 "ripper.y"
07050     {
07051 #if 0
07052                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
07053 #endif
07054                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
07055 
07056                     ;}
07057     break;
07058 
07059   case 229:
07060 #line 2206 "ripper.y"
07061     {
07062 #if 0
07063                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
07064 #endif
07065                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
07066 
07067                     ;}
07068     break;
07069 
07070   case 230:
07071 #line 2214 "ripper.y"
07072     {
07073 #if 0
07074                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
07075 #endif
07076                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
07077 
07078                     ;}
07079     break;
07080 
07081   case 231:
07082 #line 2222 "ripper.y"
07083     {
07084 #if 0
07085                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
07086 #endif
07087                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
07088 
07089                     ;}
07090     break;
07091 
07092   case 232:
07093 #line 2230 "ripper.y"
07094     {
07095 #if 0
07096                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
07097 #endif
07098                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
07099 
07100                     ;}
07101     break;
07102 
07103   case 233:
07104 #line 2238 "ripper.y"
07105     {
07106 #if 0
07107                         (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07108                         if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
07109                             (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
07110                         }
07111 #endif
07112                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
07113 
07114                     ;}
07115     break;
07116 
07117   case 234:
07118 #line 2249 "ripper.y"
07119     {
07120 #if 0
07121                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
07122 #endif
07123                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
07124 
07125                     ;}
07126     break;
07127 
07128   case 235:
07129 #line 2257 "ripper.y"
07130     {
07131 #if 0
07132                         (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
07133 #endif
07134                         (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
07135 
07136                     ;}
07137     break;
07138 
07139   case 236:
07140 #line 2265 "ripper.y"
07141     {
07142 #if 0
07143                         (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
07144 #endif
07145                         (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
07146 
07147                     ;}
07148     break;
07149 
07150   case 237:
07151 #line 2273 "ripper.y"
07152     {
07153 #if 0
07154                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
07155 #endif
07156                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
07157 
07158                     ;}
07159     break;
07160 
07161   case 238:
07162 #line 2281 "ripper.y"
07163     {
07164 #if 0
07165                         (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (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 239:
07173 #line 2289 "ripper.y"
07174     {
07175 #if 0
07176                         (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07177 #endif
07178                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
07179 
07180                     ;}
07181     break;
07182 
07183   case 240:
07184 #line 2297 "ripper.y"
07185     {
07186 #if 0
07187                         (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07188 #endif
07189                         (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
07190 
07191                     ;}
07192     break;
07193 
07194   case 241:
07195 #line 2304 "ripper.y"
07196     {in_defined = 1;;}
07197     break;
07198 
07199   case 242:
07200 #line 2305 "ripper.y"
07201     {
07202 #if 0
07203                         in_defined = 0;
07204                         (yyval.val) = NEW_DEFINED((yyvsp[(4) - (4)].val));
07205 #endif
07206                         in_defined = 0;
07207                         (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
07208 
07209                     ;}
07210     break;
07211 
07212   case 243:
07213 #line 2315 "ripper.y"
07214     {
07215 #if 0
07216                         value_expr((yyvsp[(1) - (6)].val));
07217                         (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07218                         fixpos((yyval.val), (yyvsp[(1) - (6)].val));
07219 #endif
07220                         (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
07221 
07222                     ;}
07223     break;
07224 
07225   case 244:
07226 #line 2325 "ripper.y"
07227     {
07228                         (yyval.val) = (yyvsp[(1) - (1)].val);
07229                     ;}
07230     break;
07231 
07232   case 245:
07233 #line 2331 "ripper.y"
07234     {
07235 #if 0
07236                         value_expr((yyvsp[(1) - (1)].val));
07237                         (yyval.val) = (yyvsp[(1) - (1)].val);
07238                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
07239 #endif
07240                         (yyval.val) = (yyvsp[(1) - (1)].val);
07241 
07242                     ;}
07243     break;
07244 
07245   case 247:
07246 #line 2344 "ripper.y"
07247     {
07248                         (yyval.val) = (yyvsp[(1) - (2)].val);
07249                     ;}
07250     break;
07251 
07252   case 248:
07253 #line 2348 "ripper.y"
07254     {
07255 #if 0
07256                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07257 #endif
07258                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07259 
07260                     ;}
07261     break;
07262 
07263   case 249:
07264 #line 2356 "ripper.y"
07265     {
07266 #if 0
07267                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07268 #endif
07269                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07270 
07271                     ;}
07272     break;
07273 
07274   case 250:
07275 #line 2366 "ripper.y"
07276     {
07277 #if 0
07278                         (yyval.val) = (yyvsp[(2) - (3)].val);
07279 #endif
07280                         (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
07281 
07282                     ;}
07283     break;
07284 
07285   case 255:
07286 #line 2382 "ripper.y"
07287     {
07288                       (yyval.val) = (yyvsp[(1) - (2)].val);
07289                     ;}
07290     break;
07291 
07292   case 256:
07293 #line 2386 "ripper.y"
07294     {
07295 #if 0
07296                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07297 #endif
07298                         (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
07299 
07300                     ;}
07301     break;
07302 
07303   case 257:
07304 #line 2394 "ripper.y"
07305     {
07306 #if 0
07307                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07308 #endif
07309                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07310 
07311                     ;}
07312     break;
07313 
07314   case 258:
07315 #line 2404 "ripper.y"
07316     {
07317 #if 0
07318                         value_expr((yyvsp[(1) - (1)].val));
07319                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07320 #endif
07321                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07322 
07323                     ;}
07324     break;
07325 
07326   case 259:
07327 #line 2413 "ripper.y"
07328     {
07329 #if 0
07330                         (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07331 #endif
07332                         (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07333 
07334                     ;}
07335     break;
07336 
07337   case 260:
07338 #line 2421 "ripper.y"
07339     {
07340 #if 0
07341                         (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
07342                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
07343 #endif
07344                         (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
07345                         (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
07346 
07347                     ;}
07348     break;
07349 
07350   case 261:
07351 #line 2431 "ripper.y"
07352     {
07353 #if 0
07354                         (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
07355                         (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
07356 #endif
07357                         (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
07358 
07359                     ;}
07360     break;
07361 
07362   case 262:
07363 #line 2442 "ripper.y"
07364     {
07365                         (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
07366                     ;}
07367     break;
07368 
07369   case 263:
07370 #line 2448 "ripper.y"
07371     {
07372                         (yyval.val) = cmdarg_stack;
07373                         CMDARG_PUSH(1);
07374                     ;}
07375     break;
07376 
07377   case 264:
07378 #line 2453 "ripper.y"
07379     {
07380                         /* CMDARG_POP() */
07381                         cmdarg_stack = (yyvsp[(1) - (2)].val);
07382                         (yyval.val) = (yyvsp[(2) - (2)].val);
07383                     ;}
07384     break;
07385 
07386   case 265:
07387 #line 2461 "ripper.y"
07388     {
07389 #if 0
07390                         (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
07391 #endif
07392                         (yyval.val) = (yyvsp[(2) - (2)].val);
07393 
07394                     ;}
07395     break;
07396 
07397   case 266:
07398 #line 2471 "ripper.y"
07399     {
07400                         (yyval.val) = (yyvsp[(2) - (2)].val);
07401                     ;}
07402     break;
07403 
07404   case 267:
07405 #line 2475 "ripper.y"
07406     {
07407                         (yyval.val) = 0;
07408                     ;}
07409     break;
07410 
07411   case 268:
07412 #line 2481 "ripper.y"
07413     {
07414 #if 0
07415                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
07416 #endif
07417                         (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
07418 
07419                     ;}
07420     break;
07421 
07422   case 269:
07423 #line 2489 "ripper.y"
07424     {
07425 #if 0
07426                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07427 #endif
07428                         (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
07429 
07430                     ;}
07431     break;
07432 
07433   case 270:
07434 #line 2497 "ripper.y"
07435     {
07436 #if 0
07437                         NODE *n1;
07438                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07439                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07440                         }
07441                         else {
07442                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07443                         }
07444 #endif
07445                         (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07446 
07447                     ;}
07448     break;
07449 
07450   case 271:
07451 #line 2511 "ripper.y"
07452     {
07453 #if 0
07454                         NODE *n1;
07455                         if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07456                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07457                         }
07458                         else {
07459                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07460                         }
07461 #endif
07462                         (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07463 
07464                     ;}
07465     break;
07466 
07467   case 272:
07468 #line 2527 "ripper.y"
07469     {
07470 #if 0
07471                         NODE *n1;
07472                         if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
07473                             (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
07474                         }
07475                         else {
07476                             (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07477                         }
07478 #endif
07479                         (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
07480 
07481                     ;}
07482     break;
07483 
07484   case 273:
07485 #line 2541 "ripper.y"
07486     {
07487 #if 0
07488                         NODE *n1;
07489                         if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
07490                             (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
07491                             (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
07492                         }
07493                         else {
07494                             (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
07495                         }
07496 #endif
07497                         (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
07498 
07499                     ;}
07500     break;
07501 
07502   case 274:
07503 #line 2556 "ripper.y"
07504     {
07505 #if 0
07506                         (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
07507 #endif
07508                         (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
07509 
07510                     ;}
07511     break;
07512 
07513   case 285:
07514 #line 2576 "ripper.y"
07515     {
07516 #if 0
07517                         (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
07518 #endif
07519                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
07520 
07521                     ;}
07522     break;
07523 
07524   case 286:
07525 #line 2584 "ripper.y"
07526     {
07527                         (yyvsp[(1) - (1)].val) = cmdarg_stack;
07528                         cmdarg_stack = 0;
07529 #if 0
07530                         (yyval.num) = ruby_sourceline;
07531 #endif
07532 
07533                     ;}
07534     break;
07535 
07536   case 287:
07537 #line 2594 "ripper.y"
07538     {
07539                         cmdarg_stack = (yyvsp[(1) - (4)].val);
07540 #if 0
07541                         if ((yyvsp[(3) - (4)].val) == NULL) {
07542                             (yyval.val) = NEW_NIL();
07543                         }
07544                         else {
07545                             if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
07546                                 nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
07547                                 nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
07548                             (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
07549                         }
07550                         nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
07551 #endif
07552                         (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
07553 
07554                     ;}
07555     break;
07556 
07557   case 288:
07558 #line 2611 "ripper.y"
07559     {lex_state = EXPR_ENDARG;;}
07560     break;
07561 
07562   case 289:
07563 #line 2612 "ripper.y"
07564     {
07565 #if 0
07566                         (yyval.val) = 0;
07567 #endif
07568                         (yyval.val) = dispatch1(paren, 0);
07569 
07570                     ;}
07571     break;
07572 
07573   case 290:
07574 #line 2619 "ripper.y"
07575     {lex_state = EXPR_ENDARG;;}
07576     break;
07577 
07578   case 291:
07579 #line 2620 "ripper.y"
07580     {
07581 #if 0
07582                         (yyval.val) = (yyvsp[(2) - (4)].val);
07583 #endif
07584                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
07585 
07586                     ;}
07587     break;
07588 
07589   case 292:
07590 #line 2628 "ripper.y"
07591     {
07592 #if 0
07593                         (yyval.val) = (yyvsp[(2) - (3)].val);
07594 #endif
07595                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
07596 
07597                     ;}
07598     break;
07599 
07600   case 293:
07601 #line 2636 "ripper.y"
07602     {
07603 #if 0
07604                         (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07605 #endif
07606                         (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
07607 
07608                     ;}
07609     break;
07610 
07611   case 294:
07612 #line 2644 "ripper.y"
07613     {
07614 #if 0
07615                         (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
07616 #endif
07617                         (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
07618 
07619                     ;}
07620     break;
07621 
07622   case 295:
07623 #line 2652 "ripper.y"
07624     {
07625 #if 0
07626                         if ((yyvsp[(2) - (3)].val) == 0) {
07627                             (yyval.val) = NEW_ZARRAY(); /* zero length array*/
07628                         }
07629                         else {
07630                             (yyval.val) = (yyvsp[(2) - (3)].val);
07631                         }
07632 #endif
07633                         (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
07634 
07635                     ;}
07636     break;
07637 
07638   case 296:
07639 #line 2665 "ripper.y"
07640     {
07641 #if 0
07642                         (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
07643 #endif
07644                         (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
07645 
07646                     ;}
07647     break;
07648 
07649   case 297:
07650 #line 2673 "ripper.y"
07651     {
07652 #if 0
07653                         (yyval.val) = NEW_RETURN(0);
07654 #endif
07655                         (yyval.val) = dispatch0(return0);
07656 
07657                     ;}
07658     break;
07659 
07660   case 298:
07661 #line 2681 "ripper.y"
07662     {
07663 #if 0
07664                         (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
07665 #endif
07666                         (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
07667 
07668                     ;}
07669     break;
07670 
07671   case 299:
07672 #line 2689 "ripper.y"
07673     {
07674 #if 0
07675                         (yyval.val) = NEW_YIELD(0);
07676 #endif
07677                         (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
07678 
07679                     ;}
07680     break;
07681 
07682   case 300:
07683 #line 2697 "ripper.y"
07684     {
07685 #if 0
07686                         (yyval.val) = NEW_YIELD(0);
07687 #endif
07688                         (yyval.val) = dispatch0(yield0);
07689 
07690                     ;}
07691     break;
07692 
07693   case 301:
07694 #line 2704 "ripper.y"
07695     {in_defined = 1;;}
07696     break;
07697 
07698   case 302:
07699 #line 2705 "ripper.y"
07700     {
07701 #if 0
07702                         in_defined = 0;
07703                         (yyval.val) = NEW_DEFINED((yyvsp[(5) - (6)].val));
07704 #endif
07705                         in_defined = 0;
07706                         (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
07707 
07708                     ;}
07709     break;
07710 
07711   case 303:
07712 #line 2715 "ripper.y"
07713     {
07714 #if 0
07715                         (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
07716 #endif
07717                         (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
07718 
07719                     ;}
07720     break;
07721 
07722   case 304:
07723 #line 2723 "ripper.y"
07724     {
07725 #if 0
07726                         (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
07727 #endif
07728                         (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
07729 
07730                     ;}
07731     break;
07732 
07733   case 305:
07734 #line 2731 "ripper.y"
07735     {
07736 #if 0
07737                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
07738                         (yyval.val) = (yyvsp[(2) - (2)].val);
07739 #endif
07740                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
07741                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
07742 
07743                     ;}
07744     break;
07745 
07746   case 307:
07747 #line 2742 "ripper.y"
07748     {
07749 #if 0
07750                         block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
07751                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
07752                         (yyval.val) = (yyvsp[(2) - (2)].val);
07753 #endif
07754                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
07755 
07756                     ;}
07757     break;
07758 
07759   case 308:
07760 #line 2752 "ripper.y"
07761     {
07762                         (yyval.val) = (yyvsp[(2) - (2)].val);
07763                     ;}
07764     break;
07765 
07766   case 309:
07767 #line 2759 "ripper.y"
07768     {
07769 #if 0
07770                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07771                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07772 #endif
07773                         (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07774 
07775                     ;}
07776     break;
07777 
07778   case 310:
07779 #line 2771 "ripper.y"
07780     {
07781 #if 0
07782                         (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
07783                         fixpos((yyval.val), (yyvsp[(2) - (6)].val));
07784 #endif
07785                         (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
07786 
07787                     ;}
07788     break;
07789 
07790   case 311:
07791 #line 2779 "ripper.y"
07792     {COND_PUSH(1);;}
07793     break;
07794 
07795   case 312:
07796 #line 2779 "ripper.y"
07797     {COND_POP();;}
07798     break;
07799 
07800   case 313:
07801 #line 2782 "ripper.y"
07802     {
07803 #if 0
07804                         (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
07805                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
07806 #endif
07807                         (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
07808 
07809                     ;}
07810     break;
07811 
07812   case 314:
07813 #line 2790 "ripper.y"
07814     {COND_PUSH(1);;}
07815     break;
07816 
07817   case 315:
07818 #line 2790 "ripper.y"
07819     {COND_POP();;}
07820     break;
07821 
07822   case 316:
07823 #line 2793 "ripper.y"
07824     {
07825 #if 0
07826                         (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
07827                         fixpos((yyval.val), (yyvsp[(3) - (7)].val));
07828 #endif
07829                         (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
07830 
07831                     ;}
07832     break;
07833 
07834   case 317:
07835 #line 2804 "ripper.y"
07836     {
07837 #if 0
07838                         (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
07839                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
07840 #endif
07841                         (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
07842 
07843                     ;}
07844     break;
07845 
07846   case 318:
07847 #line 2813 "ripper.y"
07848     {
07849 #if 0
07850                         (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
07851 #endif
07852                         (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
07853 
07854                     ;}
07855     break;
07856 
07857   case 319:
07858 #line 2821 "ripper.y"
07859     {COND_PUSH(1);;}
07860     break;
07861 
07862   case 320:
07863 #line 2823 "ripper.y"
07864     {COND_POP();;}
07865     break;
07866 
07867   case 321:
07868 #line 2826 "ripper.y"
07869     {
07870 #if 0
07871                         /*
07872                          *  for a, b, c in e
07873                          *  #=>
07874                          *  e.each{|*x| a, b, c = x
07875                          *
07876                          *  for a in e
07877                          *  #=>
07878                          *  e.each{|x| a, = x}
07879                          */
07880                         ID id = internal_id();
07881                         ID *tbl = ALLOC_N(ID, 2);
07882                         NODE *m = NEW_ARGS_AUX(0, 0);
07883                         NODE *args, *scope;
07884 
07885                         if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
07886                             /* if args.length == 1 && args[0].kind_of?(Array)
07887                              *   args = args[0]
07888                              * end
07889                              */
07890                             NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
07891                             NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
07892                             m->nd_next = block_append(
07893                                 NEW_IF(
07894                                     NEW_NODE(NODE_AND,
07895                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
07896                                                       idEq, one),
07897                                              NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
07898                                                       rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
07899                                              0),
07900                                     NEW_DASGN_CURR(id,
07901                                                    NEW_CALL(NEW_DVAR(id), idAREF, zero)),
07902                                     0),
07903                                 node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
07904 
07905                             args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
07906                         }
07907                         else {
07908                             if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
07909                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
07910                                 nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
07911                                 (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
07912                                 m->nd_plen = 1;
07913                                 m->nd_next = (yyvsp[(2) - (9)].val);
07914                                 args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
07915                             }
07916                             else {
07917                                 m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
07918                                 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
07919                             }
07920                         }
07921                         scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
07922                         tbl[0] = 1; tbl[1] = id;
07923                         (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
07924                         fixpos((yyval.val), (yyvsp[(2) - (9)].val));
07925 #endif
07926                         (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
07927 
07928                     ;}
07929     break;
07930 
07931   case 322:
07932 #line 2887 "ripper.y"
07933     {
07934                         if (in_def || in_single)
07935                             yyerror("class definition in method body");
07936                         local_push(0);
07937 #if 0
07938                         (yyval.num) = ruby_sourceline;
07939 #endif
07940 
07941                     ;}
07942     break;
07943 
07944   case 323:
07945 #line 2898 "ripper.y"
07946     {
07947 #if 0
07948                         (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
07949                         nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
07950 #endif
07951                         (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
07952 
07953                         local_pop();
07954                     ;}
07955     break;
07956 
07957   case 324:
07958 #line 2908 "ripper.y"
07959     {
07960                         (yyval.num) = in_def;
07961                         in_def = 0;
07962                     ;}
07963     break;
07964 
07965   case 325:
07966 #line 2913 "ripper.y"
07967     {
07968                         (yyval.num) = in_single;
07969                         in_single = 0;
07970                         local_push(0);
07971                     ;}
07972     break;
07973 
07974   case 326:
07975 #line 2920 "ripper.y"
07976     {
07977 #if 0
07978                         (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
07979                         fixpos((yyval.val), (yyvsp[(3) - (8)].val));
07980 #endif
07981                         (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
07982 
07983                         local_pop();
07984                         in_def = (yyvsp[(4) - (8)].num);
07985                         in_single = (yyvsp[(6) - (8)].num);
07986                     ;}
07987     break;
07988 
07989   case 327:
07990 #line 2932 "ripper.y"
07991     {
07992                         if (in_def || in_single)
07993                             yyerror("module definition in method body");
07994                         local_push(0);
07995 #if 0
07996                         (yyval.num) = ruby_sourceline;
07997 #endif
07998 
07999                     ;}
08000     break;
08001 
08002   case 328:
08003 #line 2943 "ripper.y"
08004     {
08005 #if 0
08006                         (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08007                         nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
08008 #endif
08009                         (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
08010 
08011                         local_pop();
08012                     ;}
08013     break;
08014 
08015   case 329:
08016 #line 2953 "ripper.y"
08017     {
08018                         (yyval.id) = cur_mid;
08019                         cur_mid = (yyvsp[(2) - (2)].val);
08020                         in_def++;
08021                         local_push(0);
08022                     ;}
08023     break;
08024 
08025   case 330:
08026 #line 2962 "ripper.y"
08027     {
08028 #if 0
08029                         NODE *body = remove_begin((yyvsp[(5) - (6)].val));
08030                         reduce_nodes(&body);
08031                         (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
08032                         nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
08033 #endif
08034                         (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
08035 
08036                         local_pop();
08037                         in_def--;
08038                         cur_mid = (yyvsp[(3) - (6)].id);
08039                     ;}
08040     break;
08041 
08042   case 331:
08043 #line 2975 "ripper.y"
08044     {lex_state = EXPR_FNAME;;}
08045     break;
08046 
08047   case 332:
08048 #line 2976 "ripper.y"
08049     {
08050                         in_single++;
08051                         lex_state = EXPR_ENDFN; /* force for args */
08052                         local_push(0);
08053                     ;}
08054     break;
08055 
08056   case 333:
08057 #line 2984 "ripper.y"
08058     {
08059 #if 0
08060                         NODE *body = remove_begin((yyvsp[(8) - (9)].val));
08061                         reduce_nodes(&body);
08062                         (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
08063                         nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
08064 #endif
08065                         (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
08066 
08067                         local_pop();
08068                         in_single--;
08069                     ;}
08070     break;
08071 
08072   case 334:
08073 #line 2997 "ripper.y"
08074     {
08075 #if 0
08076                         (yyval.val) = NEW_BREAK(0);
08077 #endif
08078                         (yyval.val) = dispatch1(break, arg_new());
08079 
08080                     ;}
08081     break;
08082 
08083   case 335:
08084 #line 3005 "ripper.y"
08085     {
08086 #if 0
08087                         (yyval.val) = NEW_NEXT(0);
08088 #endif
08089                         (yyval.val) = dispatch1(next, arg_new());
08090 
08091                     ;}
08092     break;
08093 
08094   case 336:
08095 #line 3013 "ripper.y"
08096     {
08097 #if 0
08098                         (yyval.val) = NEW_REDO();
08099 #endif
08100                         (yyval.val) = dispatch0(redo);
08101 
08102                     ;}
08103     break;
08104 
08105   case 337:
08106 #line 3021 "ripper.y"
08107     {
08108 #if 0
08109                         (yyval.val) = NEW_RETRY();
08110 #endif
08111                         (yyval.val) = dispatch0(retry);
08112 
08113                     ;}
08114     break;
08115 
08116   case 338:
08117 #line 3031 "ripper.y"
08118     {
08119 #if 0
08120                         value_expr((yyvsp[(1) - (1)].val));
08121                         (yyval.val) = (yyvsp[(1) - (1)].val);
08122                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
08123 #endif
08124                         (yyval.val) = (yyvsp[(1) - (1)].val);
08125 
08126                     ;}
08127     break;
08128 
08129   case 339:
08130 #line 3043 "ripper.y"
08131     {
08132                         token_info_push("begin");
08133                     ;}
08134     break;
08135 
08136   case 340:
08137 #line 3049 "ripper.y"
08138     {
08139                         token_info_push("if");
08140                     ;}
08141     break;
08142 
08143   case 341:
08144 #line 3055 "ripper.y"
08145     {
08146                         token_info_push("unless");
08147                     ;}
08148     break;
08149 
08150   case 342:
08151 #line 3061 "ripper.y"
08152     {
08153                         token_info_push("while");
08154                     ;}
08155     break;
08156 
08157   case 343:
08158 #line 3067 "ripper.y"
08159     {
08160                         token_info_push("until");
08161                     ;}
08162     break;
08163 
08164   case 344:
08165 #line 3073 "ripper.y"
08166     {
08167                         token_info_push("case");
08168                     ;}
08169     break;
08170 
08171   case 345:
08172 #line 3079 "ripper.y"
08173     {
08174                         token_info_push("for");
08175                     ;}
08176     break;
08177 
08178   case 346:
08179 #line 3085 "ripper.y"
08180     {
08181                         token_info_push("class");
08182                     ;}
08183     break;
08184 
08185   case 347:
08186 #line 3091 "ripper.y"
08187     {
08188                         token_info_push("module");
08189                     ;}
08190     break;
08191 
08192   case 348:
08193 #line 3097 "ripper.y"
08194     {
08195                         token_info_push("def");
08196 #if 0
08197                         (yyval.num) = ruby_sourceline;
08198 #endif
08199 
08200                     ;}
08201     break;
08202 
08203   case 349:
08204 #line 3107 "ripper.y"
08205     {
08206                         token_info_pop("end");
08207                     ;}
08208     break;
08209 
08210   case 350:
08211 #line 3115 "ripper.y"
08212     { (yyval.val) = Qnil; ;}
08213     break;
08214 
08215   case 352:
08216 #line 3121 "ripper.y"
08217     { (yyval.val) = (yyvsp[(2) - (2)].val); ;}
08218     break;
08219 
08220   case 353:
08221 #line 3128 "ripper.y"
08222     { (yyval.val) = Qnil; ;}
08223     break;
08224 
08225   case 356:
08226 #line 3137 "ripper.y"
08227     {
08228 #if 0
08229                         (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08230                         fixpos((yyval.val), (yyvsp[(2) - (5)].val));
08231 #endif
08232                         (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
08233 
08234                     ;}
08235     break;
08236 
08237   case 358:
08238 #line 3149 "ripper.y"
08239     {
08240 #if 0
08241                         (yyval.val) = (yyvsp[(2) - (2)].val);
08242 #endif
08243                         (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
08244 
08245                     ;}
08246     break;
08247 
08248   case 361:
08249 #line 3163 "ripper.y"
08250     {
08251                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
08252 #if 0
08253 #endif
08254                         (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
08255 
08256                     ;}
08257     break;
08258 
08259   case 362:
08260 #line 3171 "ripper.y"
08261     {
08262 #if 0
08263                         (yyval.val) = (yyvsp[(2) - (3)].val);
08264 #endif
08265                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
08266 
08267                     ;}
08268     break;
08269 
08270   case 363:
08271 #line 3181 "ripper.y"
08272     {
08273 #if 0
08274                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
08275 #endif
08276                         (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
08277 
08278                     ;}
08279     break;
08280 
08281   case 364:
08282 #line 3189 "ripper.y"
08283     {
08284 #if 0
08285                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08286 #endif
08287                         (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08288 
08289                     ;}
08290     break;
08291 
08292   case 365:
08293 #line 3199 "ripper.y"
08294     {
08295 #if 0
08296                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
08297 #endif
08298                         (yyval.val) = (yyvsp[(1) - (1)].val);
08299 
08300                     ;}
08301     break;
08302 
08303   case 366:
08304 #line 3207 "ripper.y"
08305     {
08306                         (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
08307 #if 0
08308                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
08309 #endif
08310                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
08311 
08312                     ;}
08313     break;
08314 
08315   case 367:
08316 #line 3216 "ripper.y"
08317     {
08318                         (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
08319 #if 0
08320                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
08321 #endif
08322                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
08323 
08324                     ;}
08325     break;
08326 
08327   case 368:
08328 #line 3225 "ripper.y"
08329     {
08330 #if 0
08331                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
08332 #endif
08333                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
08334 
08335                     ;}
08336     break;
08337 
08338   case 369:
08339 #line 3233 "ripper.y"
08340     {
08341 #if 0
08342                         (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
08343 #endif
08344                         (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
08345 
08346                     ;}
08347     break;
08348 
08349   case 370:
08350 #line 3241 "ripper.y"
08351     {
08352                         (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
08353 #if 0
08354                         (yyval.val) = NEW_MASGN(0, (yyval.val));
08355 #endif
08356                         (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
08357 
08358                     ;}
08359     break;
08360 
08361   case 371:
08362 #line 3250 "ripper.y"
08363     {
08364                         (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
08365 #if 0
08366                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
08367 #endif
08368                       #if 0
08369                       TODO: Check me
08370                       #endif
08371                         (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
08372 
08373                     ;}
08374     break;
08375 
08376   case 372:
08377 #line 3262 "ripper.y"
08378     {
08379 #if 0
08380                         (yyval.val) = NEW_MASGN(0, -1);
08381 #endif
08382                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08383 
08384                     ;}
08385     break;
08386 
08387   case 373:
08388 #line 3270 "ripper.y"
08389     {
08390 #if 0
08391                         (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
08392 #endif
08393                         (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
08394 
08395                     ;}
08396     break;
08397 
08398   case 374:
08399 #line 3281 "ripper.y"
08400     {
08401                         (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08402                     ;}
08403     break;
08404 
08405   case 375:
08406 #line 3285 "ripper.y"
08407     {
08408                         (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
08409                     ;}
08410     break;
08411 
08412   case 376:
08413 #line 3289 "ripper.y"
08414     {
08415                         (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08416                     ;}
08417     break;
08418 
08419   case 377:
08420 #line 3293 "ripper.y"
08421     {
08422                         (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
08423                     ;}
08424     break;
08425 
08426   case 378:
08427 #line 3299 "ripper.y"
08428     {
08429                         (yyval.val) = (yyvsp[(2) - (2)].val);
08430                     ;}
08431     break;
08432 
08433   case 379:
08434 #line 3303 "ripper.y"
08435     {
08436                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
08437                     ;}
08438     break;
08439 
08440   case 380:
08441 #line 3309 "ripper.y"
08442     {
08443                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
08444                     ;}
08445     break;
08446 
08447   case 381:
08448 #line 3313 "ripper.y"
08449     {
08450                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
08451                     ;}
08452     break;
08453 
08454   case 382:
08455 #line 3317 "ripper.y"
08456     {
08457                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
08458                     ;}
08459     break;
08460 
08461   case 383:
08462 #line 3321 "ripper.y"
08463     {
08464                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08465                     ;}
08466     break;
08467 
08468   case 384:
08469 #line 3325 "ripper.y"
08470     {
08471                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
08472                     ;}
08473     break;
08474 
08475   case 385:
08476 #line 3329 "ripper.y"
08477     {
08478                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
08479 #if 0
08480 #endif
08481                         dispatch1(excessed_comma, (yyval.val));
08482 
08483                     ;}
08484     break;
08485 
08486   case 386:
08487 #line 3337 "ripper.y"
08488     {
08489                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08490                     ;}
08491     break;
08492 
08493   case 387:
08494 #line 3341 "ripper.y"
08495     {
08496                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
08497                     ;}
08498     break;
08499 
08500   case 388:
08501 #line 3345 "ripper.y"
08502     {
08503                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
08504                     ;}
08505     break;
08506 
08507   case 389:
08508 #line 3349 "ripper.y"
08509     {
08510                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
08511                     ;}
08512     break;
08513 
08514   case 390:
08515 #line 3353 "ripper.y"
08516     {
08517                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
08518                     ;}
08519     break;
08520 
08521   case 391:
08522 #line 3357 "ripper.y"
08523     {
08524                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08525                     ;}
08526     break;
08527 
08528   case 392:
08529 #line 3361 "ripper.y"
08530     {
08531                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
08532                     ;}
08533     break;
08534 
08535   case 393:
08536 #line 3365 "ripper.y"
08537     {
08538                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08539                     ;}
08540     break;
08541 
08542   case 394:
08543 #line 3369 "ripper.y"
08544     {
08545                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
08546                     ;}
08547     break;
08548 
08549   case 396:
08550 #line 3376 "ripper.y"
08551     {
08552                         command_start = TRUE;
08553                     ;}
08554     break;
08555 
08556   case 397:
08557 #line 3382 "ripper.y"
08558     {
08559 #if 0
08560                         (yyval.val) = 0;
08561 #endif
08562                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
08563                                           escape_Qundef((yyvsp[(2) - (3)].val)));
08564 
08565                     ;}
08566     break;
08567 
08568   case 398:
08569 #line 3391 "ripper.y"
08570     {
08571 #if 0
08572                         (yyval.val) = 0;
08573 #endif
08574                         (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
08575                                           Qnil);
08576 
08577                     ;}
08578     break;
08579 
08580   case 399:
08581 #line 3400 "ripper.y"
08582     {
08583 #if 0
08584                         (yyval.val) = (yyvsp[(2) - (4)].val);
08585 #endif
08586                         (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
08587 
08588                     ;}
08589     break;
08590 
08591   case 400:
08592 #line 3411 "ripper.y"
08593     {
08594                       (yyval.val) = 0;
08595                     ;}
08596     break;
08597 
08598   case 401:
08599 #line 3415 "ripper.y"
08600     {
08601 #if 0
08602                         (yyval.val) = 0;
08603 #endif
08604                         (yyval.val) = (yyvsp[(3) - (4)].val);
08605 
08606                     ;}
08607     break;
08608 
08609   case 402:
08610 #line 3427 "ripper.y"
08611     {
08612                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
08613                     ;}
08614     break;
08615 
08616   case 403:
08617 #line 3434 "ripper.y"
08618     {
08619                         rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
08620                     ;}
08621     break;
08622 
08623   case 404:
08624 #line 3441 "ripper.y"
08625     {
08626                         new_bv(get_id((yyvsp[(1) - (1)].val)));
08627 #if 0
08628 #endif
08629                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
08630 
08631                     ;}
08632     break;
08633 
08634   case 405:
08635 #line 3449 "ripper.y"
08636     {
08637                         (yyval.val) = 0;
08638                     ;}
08639     break;
08640 
08641   case 406:
08642 #line 3454 "ripper.y"
08643     {
08644                         (yyval.vars) = dyna_push();
08645                     ;}
08646     break;
08647 
08648   case 407:
08649 #line 3457 "ripper.y"
08650     {
08651                         (yyval.num) = lpar_beg;
08652                         lpar_beg = ++paren_nest;
08653                     ;}
08654     break;
08655 
08656   case 408:
08657 #line 3463 "ripper.y"
08658     {
08659                         lpar_beg = (yyvsp[(2) - (4)].num);
08660 #if 0
08661                         (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08662 #endif
08663                         (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08664 
08665                         dyna_pop((yyvsp[(1) - (4)].vars));
08666                     ;}
08667     break;
08668 
08669   case 409:
08670 #line 3475 "ripper.y"
08671     {
08672 #if 0
08673                         (yyval.val) = (yyvsp[(2) - (4)].val);
08674 #endif
08675                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
08676 
08677                     ;}
08678     break;
08679 
08680   case 410:
08681 #line 3483 "ripper.y"
08682     {
08683 #if 0
08684                         (yyval.val) = (yyvsp[(1) - (1)].val);
08685 #endif
08686                         (yyval.val) = (yyvsp[(1) - (1)].val);
08687 
08688                     ;}
08689     break;
08690 
08691   case 411:
08692 #line 3493 "ripper.y"
08693     {
08694                         (yyval.val) = (yyvsp[(2) - (3)].val);
08695                     ;}
08696     break;
08697 
08698   case 412:
08699 #line 3497 "ripper.y"
08700     {
08701                         (yyval.val) = (yyvsp[(2) - (3)].val);
08702                     ;}
08703     break;
08704 
08705   case 413:
08706 #line 3503 "ripper.y"
08707     {
08708                         (yyvsp[(1) - (1)].vars) = dyna_push();
08709 #if 0
08710                         (yyval.num) = ruby_sourceline;
08711 #endif
08712                     ;}
08713     break;
08714 
08715   case 414:
08716 #line 3512 "ripper.y"
08717     {
08718 #if 0
08719                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
08720                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
08721 #endif
08722                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
08723 
08724                         dyna_pop((yyvsp[(1) - (5)].vars));
08725                     ;}
08726     break;
08727 
08728   case 415:
08729 #line 3524 "ripper.y"
08730     {
08731 #if 0
08732                         if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
08733                             compile_error(PARSER_ARG "block given to yield");
08734                         }
08735                         else {
08736                             block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
08737                         }
08738                         (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
08739                         (yyval.val) = (yyvsp[(2) - (2)].val);
08740                         fixpos((yyval.val), (yyvsp[(1) - (2)].val));
08741 #endif
08742                         (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
08743 
08744                     ;}
08745     break;
08746 
08747   case 416:
08748 #line 3540 "ripper.y"
08749     {
08750 #if 0
08751                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
08752 #endif
08753                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
08754                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
08755 
08756                     ;}
08757     break;
08758 
08759   case 417:
08760 #line 3549 "ripper.y"
08761     {
08762 #if 0
08763                         block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08764                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
08765                         (yyval.val) = (yyvsp[(5) - (5)].val);
08766                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
08767 #endif
08768                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
08769                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
08770 
08771                     ;}
08772     break;
08773 
08774   case 418:
08775 #line 3561 "ripper.y"
08776     {
08777 #if 0
08778                         block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08779                         (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
08780                         (yyval.val) = (yyvsp[(5) - (5)].val);
08781                         fixpos((yyval.val), (yyvsp[(1) - (5)].val));
08782 #endif
08783                         (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
08784                         (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
08785 
08786                     ;}
08787     break;
08788 
08789   case 419:
08790 #line 3575 "ripper.y"
08791     {
08792 #if 0
08793                         (yyval.val) = (yyvsp[(1) - (2)].val);
08794                         (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
08795 #endif
08796                         (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
08797 
08798                     ;}
08799     break;
08800 
08801   case 420:
08802 #line 3584 "ripper.y"
08803     {
08804 #if 0
08805                         (yyval.num) = ruby_sourceline;
08806 #endif
08807                     ;}
08808     break;
08809 
08810   case 421:
08811 #line 3590 "ripper.y"
08812     {
08813 #if 0
08814                         (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
08815                         nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
08816 #endif
08817                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
08818                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
08819 
08820                     ;}
08821     break;
08822 
08823   case 422:
08824 #line 3600 "ripper.y"
08825     {
08826 #if 0
08827                         (yyval.num) = ruby_sourceline;
08828 #endif
08829                     ;}
08830     break;
08831 
08832   case 423:
08833 #line 3606 "ripper.y"
08834     {
08835 #if 0
08836                         (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
08837                         nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
08838 #endif
08839                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
08840                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
08841 
08842                     ;}
08843     break;
08844 
08845   case 424:
08846 #line 3616 "ripper.y"
08847     {
08848 #if 0
08849                         (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
08850 #endif
08851                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
08852 
08853                     ;}
08854     break;
08855 
08856   case 425:
08857 #line 3624 "ripper.y"
08858     {
08859 #if 0
08860                         (yyval.num) = ruby_sourceline;
08861 #endif
08862                     ;}
08863     break;
08864 
08865   case 426:
08866 #line 3630 "ripper.y"
08867     {
08868 #if 0
08869                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
08870                         nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
08871 #endif
08872                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
08873                                        ripper_intern("call"));
08874                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
08875 
08876                     ;}
08877     break;
08878 
08879   case 427:
08880 #line 3641 "ripper.y"
08881     {
08882 #if 0
08883                         (yyval.num) = ruby_sourceline;
08884 #endif
08885                     ;}
08886     break;
08887 
08888   case 428:
08889 #line 3647 "ripper.y"
08890     {
08891 #if 0
08892                         (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
08893                         nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
08894 #endif
08895                         (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
08896                                        ripper_intern("call"));
08897                         (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
08898 
08899                     ;}
08900     break;
08901 
08902   case 429:
08903 #line 3658 "ripper.y"
08904     {
08905 #if 0
08906                         (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
08907 #endif
08908                         (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
08909 
08910                     ;}
08911     break;
08912 
08913   case 430:
08914 #line 3666 "ripper.y"
08915     {
08916 #if 0
08917                         (yyval.val) = NEW_ZSUPER();
08918 #endif
08919                         (yyval.val) = dispatch0(zsuper);
08920 
08921                     ;}
08922     break;
08923 
08924   case 431:
08925 #line 3674 "ripper.y"
08926     {
08927 #if 0
08928                         if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
08929                             (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
08930                         else
08931                             (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
08932                         fixpos((yyval.val), (yyvsp[(1) - (4)].val));
08933 #endif
08934                         (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
08935 
08936                     ;}
08937     break;
08938 
08939   case 432:
08940 #line 3688 "ripper.y"
08941     {
08942                         (yyvsp[(1) - (1)].vars) = dyna_push();
08943 #if 0
08944                         (yyval.num) = ruby_sourceline;
08945 #endif
08946 
08947                     ;}
08948     break;
08949 
08950   case 433:
08951 #line 3697 "ripper.y"
08952     {
08953 #if 0
08954                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
08955                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
08956 #endif
08957                         (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
08958 
08959                         dyna_pop((yyvsp[(1) - (5)].vars));
08960                     ;}
08961     break;
08962 
08963   case 434:
08964 #line 3707 "ripper.y"
08965     {
08966                         (yyvsp[(1) - (1)].vars) = dyna_push();
08967 #if 0
08968                         (yyval.num) = ruby_sourceline;
08969 #endif
08970 
08971                     ;}
08972     break;
08973 
08974   case 435:
08975 #line 3716 "ripper.y"
08976     {
08977 #if 0
08978                         (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
08979                         nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
08980 #endif
08981                         (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
08982 
08983                         dyna_pop((yyvsp[(1) - (5)].vars));
08984                     ;}
08985     break;
08986 
08987   case 436:
08988 #line 3730 "ripper.y"
08989     {
08990 #if 0
08991                         (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
08992 #endif
08993                         (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
08994 
08995                     ;}
08996     break;
08997 
08998   case 439:
08999 #line 3746 "ripper.y"
09000     {
09001 #if 0
09002                         if ((yyvsp[(3) - (6)].val)) {
09003                             (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
09004                             (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
09005                         }
09006                         (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09007                         fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
09008 #endif
09009                         (yyval.val) = dispatch4(rescue,
09010                                        escape_Qundef((yyvsp[(2) - (6)].val)),
09011                                        escape_Qundef((yyvsp[(3) - (6)].val)),
09012                                        escape_Qundef((yyvsp[(5) - (6)].val)),
09013                                        escape_Qundef((yyvsp[(6) - (6)].val)));
09014 
09015                     ;}
09016     break;
09017 
09018   case 441:
09019 #line 3766 "ripper.y"
09020     {
09021 #if 0
09022                         (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
09023 #endif
09024                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
09025 
09026                     ;}
09027     break;
09028 
09029   case 442:
09030 #line 3774 "ripper.y"
09031     {
09032 #if 0
09033                         if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
09034 #endif
09035                         (yyval.val) = (yyvsp[(1) - (1)].val);
09036 
09037                     ;}
09038     break;
09039 
09040   case 444:
09041 #line 3785 "ripper.y"
09042     {
09043                         (yyval.val) = (yyvsp[(2) - (2)].val);
09044                     ;}
09045     break;
09046 
09047   case 446:
09048 #line 3792 "ripper.y"
09049     {
09050 #if 0
09051                         (yyval.val) = (yyvsp[(2) - (2)].val);
09052 #endif
09053                         (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
09054 
09055                     ;}
09056     break;
09057 
09058   case 449:
09059 #line 3804 "ripper.y"
09060     {
09061 #if 0
09062                         (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
09063 #endif
09064                         (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
09065 
09066                     ;}
09067     break;
09068 
09069   case 451:
09070 #line 3815 "ripper.y"
09071     {
09072 #if 0
09073                         NODE *node = (yyvsp[(1) - (1)].val);
09074                         if (!node) {
09075                             node = NEW_STR(STR_NEW0());
09076                         }
09077                         else {
09078                             node = evstr2dstr(node);
09079                         }
09080                         (yyval.val) = node;
09081 #endif
09082                         (yyval.val) = (yyvsp[(1) - (1)].val);
09083 
09084                     ;}
09085     break;
09086 
09087   case 454:
09088 #line 3834 "ripper.y"
09089     {
09090 #if 0
09091                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09092 #endif
09093                         (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09094 
09095                     ;}
09096     break;
09097 
09098   case 455:
09099 #line 3844 "ripper.y"
09100     {
09101 #if 0
09102                         (yyval.val) = (yyvsp[(2) - (3)].val);
09103 #endif
09104                         (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
09105 
09106                     ;}
09107     break;
09108 
09109   case 456:
09110 #line 3854 "ripper.y"
09111     {
09112 #if 0
09113                         NODE *node = (yyvsp[(2) - (3)].val);
09114                         if (!node) {
09115                             node = NEW_XSTR(STR_NEW0());
09116                         }
09117                         else {
09118                             switch (nd_type(node)) {
09119                               case NODE_STR:
09120                                 nd_set_type(node, NODE_XSTR);
09121                                 break;
09122                               case NODE_DSTR:
09123                                 nd_set_type(node, NODE_DXSTR);
09124                                 break;
09125                               default:
09126                                 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
09127                                 break;
09128                             }
09129                         }
09130                         (yyval.val) = node;
09131 #endif
09132                         (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
09133 
09134                     ;}
09135     break;
09136 
09137   case 457:
09138 #line 3881 "ripper.y"
09139     {
09140 #if 0
09141                         int options = (yyvsp[(3) - (3)].val);
09142                         NODE *node = (yyvsp[(2) - (3)].val);
09143                         NODE *list, *prev;
09144                         if (!node) {
09145                             node = NEW_LIT(reg_compile(STR_NEW0(), options));
09146                         }
09147                         else switch (nd_type(node)) {
09148                           case NODE_STR:
09149                             {
09150                                 VALUE src = node->nd_lit;
09151                                 nd_set_type(node, NODE_LIT);
09152                                 node->nd_lit = reg_compile(src, options);
09153                             }
09154                             break;
09155                           default:
09156                             node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
09157                           case NODE_DSTR:
09158                             if (options & RE_OPTION_ONCE) {
09159                                 nd_set_type(node, NODE_DREGX_ONCE);
09160                             }
09161                             else {
09162                                 nd_set_type(node, NODE_DREGX);
09163                             }
09164                             node->nd_cflag = options & RE_OPTION_MASK;
09165                             if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
09166                             for (list = (prev = node)->nd_next; list; list = list->nd_next) {
09167                                 if (nd_type(list->nd_head) == NODE_STR) {
09168                                     VALUE tail = list->nd_head->nd_lit;
09169                                     if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
09170                                         VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
09171                                         if (!literal_concat0(parser, lit, tail)) {
09172                                             node = 0;
09173                                             break;
09174                                         }
09175                                         rb_str_resize(tail, 0);
09176                                         prev->nd_next = list->nd_next;
09177                                         rb_gc_force_recycle((VALUE)list->nd_head);
09178                                         rb_gc_force_recycle((VALUE)list);
09179                                         list = prev;
09180                                     }
09181                                     else {
09182                                         prev = list;
09183                                     }
09184                                 }
09185                                 else {
09186                                     prev = 0;
09187                                 }
09188                             }
09189                             if (!node->nd_next) {
09190                                 VALUE src = node->nd_lit;
09191                                 nd_set_type(node, NODE_LIT);
09192                                 node->nd_lit = reg_compile(src, options);
09193                             }
09194                             break;
09195                         }
09196                         (yyval.val) = node;
09197 #endif
09198                         (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
09199 
09200                     ;}
09201     break;
09202 
09203   case 458:
09204 #line 3946 "ripper.y"
09205     {
09206 #if 0
09207                         (yyval.val) = NEW_ZARRAY();
09208 #endif
09209                         (yyval.val) = dispatch0(words_new);
09210                         (yyval.val) = dispatch1(array, (yyval.val));
09211 
09212                     ;}
09213     break;
09214 
09215   case 459:
09216 #line 3955 "ripper.y"
09217     {
09218 #if 0
09219                         (yyval.val) = (yyvsp[(2) - (3)].val);
09220 #endif
09221                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09222 
09223                     ;}
09224     break;
09225 
09226   case 460:
09227 #line 3965 "ripper.y"
09228     {
09229 #if 0
09230                         (yyval.val) = 0;
09231 #endif
09232                         (yyval.val) = dispatch0(words_new);
09233 
09234                     ;}
09235     break;
09236 
09237   case 461:
09238 #line 3973 "ripper.y"
09239     {
09240 #if 0
09241                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
09242 #endif
09243                         (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09244 
09245                     ;}
09246     break;
09247 
09248   case 462:
09249 #line 3985 "ripper.y"
09250     {
09251                         (yyval.val) = dispatch0(word_new);
09252                         (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
09253                     ;}
09254     break;
09255 
09256   case 463:
09257 #line 3991 "ripper.y"
09258     {
09259 #if 0
09260                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09261 #endif
09262                         (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09263 
09264                     ;}
09265     break;
09266 
09267   case 464:
09268 #line 4001 "ripper.y"
09269     {
09270 #if 0
09271                         (yyval.val) = NEW_ZARRAY();
09272 #endif
09273                         (yyval.val) = dispatch0(symbols_new);
09274                         (yyval.val) = dispatch1(array, (yyval.val));
09275 
09276                     ;}
09277     break;
09278 
09279   case 465:
09280 #line 4010 "ripper.y"
09281     {
09282 #if 0
09283                         (yyval.val) = (yyvsp[(2) - (3)].val);
09284 #endif
09285                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09286 
09287                     ;}
09288     break;
09289 
09290   case 466:
09291 #line 4020 "ripper.y"
09292     {
09293 #if 0
09294                         (yyval.val) = 0;
09295 #endif
09296                         (yyval.val) = dispatch0(symbols_new);
09297 
09298                     ;}
09299     break;
09300 
09301   case 467:
09302 #line 4028 "ripper.y"
09303     {
09304 #if 0
09305                         (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
09306                         nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
09307                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09308 #endif
09309                         (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09310 
09311                     ;}
09312     break;
09313 
09314   case 468:
09315 #line 4040 "ripper.y"
09316     {
09317 #if 0
09318                         (yyval.val) = NEW_ZARRAY();
09319 #endif
09320                         (yyval.val) = dispatch0(qwords_new);
09321                         (yyval.val) = dispatch1(array, (yyval.val));
09322 
09323                     ;}
09324     break;
09325 
09326   case 469:
09327 #line 4049 "ripper.y"
09328     {
09329 #if 0
09330                         (yyval.val) = (yyvsp[(2) - (3)].val);
09331 #endif
09332                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09333 
09334                     ;}
09335     break;
09336 
09337   case 470:
09338 #line 4059 "ripper.y"
09339     {
09340 #if 0
09341                         (yyval.val) = NEW_ZARRAY();
09342 #endif
09343                         (yyval.val) = dispatch0(qsymbols_new);
09344                         (yyval.val) = dispatch1(array, (yyval.val));
09345 
09346                     ;}
09347     break;
09348 
09349   case 471:
09350 #line 4068 "ripper.y"
09351     {
09352 #if 0
09353                         (yyval.val) = (yyvsp[(2) - (3)].val);
09354 #endif
09355                         (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
09356 
09357                     ;}
09358     break;
09359 
09360   case 472:
09361 #line 4078 "ripper.y"
09362     {
09363 #if 0
09364                         (yyval.val) = 0;
09365 #endif
09366                         (yyval.val) = dispatch0(qwords_new);
09367 
09368                     ;}
09369     break;
09370 
09371   case 473:
09372 #line 4086 "ripper.y"
09373     {
09374 #if 0
09375                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09376 #endif
09377                         (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09378 
09379                     ;}
09380     break;
09381 
09382   case 474:
09383 #line 4096 "ripper.y"
09384     {
09385 #if 0
09386                         (yyval.val) = 0;
09387 #endif
09388                         (yyval.val) = dispatch0(qsymbols_new);
09389 
09390                     ;}
09391     break;
09392 
09393   case 475:
09394 #line 4104 "ripper.y"
09395     {
09396 #if 0
09397                         VALUE lit;
09398                         lit = (yyvsp[(2) - (3)].val)->nd_lit;
09399                         (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
09400                         nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
09401                         (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09402 #endif
09403                         (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
09404 
09405                     ;}
09406     break;
09407 
09408   case 476:
09409 #line 4118 "ripper.y"
09410     {
09411 #if 0
09412                         (yyval.val) = 0;
09413 #endif
09414                         (yyval.val) = dispatch0(string_content);
09415 
09416                     ;}
09417     break;
09418 
09419   case 477:
09420 #line 4126 "ripper.y"
09421     {
09422 #if 0
09423                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09424 #endif
09425                         (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09426 
09427                     ;}
09428     break;
09429 
09430   case 478:
09431 #line 4136 "ripper.y"
09432     {
09433 #if 0
09434                         (yyval.val) = 0;
09435 #endif
09436                         (yyval.val) = dispatch0(xstring_new);
09437 
09438                     ;}
09439     break;
09440 
09441   case 479:
09442 #line 4144 "ripper.y"
09443     {
09444 #if 0
09445                         (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09446 #endif
09447                         (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09448 
09449                     ;}
09450     break;
09451 
09452   case 480:
09453 #line 4154 "ripper.y"
09454     {
09455 #if 0
09456                         (yyval.val) = 0;
09457 #endif
09458                         (yyval.val) = dispatch0(regexp_new);
09459 
09460                     ;}
09461     break;
09462 
09463   case 481:
09464 #line 4162 "ripper.y"
09465     {
09466 #if 0
09467                         NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
09468                         if (!head) {
09469                             (yyval.val) = tail;
09470                         }
09471                         else if (!tail) {
09472                             (yyval.val) = head;
09473                         }
09474                         else {
09475                             switch (nd_type(head)) {
09476                               case NODE_STR:
09477                                 nd_set_type(head, NODE_DSTR);
09478                                 break;
09479                               case NODE_DSTR:
09480                                 break;
09481                               default:
09482                                 head = list_append(NEW_DSTR(Qnil), head);
09483                                 break;
09484                             }
09485                             (yyval.val) = list_append(head, tail);
09486                         }
09487 #endif
09488                         (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09489 
09490                     ;}
09491     break;
09492 
09493   case 483:
09494 #line 4192 "ripper.y"
09495     {
09496                         (yyval.node) = lex_strterm;
09497                         lex_strterm = 0;
09498                         lex_state = EXPR_BEG;
09499                     ;}
09500     break;
09501 
09502   case 484:
09503 #line 4198 "ripper.y"
09504     {
09505 #if 0
09506                         lex_strterm = (yyvsp[(2) - (3)].node);
09507                         (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
09508 #endif
09509                         lex_strterm = (yyvsp[(2) - (3)].node);
09510                         (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
09511 
09512                     ;}
09513     break;
09514 
09515   case 485:
09516 #line 4208 "ripper.y"
09517     {
09518                         (yyvsp[(1) - (1)].val) = cond_stack;
09519                         (yyval.val) = cmdarg_stack;
09520                         cond_stack = 0;
09521                         cmdarg_stack = 0;
09522                     ;}
09523     break;
09524 
09525   case 486:
09526 #line 4214 "ripper.y"
09527     {
09528                         (yyval.node) = lex_strterm;
09529                         lex_strterm = 0;
09530                         lex_state = EXPR_BEG;
09531                     ;}
09532     break;
09533 
09534   case 487:
09535 #line 4219 "ripper.y"
09536     {
09537                         (yyval.num) = brace_nest;
09538                         brace_nest = 0;
09539                     ;}
09540     break;
09541 
09542   case 488:
09543 #line 4224 "ripper.y"
09544     {
09545                         cond_stack = (yyvsp[(1) - (6)].val);
09546                         cmdarg_stack = (yyvsp[(2) - (6)].val);
09547                         lex_strterm = (yyvsp[(3) - (6)].node);
09548                         brace_nest = (yyvsp[(4) - (6)].num);
09549 #if 0
09550                         if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
09551                         (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
09552 #endif
09553                         (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
09554 
09555                     ;}
09556     break;
09557 
09558   case 489:
09559 #line 4239 "ripper.y"
09560     {
09561 #if 0
09562                         (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
09563 #endif
09564                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09565 
09566                     ;}
09567     break;
09568 
09569   case 490:
09570 #line 4247 "ripper.y"
09571     {
09572 #if 0
09573                         (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
09574 #endif
09575                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09576 
09577                     ;}
09578     break;
09579 
09580   case 491:
09581 #line 4255 "ripper.y"
09582     {
09583 #if 0
09584                         (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
09585 #endif
09586                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09587 
09588                     ;}
09589     break;
09590 
09591   case 493:
09592 #line 4266 "ripper.y"
09593     {
09594                         lex_state = EXPR_END;
09595 #if 0
09596                         (yyval.val) = (yyvsp[(2) - (2)].val);
09597 #endif
09598                         (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
09599 
09600                     ;}
09601     break;
09602 
09603   case 498:
09604 #line 4283 "ripper.y"
09605     {
09606                         lex_state = EXPR_END;
09607 #if 0
09608                         (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
09609 #endif
09610                         (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
09611 
09612                     ;}
09613     break;
09614 
09615   case 501:
09616 #line 4296 "ripper.y"
09617     {
09618 #if 0
09619                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09620 #endif
09621                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09622 
09623                     ;}
09624     break;
09625 
09626   case 502:
09627 #line 4304 "ripper.y"
09628     {
09629 #if 0
09630                         (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
09631 #endif
09632                         (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
09633 
09634                     ;}
09635     break;
09636 
09637   case 508:
09638 #line 4320 "ripper.y"
09639     {ifndef_ripper((yyval.val) = keyword_nil);;}
09640     break;
09641 
09642   case 509:
09643 #line 4321 "ripper.y"
09644     {ifndef_ripper((yyval.val) = keyword_self);;}
09645     break;
09646 
09647   case 510:
09648 #line 4322 "ripper.y"
09649     {ifndef_ripper((yyval.val) = keyword_true);;}
09650     break;
09651 
09652   case 511:
09653 #line 4323 "ripper.y"
09654     {ifndef_ripper((yyval.val) = keyword_false);;}
09655     break;
09656 
09657   case 512:
09658 #line 4324 "ripper.y"
09659     {ifndef_ripper((yyval.val) = keyword__FILE__);;}
09660     break;
09661 
09662   case 513:
09663 #line 4325 "ripper.y"
09664     {ifndef_ripper((yyval.val) = keyword__LINE__);;}
09665     break;
09666 
09667   case 514:
09668 #line 4326 "ripper.y"
09669     {ifndef_ripper((yyval.val) = keyword__ENCODING__);;}
09670     break;
09671 
09672   case 515:
09673 #line 4330 "ripper.y"
09674     {
09675 #if 0
09676                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
09677 #endif
09678                         if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
09679                             (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09680                         }
09681                         else {
09682                             (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
09683                         }
09684 
09685                     ;}
09686     break;
09687 
09688   case 516:
09689 #line 4343 "ripper.y"
09690     {
09691 #if 0
09692                         if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
09693 #endif
09694                         (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
09695 
09696                     ;}
09697     break;
09698 
09699   case 517:
09700 #line 4353 "ripper.y"
09701     {
09702                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
09703 #if 0
09704 #endif
09705                         (yyval.val) = dispatch1(var_field, (yyval.val));
09706 
09707                     ;}
09708     break;
09709 
09710   case 518:
09711 #line 4361 "ripper.y"
09712     {
09713                         (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
09714 #if 0
09715 #endif
09716                         (yyval.val) = dispatch1(var_field, (yyval.val));
09717 
09718                     ;}
09719     break;
09720 
09721   case 521:
09722 #line 4375 "ripper.y"
09723     {
09724 #if 0
09725                         (yyval.val) = 0;
09726 #endif
09727                         (yyval.val) = Qnil;
09728 
09729                     ;}
09730     break;
09731 
09732   case 522:
09733 #line 4383 "ripper.y"
09734     {
09735                         lex_state = EXPR_BEG;
09736                         command_start = TRUE;
09737                     ;}
09738     break;
09739 
09740   case 523:
09741 #line 4388 "ripper.y"
09742     {
09743                         (yyval.val) = (yyvsp[(3) - (4)].val);
09744                     ;}
09745     break;
09746 
09747   case 524:
09748 #line 4392 "ripper.y"
09749     {
09750 #if 0
09751                         yyerrok;
09752                         (yyval.val) = 0;
09753 #endif
09754                         yyerrok;
09755                         (yyval.val) = Qnil;
09756 
09757                     ;}
09758     break;
09759 
09760   case 525:
09761 #line 4404 "ripper.y"
09762     {
09763 #if 0
09764                         (yyval.val) = (yyvsp[(2) - (3)].val);
09765 #endif
09766                         (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
09767 
09768                         lex_state = EXPR_BEG;
09769                         command_start = TRUE;
09770                     ;}
09771     break;
09772 
09773   case 526:
09774 #line 4414 "ripper.y"
09775     {
09776                         (yyval.val) = (yyvsp[(1) - (2)].val);
09777                         lex_state = EXPR_BEG;
09778                         command_start = TRUE;
09779                     ;}
09780     break;
09781 
09782   case 527:
09783 #line 4422 "ripper.y"
09784     {
09785                         (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09786                     ;}
09787     break;
09788 
09789   case 528:
09790 #line 4426 "ripper.y"
09791     {
09792                         (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
09793                     ;}
09794     break;
09795 
09796   case 529:
09797 #line 4430 "ripper.y"
09798     {
09799                         (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
09800                     ;}
09801     break;
09802 
09803   case 530:
09804 #line 4434 "ripper.y"
09805     {
09806                         (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
09807                     ;}
09808     break;
09809 
09810   case 531:
09811 #line 4440 "ripper.y"
09812     {
09813                         (yyval.val) = (yyvsp[(2) - (2)].val);
09814                     ;}
09815     break;
09816 
09817   case 532:
09818 #line 4444 "ripper.y"
09819     {
09820                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
09821                     ;}
09822     break;
09823 
09824   case 533:
09825 #line 4450 "ripper.y"
09826     {
09827                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
09828                     ;}
09829     break;
09830 
09831   case 534:
09832 #line 4454 "ripper.y"
09833     {
09834                         (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
09835                     ;}
09836     break;
09837 
09838   case 535:
09839 #line 4458 "ripper.y"
09840     {
09841                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
09842                     ;}
09843     break;
09844 
09845   case 536:
09846 #line 4462 "ripper.y"
09847     {
09848                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09849                     ;}
09850     break;
09851 
09852   case 537:
09853 #line 4466 "ripper.y"
09854     {
09855                         (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
09856                     ;}
09857     break;
09858 
09859   case 538:
09860 #line 4470 "ripper.y"
09861     {
09862                         (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09863                     ;}
09864     break;
09865 
09866   case 539:
09867 #line 4474 "ripper.y"
09868     {
09869                         (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
09870                     ;}
09871     break;
09872 
09873   case 540:
09874 #line 4478 "ripper.y"
09875     {
09876                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
09877                     ;}
09878     break;
09879 
09880   case 541:
09881 #line 4482 "ripper.y"
09882     {
09883                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
09884                     ;}
09885     break;
09886 
09887   case 542:
09888 #line 4486 "ripper.y"
09889     {
09890                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
09891                     ;}
09892     break;
09893 
09894   case 543:
09895 #line 4490 "ripper.y"
09896     {
09897                         (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09898                     ;}
09899     break;
09900 
09901   case 544:
09902 #line 4494 "ripper.y"
09903     {
09904                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
09905                     ;}
09906     break;
09907 
09908   case 545:
09909 #line 4498 "ripper.y"
09910     {
09911                         (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
09912                     ;}
09913     break;
09914 
09915   case 546:
09916 #line 4502 "ripper.y"
09917     {
09918                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
09919                     ;}
09920     break;
09921 
09922   case 547:
09923 #line 4506 "ripper.y"
09924     {
09925                         (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
09926                         (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
09927                     ;}
09928     break;
09929 
09930   case 548:
09931 #line 4513 "ripper.y"
09932     {
09933 #if 0
09934                         yyerror("formal argument cannot be a constant");
09935                         (yyval.val) = 0;
09936 #endif
09937                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
09938 
09939                     ;}
09940     break;
09941 
09942   case 549:
09943 #line 4522 "ripper.y"
09944     {
09945 #if 0
09946                         yyerror("formal argument cannot be an instance variable");
09947                         (yyval.val) = 0;
09948 #endif
09949                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
09950 
09951                     ;}
09952     break;
09953 
09954   case 550:
09955 #line 4531 "ripper.y"
09956     {
09957 #if 0
09958                         yyerror("formal argument cannot be a global variable");
09959                         (yyval.val) = 0;
09960 #endif
09961                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
09962 
09963                     ;}
09964     break;
09965 
09966   case 551:
09967 #line 4540 "ripper.y"
09968     {
09969 #if 0
09970                         yyerror("formal argument cannot be a class variable");
09971                         (yyval.val) = 0;
09972 #endif
09973                         (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
09974 
09975                     ;}
09976     break;
09977 
09978   case 553:
09979 #line 4552 "ripper.y"
09980     {
09981                         formal_argument(get_id((yyvsp[(1) - (1)].val)));
09982                         (yyval.val) = (yyvsp[(1) - (1)].val);
09983                     ;}
09984     break;
09985 
09986   case 554:
09987 #line 4559 "ripper.y"
09988     {
09989                         arg_var(get_id((yyvsp[(1) - (1)].val)));
09990 #if 0
09991                         (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
09992 #endif
09993                         (yyval.val) = get_value((yyvsp[(1) - (1)].val));
09994 
09995                     ;}
09996     break;
09997 
09998   case 555:
09999 #line 4568 "ripper.y"
10000     {
10001                         ID tid = internal_id();
10002                         arg_var(tid);
10003 #if 0
10004                         if (dyna_in_block()) {
10005                             (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10006                         }
10007                         else {
10008                             (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10009                         }
10010                         (yyval.val) = NEW_ARGS_AUX(tid, 1);
10011                         (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10012 #endif
10013                         (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10014 
10015                     ;}
10016     break;
10017 
10018   case 556:
10019 #line 4589 "ripper.y"
10020     {
10021                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10022                     ;}
10023     break;
10024 
10025   case 557:
10026 #line 4594 "ripper.y"
10027     {
10028 #if 0
10029                         (yyval.val) = (yyvsp[(1) - (3)].val);
10030                         (yyval.val)->nd_plen++;
10031                         (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10032                         rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10033 #endif
10034                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10035 
10036                     ;}
10037     break;
10038 
10039   case 558:
10040 #line 4607 "ripper.y"
10041     {
10042                         arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10043                         (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10044 #if 0
10045                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10046 #endif
10047                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10048 
10049                     ;}
10050     break;
10051 
10052   case 559:
10053 #line 4619 "ripper.y"
10054     {
10055                         arg_var(formal_argument(get_id((yyvsp[(1) - (2)].val))));
10056                         (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10057 #if 0
10058                         (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10059 #endif
10060                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10061 
10062                     ;}
10063     break;
10064 
10065   case 560:
10066 #line 4631 "ripper.y"
10067     {
10068 #if 0
10069                         (yyval.val) = (yyvsp[(1) - (1)].val);
10070 #endif
10071                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10072 
10073                     ;}
10074     break;
10075 
10076   case 561:
10077 #line 4639 "ripper.y"
10078     {
10079 #if 0
10080                         NODE *kws = (yyvsp[(1) - (3)].val);
10081 
10082                         while (kws->nd_next) {
10083                             kws = kws->nd_next;
10084                         }
10085                         kws->nd_next = (yyvsp[(3) - (3)].val);
10086                         (yyval.val) = (yyvsp[(1) - (3)].val);
10087 #endif
10088                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10089 
10090                     ;}
10091     break;
10092 
10093   case 562:
10094 #line 4656 "ripper.y"
10095     {
10096 #if 0
10097                         (yyval.val) = (yyvsp[(1) - (1)].val);
10098 #endif
10099                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10100 
10101                     ;}
10102     break;
10103 
10104   case 563:
10105 #line 4664 "ripper.y"
10106     {
10107 #if 0
10108                         NODE *kws = (yyvsp[(1) - (3)].val);
10109 
10110                         while (kws->nd_next) {
10111                             kws = kws->nd_next;
10112                         }
10113                         kws->nd_next = (yyvsp[(3) - (3)].val);
10114                         (yyval.val) = (yyvsp[(1) - (3)].val);
10115 #endif
10116                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10117 
10118                     ;}
10119     break;
10120 
10121   case 566:
10122 #line 4684 "ripper.y"
10123     {
10124                         shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
10125                         (yyval.val) = (yyvsp[(2) - (2)].val);
10126                     ;}
10127     break;
10128 
10129   case 567:
10130 #line 4689 "ripper.y"
10131     {
10132                         (yyval.val) = internal_id();
10133                     ;}
10134     break;
10135 
10136   case 568:
10137 #line 4695 "ripper.y"
10138     {
10139                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10140                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10141 #if 0
10142                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10143 #endif
10144                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10145 
10146                     ;}
10147     break;
10148 
10149   case 569:
10150 #line 4707 "ripper.y"
10151     {
10152                         arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10153                         (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10154 #if 0
10155                         (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10156 #endif
10157                         (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
10158 
10159                     ;}
10160     break;
10161 
10162   case 570:
10163 #line 4719 "ripper.y"
10164     {
10165 #if 0
10166                         (yyval.val) = (yyvsp[(1) - (1)].val);
10167 #endif
10168                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10169 
10170                     ;}
10171     break;
10172 
10173   case 571:
10174 #line 4727 "ripper.y"
10175     {
10176 #if 0
10177                         NODE *opts = (yyvsp[(1) - (3)].val);
10178 
10179                         while (opts->nd_next) {
10180                             opts = opts->nd_next;
10181                         }
10182                         opts->nd_next = (yyvsp[(3) - (3)].val);
10183                         (yyval.val) = (yyvsp[(1) - (3)].val);
10184 #endif
10185                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10186 
10187                     ;}
10188     break;
10189 
10190   case 572:
10191 #line 4743 "ripper.y"
10192     {
10193 #if 0
10194                         (yyval.val) = (yyvsp[(1) - (1)].val);
10195 #endif
10196                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10197 
10198                     ;}
10199     break;
10200 
10201   case 573:
10202 #line 4751 "ripper.y"
10203     {
10204 #if 0
10205                         NODE *opts = (yyvsp[(1) - (3)].val);
10206 
10207                         while (opts->nd_next) {
10208                             opts = opts->nd_next;
10209                         }
10210                         opts->nd_next = (yyvsp[(3) - (3)].val);
10211                         (yyval.val) = (yyvsp[(1) - (3)].val);
10212 #endif
10213                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10214 
10215                     ;}
10216     break;
10217 
10218   case 576:
10219 #line 4771 "ripper.y"
10220     {
10221 #if 0
10222                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10223                             yyerror("rest argument must be local variable");
10224 #endif
10225                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10226 #if 0
10227                         (yyval.val) = (yyvsp[(2) - (2)].val);
10228 #endif
10229                         (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
10230 
10231                     ;}
10232     break;
10233 
10234   case 577:
10235 #line 4784 "ripper.y"
10236     {
10237 #if 0
10238                         (yyval.val) = internal_id();
10239                         arg_var((yyval.val));
10240 #endif
10241                         (yyval.val) = dispatch1(rest_param, Qnil);
10242 
10243                     ;}
10244     break;
10245 
10246   case 580:
10247 #line 4799 "ripper.y"
10248     {
10249 #if 0
10250                         if (!is_local_id((yyvsp[(2) - (2)].val)))
10251                             yyerror("block argument must be local variable");
10252                         else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
10253                             yyerror("duplicated block argument name");
10254 #endif
10255                         arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10256 #if 0
10257                         (yyval.val) = (yyvsp[(2) - (2)].val);
10258 #endif
10259                         (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
10260 
10261                     ;}
10262     break;
10263 
10264   case 581:
10265 #line 4816 "ripper.y"
10266     {
10267                         (yyval.val) = (yyvsp[(2) - (2)].val);
10268                     ;}
10269     break;
10270 
10271   case 582:
10272 #line 4820 "ripper.y"
10273     {
10274 #if 0
10275                         (yyval.val) = 0;
10276 #endif
10277                         (yyval.val) = Qundef;
10278 
10279                     ;}
10280     break;
10281 
10282   case 583:
10283 #line 4830 "ripper.y"
10284     {
10285 #if 0
10286                         value_expr((yyvsp[(1) - (1)].val));
10287                         (yyval.val) = (yyvsp[(1) - (1)].val);
10288                         if (!(yyval.val)) (yyval.val) = NEW_NIL();
10289 #endif
10290                         (yyval.val) = (yyvsp[(1) - (1)].val);
10291 
10292                     ;}
10293     break;
10294 
10295   case 584:
10296 #line 4839 "ripper.y"
10297     {lex_state = EXPR_BEG;;}
10298     break;
10299 
10300   case 585:
10301 #line 4840 "ripper.y"
10302     {
10303 #if 0
10304                         if ((yyvsp[(3) - (4)].val) == 0) {
10305                             yyerror("can't define singleton method for ().");
10306                         }
10307                         else {
10308                             switch (nd_type((yyvsp[(3) - (4)].val))) {
10309                               case NODE_STR:
10310                               case NODE_DSTR:
10311                               case NODE_XSTR:
10312                               case NODE_DXSTR:
10313                               case NODE_DREGX:
10314                               case NODE_LIT:
10315                               case NODE_ARRAY:
10316                               case NODE_ZARRAY:
10317                                 yyerror("can't define singleton method for literals");
10318                               default:
10319                                 value_expr((yyvsp[(3) - (4)].val));
10320                                 break;
10321                             }
10322                         }
10323                         (yyval.val) = (yyvsp[(3) - (4)].val);
10324 #endif
10325                         (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
10326 
10327                     ;}
10328     break;
10329 
10330   case 587:
10331 #line 4870 "ripper.y"
10332     {
10333 #if 0
10334                         (yyval.val) = (yyvsp[(1) - (2)].val);
10335 #endif
10336                         (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
10337 
10338                     ;}
10339     break;
10340 
10341   case 588:
10342 #line 4882 "ripper.y"
10343     {
10344                         (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10345                     ;}
10346     break;
10347 
10348   case 589:
10349 #line 4887 "ripper.y"
10350     {
10351 #if 0
10352                         (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10353 #endif
10354                         (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10355 
10356                     ;}
10357     break;
10358 
10359   case 590:
10360 #line 4897 "ripper.y"
10361     {
10362 #if 0
10363                         (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
10364 #endif
10365                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10366 
10367                     ;}
10368     break;
10369 
10370   case 591:
10371 #line 4905 "ripper.y"
10372     {
10373 #if 0
10374                         (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
10375 #endif
10376                         (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10377 
10378                     ;}
10379     break;
10380 
10381   case 592:
10382 #line 4913 "ripper.y"
10383     {
10384 #if 0
10385                         (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
10386 #endif
10387                         (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
10388 
10389                     ;}
10390     break;
10391 
10392   case 603:
10393 #line 4943 "ripper.y"
10394     { (yyval.val) = (yyvsp[(1) - (1)].val); ;}
10395     break;
10396 
10397   case 604:
10398 #line 4948 "ripper.y"
10399     { (yyval.val) = (yyvsp[(1) - (1)].val); ;}
10400     break;
10401 
10402   case 614:
10403 #line 4971 "ripper.y"
10404     {yyerrok;;}
10405     break;
10406 
10407   case 617:
10408 #line 4976 "ripper.y"
10409     {yyerrok;;}
10410     break;
10411 
10412   case 618:
10413 #line 4980 "ripper.y"
10414     {
10415 #if 0
10416                         (yyval.val) = 0;
10417 #endif
10418                         (yyval.val) = Qundef;
10419 
10420                     ;}
10421     break;
10422 
10423 
10424 /* Line 1267 of yacc.c.  */
10425 #line 10424 "parse.c"
10426       default: break;
10427     }
10428   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10429 
10430   YYPOPSTACK (yylen);
10431   yylen = 0;
10432   YY_STACK_PRINT (yyss, yyssp);
10433 
10434   *++yyvsp = yyval;
10435 
10436 
10437   /* Now `shift' the result of the reduction.  Determine what state
10438      that goes to, based on the state we popped back to and the rule
10439      number reduced by.  */
10440 
10441   yyn = yyr1[yyn];
10442 
10443   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10444   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10445     yystate = yytable[yystate];
10446   else
10447     yystate = yydefgoto[yyn - YYNTOKENS];
10448 
10449   goto yynewstate;
10450 
10451 
10452 /*------------------------------------.
10453 | yyerrlab -- here on detecting error |
10454 `------------------------------------*/
10455 yyerrlab:
10456   /* If not already recovering from an error, report this error.  */
10457   if (!yyerrstatus)
10458     {
10459       ++yynerrs;
10460 #if ! YYERROR_VERBOSE
10461       parser_yyerror (parser, YY_("syntax error"));
10462 #else
10463       {
10464         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
10465         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
10466           {
10467             YYSIZE_T yyalloc = 2 * yysize;
10468             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
10469               yyalloc = YYSTACK_ALLOC_MAXIMUM;
10470             if (yymsg != yymsgbuf)
10471               YYSTACK_FREE (yymsg);
10472             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
10473             if (yymsg)
10474               yymsg_alloc = yyalloc;
10475             else
10476               {
10477                 yymsg = yymsgbuf;
10478                 yymsg_alloc = sizeof yymsgbuf;
10479               }
10480           }
10481 
10482         if (0 < yysize && yysize <= yymsg_alloc)
10483           {
10484             (void) yysyntax_error (yymsg, yystate, yychar);
10485             parser_yyerror (parser, yymsg);
10486           }
10487         else
10488           {
10489             parser_yyerror (parser, YY_("syntax error"));
10490             if (yysize != 0)
10491               goto yyexhaustedlab;
10492           }
10493       }
10494 #endif
10495     }
10496 
10497 
10498 
10499   if (yyerrstatus == 3)
10500     {
10501       /* If just tried and failed to reuse look-ahead token after an
10502          error, discard it.  */
10503 
10504       if (yychar <= YYEOF)
10505         {
10506           /* Return failure if at end of input.  */
10507           if (yychar == YYEOF)
10508             YYABORT;
10509         }
10510       else
10511         {
10512           yydestruct ("Error: discarding",
10513                       yytoken, &yylval, parser);
10514           yychar = YYEMPTY;
10515         }
10516     }
10517 
10518   /* Else will try to reuse look-ahead token after shifting the error
10519      token.  */
10520   goto yyerrlab1;
10521 
10522 
10523 /*---------------------------------------------------.
10524 | yyerrorlab -- error raised explicitly by YYERROR.  |
10525 `---------------------------------------------------*/
10526 yyerrorlab:
10527 
10528   /* Pacify compilers like GCC when the user code never invokes
10529      YYERROR and the label yyerrorlab therefore never appears in user
10530      code.  */
10531   if (/*CONSTCOND*/ 0)
10532      goto yyerrorlab;
10533 
10534   /* Do not reclaim the symbols of the rule which action triggered
10535      this YYERROR.  */
10536   YYPOPSTACK (yylen);
10537   yylen = 0;
10538   YY_STACK_PRINT (yyss, yyssp);
10539   yystate = *yyssp;
10540   goto yyerrlab1;
10541 
10542 
10543 /*-------------------------------------------------------------.
10544 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
10545 `-------------------------------------------------------------*/
10546 yyerrlab1:
10547   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
10548 
10549   for (;;)
10550     {
10551       yyn = yypact[yystate];
10552       if (yyn != YYPACT_NINF)
10553         {
10554           yyn += YYTERROR;
10555           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10556             {
10557               yyn = yytable[yyn];
10558               if (0 < yyn)
10559                 break;
10560             }
10561         }
10562 
10563       /* Pop the current state because it cannot handle the error token.  */
10564       if (yyssp == yyss)
10565         YYABORT;
10566 
10567 
10568       yydestruct ("Error: popping",
10569                   yystos[yystate], yyvsp, parser);
10570       YYPOPSTACK (1);
10571       yystate = *yyssp;
10572       YY_STACK_PRINT (yyss, yyssp);
10573     }
10574 
10575   if (yyn == YYFINAL)
10576     YYACCEPT;
10577 
10578   *++yyvsp = yylval;
10579 
10580 
10581   /* Shift the error token.  */
10582   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
10583 
10584   yystate = yyn;
10585   goto yynewstate;
10586 
10587 
10588 /*-------------------------------------.
10589 | yyacceptlab -- YYACCEPT comes here.  |
10590 `-------------------------------------*/
10591 yyacceptlab:
10592   yyresult = 0;
10593   goto yyreturn;
10594 
10595 /*-----------------------------------.
10596 | yyabortlab -- YYABORT comes here.  |
10597 `-----------------------------------*/
10598 yyabortlab:
10599   yyresult = 1;
10600   goto yyreturn;
10601 
10602 #ifndef yyoverflow
10603 /*-------------------------------------------------.
10604 | yyexhaustedlab -- memory exhaustion comes here.  |
10605 `-------------------------------------------------*/
10606 yyexhaustedlab:
10607   parser_yyerror (parser, YY_("memory exhausted"));
10608   yyresult = 2;
10609   /* Fall through.  */
10610 #endif
10611 
10612 yyreturn:
10613   if (yychar != YYEOF && yychar != YYEMPTY)
10614      yydestruct ("Cleanup: discarding lookahead",
10615                  yytoken, &yylval, parser);
10616   /* Do not reclaim the symbols of the rule which action triggered
10617      this YYABORT or YYACCEPT.  */
10618   YYPOPSTACK (yylen);
10619   YY_STACK_PRINT (yyss, yyssp);
10620   while (yyssp != yyss)
10621     {
10622       yydestruct ("Cleanup: popping",
10623                   yystos[*yyssp], yyvsp, parser);
10624       YYPOPSTACK (1);
10625     }
10626 #ifndef yyoverflow
10627   if (yyss != yyssa)
10628     YYSTACK_FREE (yyss);
10629 #endif
10630 #if YYERROR_VERBOSE
10631   if (yymsg != yymsgbuf)
10632     YYSTACK_FREE (yymsg);
10633 #endif
10634   /* Make sure YYID is used.  */
10635   return YYID (yyresult);
10636 }
10637 
10638 
10639 #line 4988 "ripper.y"
10640 
10641 # undef parser
10642 # undef yylex
10643 # undef yylval
10644 # define yylval  (*((YYSTYPE*)(parser->parser_yylval)))
10645 
10646 static int parser_regx_options(struct parser_params*);
10647 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
10648 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
10649 static int parser_parse_string(struct parser_params*,NODE*);
10650 static int parser_here_document(struct parser_params*,NODE*);
10651 
10652 
10653 # define nextc()                   parser_nextc(parser)
10654 # define pushback(c)               parser_pushback(parser, (c))
10655 # define newtok()                  parser_newtok(parser)
10656 # define tokspace(n)               parser_tokspace(parser, (n))
10657 # define tokadd(c)                 parser_tokadd(parser, (c))
10658 # define tok_hex(numlen)           parser_tok_hex(parser, (numlen))
10659 # define read_escape(flags,e)      parser_read_escape(parser, (flags), (e))
10660 # define tokadd_escape(e)          parser_tokadd_escape(parser, (e))
10661 # define regx_options()            parser_regx_options(parser)
10662 # define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser,(f),(t),(p),(n),(e))
10663 # define parse_string(n)           parser_parse_string(parser,(n))
10664 # define tokaddmbc(c, enc)         parser_tokaddmbc(parser, (c), (enc))
10665 # define here_document(n)          parser_here_document(parser,(n))
10666 # define heredoc_identifier()      parser_heredoc_identifier(parser)
10667 # define heredoc_restore(n)        parser_heredoc_restore(parser,(n))
10668 # define whole_match_p(e,l,i)      parser_whole_match_p(parser,(e),(l),(i))
10669 
10670 #ifndef RIPPER
10671 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
10672 # define set_yylval_num(x) (yylval.num = (x))
10673 # define set_yylval_id(x)  (yylval.id = (x))
10674 # define set_yylval_name(x)  (yylval.id = (x))
10675 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
10676 # define set_yylval_node(x) (yylval.node = (x))
10677 # define yylval_id() (yylval.id)
10678 #else
10679 static inline VALUE
10680 ripper_yylval_id(ID x)
10681 {
10682     return (VALUE)NEW_LASGN(x, ID2SYM(x));
10683 }
10684 # define set_yylval_str(x) (void)(x)
10685 # define set_yylval_num(x) (void)(x)
10686 # define set_yylval_id(x)  (void)(x)
10687 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
10688 # define set_yylval_literal(x) (void)(x)
10689 # define set_yylval_node(x) (void)(x)
10690 # define yylval_id() yylval.id
10691 #endif
10692 
10693 #ifndef RIPPER
10694 #define ripper_flush(p) (void)(p)
10695 #else
10696 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
10697 
10698 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
10699 
10700 static int
10701 ripper_has_scan_event(struct parser_params *parser)
10702 {
10703 
10704     if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
10705     return lex_p > parser->tokp;
10706 }
10707 
10708 static VALUE
10709 ripper_scan_event_val(struct parser_params *parser, int t)
10710 {
10711     VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
10712     VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
10713     ripper_flush(parser);
10714     return rval;
10715 }
10716 
10717 static void
10718 ripper_dispatch_scan_event(struct parser_params *parser, int t)
10719 {
10720     if (!ripper_has_scan_event(parser)) return;
10721     yylval_rval = ripper_scan_event_val(parser, t);
10722 }
10723 
10724 static void
10725 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
10726 {
10727     if (!ripper_has_scan_event(parser)) return;
10728     (void)ripper_scan_event_val(parser, t);
10729 }
10730 
10731 static void
10732 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
10733 {
10734     int saved_line = ruby_sourceline;
10735     const char *saved_tokp = parser->tokp;
10736 
10737     ruby_sourceline = parser->delayed_line;
10738     parser->tokp = lex_pbeg + parser->delayed_col;
10739     yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
10740     parser->delayed = Qnil;
10741     ruby_sourceline = saved_line;
10742     parser->tokp = saved_tokp;
10743 }
10744 #endif /* RIPPER */
10745 
10746 #include "ruby/regex.h"
10747 #include "ruby/util.h"
10748 
10749 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
10750    since ours (we hope) works properly with all combinations of
10751    machines, compilers, `char' and `unsigned char' argument types.
10752    (Per Bothner suggested the basic approach.)  */
10753 #undef SIGN_EXTEND_CHAR
10754 #if __STDC__
10755 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
10756 #else  /* not __STDC__ */
10757 /* As in Harbison and Steele.  */
10758 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
10759 #endif
10760 
10761 #define parser_encoding_name()  (current_enc->name)
10762 #define parser_mbclen()  mbclen((lex_p-1),lex_pend,current_enc)
10763 #define parser_precise_mbclen()  rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
10764 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
10765 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
10766 
10767 #define parser_isascii() ISASCII(*(lex_p-1))
10768 
10769 #ifndef RIPPER
10770 static int
10771 token_info_get_column(struct parser_params *parser, const char *token)
10772 {
10773     int column = 1;
10774     const char *p, *pend = lex_p - strlen(token);
10775     for (p = lex_pbeg; p < pend; p++) {
10776         if (*p == '\t') {
10777             column = (((column - 1) / 8) + 1) * 8;
10778         }
10779         column++;
10780     }
10781     return column;
10782 }
10783 
10784 static int
10785 token_info_has_nonspaces(struct parser_params *parser, const char *token)
10786 {
10787     const char *p, *pend = lex_p - strlen(token);
10788     for (p = lex_pbeg; p < pend; p++) {
10789         if (*p != ' ' && *p != '\t') {
10790             return 1;
10791         }
10792     }
10793     return 0;
10794 }
10795 
10796 #undef token_info_push
10797 static void
10798 token_info_push(struct parser_params *parser, const char *token)
10799 {
10800     token_info *ptinfo;
10801 
10802     if (!parser->parser_token_info_enabled) return;
10803     ptinfo = ALLOC(token_info);
10804     ptinfo->token = token;
10805     ptinfo->linenum = ruby_sourceline;
10806     ptinfo->column = token_info_get_column(parser, token);
10807     ptinfo->nonspc = token_info_has_nonspaces(parser, token);
10808     ptinfo->next = parser->parser_token_info;
10809 
10810     parser->parser_token_info = ptinfo;
10811 }
10812 
10813 #undef token_info_pop
10814 static void
10815 token_info_pop(struct parser_params *parser, const char *token)
10816 {
10817     int linenum;
10818     token_info *ptinfo = parser->parser_token_info;
10819 
10820     if (!ptinfo) return;
10821     parser->parser_token_info = ptinfo->next;
10822     if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
10823         goto finish;
10824     }
10825     linenum = ruby_sourceline;
10826     if (linenum == ptinfo->linenum) { /* SKIP */
10827         goto finish;
10828     }
10829     if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
10830         goto finish;
10831     }
10832     if (parser->parser_token_info_enabled) {
10833         rb_compile_warn(ruby_sourcefile, linenum,
10834                         "mismatched indentations at '%s' with '%s' at %d",
10835                         token, ptinfo->token, ptinfo->linenum);
10836     }
10837 
10838   finish:
10839     xfree(ptinfo);
10840 }
10841 #endif  /* RIPPER */
10842 
10843 static int
10844 parser_yyerror(struct parser_params *parser, const char *msg)
10845 {
10846 #ifndef RIPPER
10847     const int max_line_margin = 30;
10848     const char *p, *pe;
10849     char *buf;
10850     long len;
10851     int i;
10852 
10853     compile_error(PARSER_ARG "%s", msg);
10854     p = lex_p;
10855     while (lex_pbeg <= p) {
10856         if (*p == '\n') break;
10857         p--;
10858     }
10859     p++;
10860 
10861     pe = lex_p;
10862     while (pe < lex_pend) {
10863         if (*pe == '\n') break;
10864         pe++;
10865     }
10866 
10867     len = pe - p;
10868     if (len > 4) {
10869         char *p2;
10870         const char *pre = "", *post = "";
10871 
10872         if (len > max_line_margin * 2 + 10) {
10873             if (lex_p - p > max_line_margin) {
10874                 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
10875                 pre = "...";
10876             }
10877             if (pe - lex_p > max_line_margin) {
10878                 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
10879                 post = "...";
10880             }
10881             len = pe - p;
10882         }
10883         buf = ALLOCA_N(char, len+2);
10884         MEMCPY(buf, p, char, len);
10885         buf[len] = '\0';
10886         rb_compile_error_append("%s%s%s", pre, buf, post);
10887 
10888         i = (int)(lex_p - p);
10889         p2 = buf; pe = buf + len;
10890 
10891         while (p2 < pe) {
10892             if (*p2 != '\t') *p2 = ' ';
10893             p2++;
10894         }
10895         buf[i] = '^';
10896         buf[i+1] = '\0';
10897         rb_compile_error_append("%s%s", pre, buf);
10898     }
10899 #else
10900     dispatch1(parse_error, STR_NEW2(msg));
10901 #endif /* !RIPPER */
10902     return 0;
10903 }
10904 
10905 static void parser_prepare(struct parser_params *parser);
10906 
10907 #ifndef RIPPER
10908 static VALUE
10909 debug_lines(const char *f)
10910 {
10911     ID script_lines;
10912     CONST_ID(script_lines, "SCRIPT_LINES__");
10913     if (rb_const_defined_at(rb_cObject, script_lines)) {
10914         VALUE hash = rb_const_get_at(rb_cObject, script_lines);
10915         if (RB_TYPE_P(hash, T_HASH)) {
10916             VALUE fname = rb_external_str_new_with_enc(f, strlen(f), rb_filesystem_encoding());
10917             VALUE lines = rb_ary_new();
10918             rb_hash_aset(hash, fname, lines);
10919             return lines;
10920         }
10921     }
10922     return 0;
10923 }
10924 
10925 static VALUE
10926 coverage(const char *f, int n)
10927 {
10928     VALUE coverages = rb_get_coverages();
10929     if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
10930         VALUE fname = rb_external_str_new_with_enc(f, strlen(f), rb_filesystem_encoding());
10931         VALUE lines = rb_ary_new2(n);
10932         int i;
10933         RBASIC(lines)->klass = 0;
10934         for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
10935         RARRAY(lines)->as.heap.len = n;
10936         rb_hash_aset(coverages, fname, lines);
10937         return lines;
10938     }
10939     return 0;
10940 }
10941 
10942 static int
10943 e_option_supplied(struct parser_params *parser)
10944 {
10945     return strcmp(ruby_sourcefile, "-e") == 0;
10946 }
10947 
10948 static VALUE
10949 yycompile0(VALUE arg)
10950 {
10951     int n;
10952     NODE *tree;
10953     struct parser_params *parser = (struct parser_params *)arg;
10954 
10955     if (!compile_for_eval && rb_safe_level() == 0) {
10956         ruby_debug_lines = debug_lines(ruby_sourcefile);
10957         if (ruby_debug_lines && ruby_sourceline > 0) {
10958             VALUE str = STR_NEW0();
10959             n = ruby_sourceline;
10960             do {
10961                 rb_ary_push(ruby_debug_lines, str);
10962             } while (--n);
10963         }
10964 
10965         if (!e_option_supplied(parser)) {
10966             ruby_coverage = coverage(ruby_sourcefile, ruby_sourceline);
10967         }
10968     }
10969 
10970     parser_prepare(parser);
10971     deferred_nodes = 0;
10972 #ifndef RIPPER
10973     parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
10974 #endif
10975 #ifndef RIPPER
10976     if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) {
10977         RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
10978                                 parser->parser_ruby_sourceline);
10979     }
10980 #endif
10981     n = yyparse((void*)parser);
10982 #ifndef RIPPER
10983     if (RUBY_DTRACE_PARSE_END_ENABLED()) {
10984         RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
10985                               parser->parser_ruby_sourceline);
10986     }
10987 #endif
10988     ruby_debug_lines = 0;
10989     ruby_coverage = 0;
10990     compile_for_eval = 0;
10991 
10992     lex_strterm = 0;
10993     lex_p = lex_pbeg = lex_pend = 0;
10994     lex_lastline = lex_nextline = 0;
10995     if (parser->nerr) {
10996         return 0;
10997     }
10998     tree = ruby_eval_tree;
10999     if (!tree) {
11000         tree = NEW_NIL();
11001     }
11002     else if (ruby_eval_tree_begin) {
11003         tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11004     }
11005     return (VALUE)tree;
11006 }
11007 
11008 static NODE*
11009 yycompile(struct parser_params *parser, const char *f, int line)
11010 {
11011     ruby_sourcefile = ruby_strdup(f);
11012     ruby_sourceline = line - 1;
11013     return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11014 }
11015 #endif /* !RIPPER */
11016 
11017 static rb_encoding *
11018 must_be_ascii_compatible(VALUE s)
11019 {
11020     rb_encoding *enc = rb_enc_get(s);
11021     if (!rb_enc_asciicompat(enc)) {
11022         rb_raise(rb_eArgError, "invalid source encoding");
11023     }
11024     return enc;
11025 }
11026 
11027 static VALUE
11028 lex_get_str(struct parser_params *parser, VALUE s)
11029 {
11030     char *beg, *end, *pend;
11031     rb_encoding *enc = must_be_ascii_compatible(s);
11032 
11033     beg = RSTRING_PTR(s);
11034     if (lex_gets_ptr) {
11035         if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11036         beg += lex_gets_ptr;
11037     }
11038     pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11039     end = beg;
11040     while (end < pend) {
11041         if (*end++ == '\n') break;
11042     }
11043     lex_gets_ptr = end - RSTRING_PTR(s);
11044     return rb_enc_str_new(beg, end - beg, enc);
11045 }
11046 
11047 static VALUE
11048 lex_getline(struct parser_params *parser)
11049 {
11050     VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11051     if (NIL_P(line)) return line;
11052     must_be_ascii_compatible(line);
11053 #ifndef RIPPER
11054     if (ruby_debug_lines) {
11055         rb_enc_associate(line, current_enc);
11056         rb_ary_push(ruby_debug_lines, line);
11057     }
11058     if (ruby_coverage) {
11059         rb_ary_push(ruby_coverage, Qnil);
11060     }
11061 #endif
11062     return line;
11063 }
11064 
11065 #ifdef RIPPER
11066 static rb_data_type_t parser_data_type;
11067 #else
11068 static const rb_data_type_t parser_data_type;
11069 
11070 static NODE*
11071 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11072 {
11073     struct parser_params *parser;
11074     NODE *node;
11075 
11076     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11077     lex_gets = lex_get_str;
11078     lex_gets_ptr = 0;
11079     lex_input = s;
11080     lex_pbeg = lex_p = lex_pend = 0;
11081     compile_for_eval = rb_parse_in_eval();
11082 
11083     node = yycompile(parser, f, line);
11084     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11085 
11086     return node;
11087 }
11088 
11089 NODE*
11090 rb_compile_string(const char *f, VALUE s, int line)
11091 {
11092     must_be_ascii_compatible(s);
11093     return parser_compile_string(rb_parser_new(), f, s, line);
11094 }
11095 
11096 NODE*
11097 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11098 {
11099     must_be_ascii_compatible(s);
11100     return parser_compile_string(vparser, f, s, line);
11101 }
11102 
11103 NODE*
11104 rb_compile_cstr(const char *f, const char *s, int len, int line)
11105 {
11106     VALUE str = rb_str_new(s, len);
11107     return parser_compile_string(rb_parser_new(), f, str, line);
11108 }
11109 
11110 NODE*
11111 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11112 {
11113     VALUE str = rb_str_new(s, len);
11114     return parser_compile_string(vparser, f, str, line);
11115 }
11116 
11117 static VALUE
11118 lex_io_gets(struct parser_params *parser, VALUE io)
11119 {
11120     return rb_io_gets(io);
11121 }
11122 
11123 NODE*
11124 rb_compile_file(const char *f, VALUE file, int start)
11125 {
11126     VALUE volatile vparser = rb_parser_new();
11127 
11128     return rb_parser_compile_file(vparser, f, file, start);
11129 }
11130 
11131 NODE*
11132 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11133 {
11134     struct parser_params *parser;
11135     NODE *node;
11136 
11137     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11138     lex_gets = lex_io_gets;
11139     lex_input = file;
11140     lex_pbeg = lex_p = lex_pend = 0;
11141     compile_for_eval = rb_parse_in_eval();
11142 
11143     node = yycompile(parser, f, start);
11144     RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11145 
11146     return node;
11147 }
11148 #endif  /* !RIPPER */
11149 
11150 #define STR_FUNC_ESCAPE 0x01
11151 #define STR_FUNC_EXPAND 0x02
11152 #define STR_FUNC_REGEXP 0x04
11153 #define STR_FUNC_QWORDS 0x08
11154 #define STR_FUNC_SYMBOL 0x10
11155 #define STR_FUNC_INDENT 0x20
11156 
11157 enum string_type {
11158     str_squote = (0),
11159     str_dquote = (STR_FUNC_EXPAND),
11160     str_xquote = (STR_FUNC_EXPAND),
11161     str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
11162     str_sword  = (STR_FUNC_QWORDS),
11163     str_dword  = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
11164     str_ssym   = (STR_FUNC_SYMBOL),
11165     str_dsym   = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
11166 };
11167 
11168 static VALUE
11169 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11170 {
11171     VALUE str;
11172 
11173     str = rb_enc_str_new(p, n, enc);
11174     if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11175         if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
11176         }
11177         else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11178             rb_enc_associate(str, rb_ascii8bit_encoding());
11179         }
11180     }
11181 
11182     return str;
11183 }
11184 
11185 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
11186 #define lex_eol_p() (lex_p >= lex_pend)
11187 #define peek(c) peek_n((c), 0)
11188 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11189 
11190 static inline int
11191 parser_nextc(struct parser_params *parser)
11192 {
11193     int c;
11194 
11195     if (lex_p == lex_pend) {
11196         VALUE v = lex_nextline;
11197         lex_nextline = 0;
11198         if (!v) {
11199             if (parser->eofp)
11200                 return -1;
11201 
11202             if (!lex_input || NIL_P(v = lex_getline(parser))) {
11203                 parser->eofp = Qtrue;
11204                 lex_goto_eol(parser);
11205                 return -1;
11206             }
11207         }
11208         {
11209 #ifdef RIPPER
11210             if (parser->tokp < lex_pend) {
11211                 if (NIL_P(parser->delayed)) {
11212                     parser->delayed = rb_str_buf_new(1024);
11213                     rb_enc_associate(parser->delayed, current_enc);
11214                     rb_str_buf_cat(parser->delayed,
11215                                    parser->tokp, lex_pend - parser->tokp);
11216                     parser->delayed_line = ruby_sourceline;
11217                     parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11218                 }
11219                 else {
11220                     rb_str_buf_cat(parser->delayed,
11221                                    parser->tokp, lex_pend - parser->tokp);
11222                 }
11223             }
11224 #endif
11225             if (heredoc_end > 0) {
11226                 ruby_sourceline = heredoc_end;
11227                 heredoc_end = 0;
11228             }
11229             ruby_sourceline++;
11230             parser->line_count++;
11231             lex_pbeg = lex_p = RSTRING_PTR(v);
11232             lex_pend = lex_p + RSTRING_LEN(v);
11233             ripper_flush(parser);
11234             lex_lastline = v;
11235         }
11236     }
11237     c = (unsigned char)*lex_p++;
11238     if (c == '\r' && peek('\n')) {
11239         lex_p++;
11240         c = '\n';
11241     }
11242 
11243     return c;
11244 }
11245 
11246 static void
11247 parser_pushback(struct parser_params *parser, int c)
11248 {
11249     if (c == -1) return;
11250     lex_p--;
11251     if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11252         lex_p--;
11253     }
11254 }
11255 
11256 #define was_bol() (lex_p == lex_pbeg + 1)
11257 
11258 #define tokfix() (tokenbuf[tokidx]='\0')
11259 #define tok() tokenbuf
11260 #define toklen() tokidx
11261 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11262 
11263 static char*
11264 parser_newtok(struct parser_params *parser)
11265 {
11266     tokidx = 0;
11267     tokline = ruby_sourceline;
11268     if (!tokenbuf) {
11269         toksiz = 60;
11270         tokenbuf = ALLOC_N(char, 60);
11271     }
11272     if (toksiz > 4096) {
11273         toksiz = 60;
11274         REALLOC_N(tokenbuf, char, 60);
11275     }
11276     return tokenbuf;
11277 }
11278 
11279 static char *
11280 parser_tokspace(struct parser_params *parser, int n)
11281 {
11282     tokidx += n;
11283 
11284     if (tokidx >= toksiz) {
11285         do {toksiz *= 2;} while (toksiz < tokidx);
11286         REALLOC_N(tokenbuf, char, toksiz);
11287     }
11288     return &tokenbuf[tokidx-n];
11289 }
11290 
11291 static void
11292 parser_tokadd(struct parser_params *parser, int c)
11293 {
11294     tokenbuf[tokidx++] = (char)c;
11295     if (tokidx >= toksiz) {
11296         toksiz *= 2;
11297         REALLOC_N(tokenbuf, char, toksiz);
11298     }
11299 }
11300 
11301 static int
11302 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11303 {
11304     int c;
11305 
11306     c = scan_hex(lex_p, 2, numlen);
11307     if (!*numlen) {
11308         yyerror("invalid hex escape");
11309         return 0;
11310     }
11311     lex_p += *numlen;
11312     return c;
11313 }
11314 
11315 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11316 
11317 /* return value is for ?\u3042 */
11318 static int
11319 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
11320                    int string_literal, int symbol_literal, int regexp_literal)
11321 {
11322     /*
11323      * If string_literal is true, then we allow multiple codepoints
11324      * in \u{}, and add the codepoints to the current token.
11325      * Otherwise we're parsing a character literal and return a single
11326      * codepoint without adding it
11327      */
11328 
11329     int codepoint;
11330     size_t numlen;
11331 
11332     if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11333 
11334     if (peek('{')) {  /* handle \u{...} form */
11335         do {
11336             if (regexp_literal) { tokadd(*lex_p); }
11337             nextc();
11338             codepoint = scan_hex(lex_p, 6, &numlen);
11339             if (numlen == 0)  {
11340                 yyerror("invalid Unicode escape");
11341                 return 0;
11342             }
11343             if (codepoint > 0x10ffff) {
11344                 yyerror("invalid Unicode codepoint (too large)");
11345                 return 0;
11346             }
11347             lex_p += numlen;
11348             if (regexp_literal) {
11349                 tokcopy((int)numlen);
11350             }
11351             else if (codepoint >= 0x80) {
11352                 *encp = rb_utf8_encoding();
11353                 if (string_literal) tokaddmbc(codepoint, *encp);
11354             }
11355             else if (string_literal) {
11356                 tokadd(codepoint);
11357             }
11358         } while (string_literal && (peek(' ') || peek('\t')));
11359 
11360         if (!peek('}')) {
11361             yyerror("unterminated Unicode escape");
11362             return 0;
11363         }
11364 
11365         if (regexp_literal) { tokadd('}'); }
11366         nextc();
11367     }
11368     else {                      /* handle \uxxxx form */
11369         codepoint = scan_hex(lex_p, 4, &numlen);
11370         if (numlen < 4) {
11371             yyerror("invalid Unicode escape");
11372             return 0;
11373         }
11374         lex_p += 4;
11375         if (regexp_literal) {
11376             tokcopy(4);
11377         }
11378         else if (codepoint >= 0x80) {
11379             *encp = rb_utf8_encoding();
11380             if (string_literal) tokaddmbc(codepoint, *encp);
11381         }
11382         else if (string_literal) {
11383             tokadd(codepoint);
11384         }
11385     }
11386 
11387     return codepoint;
11388 }
11389 
11390 #define ESCAPE_CONTROL 1
11391 #define ESCAPE_META    2
11392 
11393 static int
11394 parser_read_escape(struct parser_params *parser, int flags,
11395                    rb_encoding **encp)
11396 {
11397     int c;
11398     size_t numlen;
11399 
11400     switch (c = nextc()) {
11401       case '\\':        /* Backslash */
11402         return c;
11403 
11404       case 'n': /* newline */
11405         return '\n';
11406 
11407       case 't': /* horizontal tab */
11408         return '\t';
11409 
11410       case 'r': /* carriage-return */
11411         return '\r';
11412 
11413       case 'f': /* form-feed */
11414         return '\f';
11415 
11416       case 'v': /* vertical tab */
11417         return '\13';
11418 
11419       case 'a': /* alarm(bell) */
11420         return '\007';
11421 
11422       case 'e': /* escape */
11423         return 033;
11424 
11425       case '0': case '1': case '2': case '3': /* octal constant */
11426       case '4': case '5': case '6': case '7':
11427         pushback(c);
11428         c = scan_oct(lex_p, 3, &numlen);
11429         lex_p += numlen;
11430         return c;
11431 
11432       case 'x': /* hex constant */
11433         c = tok_hex(&numlen);
11434         if (numlen == 0) return 0;
11435         return c;
11436 
11437       case 'b': /* backspace */
11438         return '\010';
11439 
11440       case 's': /* space */
11441         return ' ';
11442 
11443       case 'M':
11444         if (flags & ESCAPE_META) goto eof;
11445         if ((c = nextc()) != '-') {
11446             pushback(c);
11447             goto eof;
11448         }
11449         if ((c = nextc()) == '\\') {
11450             if (peek('u')) goto eof;
11451             return read_escape(flags|ESCAPE_META, encp) | 0x80;
11452         }
11453         else if (c == -1 || !ISASCII(c)) goto eof;
11454         else {
11455             return ((c & 0xff) | 0x80);
11456         }
11457 
11458       case 'C':
11459         if ((c = nextc()) != '-') {
11460             pushback(c);
11461             goto eof;
11462         }
11463       case 'c':
11464         if (flags & ESCAPE_CONTROL) goto eof;
11465         if ((c = nextc())== '\\') {
11466             if (peek('u')) goto eof;
11467             c = read_escape(flags|ESCAPE_CONTROL, encp);
11468         }
11469         else if (c == '?')
11470             return 0177;
11471         else if (c == -1 || !ISASCII(c)) goto eof;
11472         return c & 0x9f;
11473 
11474       eof:
11475       case -1:
11476         yyerror("Invalid escape character syntax");
11477         return '\0';
11478 
11479       default:
11480         return c;
11481     }
11482 }
11483 
11484 static void
11485 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
11486 {
11487     int len = rb_enc_codelen(c, enc);
11488     rb_enc_mbcput(c, tokspace(len), enc);
11489 }
11490 
11491 static int
11492 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
11493 {
11494     int c;
11495     int flags = 0;
11496     size_t numlen;
11497 
11498   first:
11499     switch (c = nextc()) {
11500       case '\n':
11501         return 0;               /* just ignore */
11502 
11503       case '0': case '1': case '2': case '3': /* octal constant */
11504       case '4': case '5': case '6': case '7':
11505         {
11506             ruby_scan_oct(--lex_p, 3, &numlen);
11507             if (numlen == 0) goto eof;
11508             lex_p += numlen;
11509             tokcopy((int)numlen + 1);
11510         }
11511         return 0;
11512 
11513       case 'x': /* hex constant */
11514         {
11515             tok_hex(&numlen);
11516             if (numlen == 0) return -1;
11517             tokcopy((int)numlen + 2);
11518         }
11519         return 0;
11520 
11521       case 'M':
11522         if (flags & ESCAPE_META) goto eof;
11523         if ((c = nextc()) != '-') {
11524             pushback(c);
11525             goto eof;
11526         }
11527         tokcopy(3);
11528         flags |= ESCAPE_META;
11529         goto escaped;
11530 
11531       case 'C':
11532         if (flags & ESCAPE_CONTROL) goto eof;
11533         if ((c = nextc()) != '-') {
11534             pushback(c);
11535             goto eof;
11536         }
11537         tokcopy(3);
11538         goto escaped;
11539 
11540       case 'c':
11541         if (flags & ESCAPE_CONTROL) goto eof;
11542         tokcopy(2);
11543         flags |= ESCAPE_CONTROL;
11544       escaped:
11545         if ((c = nextc()) == '\\') {
11546             goto first;
11547         }
11548         else if (c == -1) goto eof;
11549         tokadd(c);
11550         return 0;
11551 
11552       eof:
11553       case -1:
11554         yyerror("Invalid escape character syntax");
11555         return -1;
11556 
11557       default:
11558         tokadd('\\');
11559         tokadd(c);
11560     }
11561     return 0;
11562 }
11563 
11564 static int
11565 parser_regx_options(struct parser_params *parser)
11566 {
11567     int kcode = 0;
11568     int kopt = 0;
11569     int options = 0;
11570     int c, opt, kc;
11571 
11572     newtok();
11573     while (c = nextc(), ISALPHA(c)) {
11574         if (c == 'o') {
11575             options |= RE_OPTION_ONCE;
11576         }
11577         else if (rb_char_to_option_kcode(c, &opt, &kc)) {
11578             if (kc >= 0) {
11579                 if (kc != rb_ascii8bit_encindex()) kcode = c;
11580                 kopt = opt;
11581             }
11582             else {
11583                 options |= opt;
11584             }
11585         }
11586         else {
11587             tokadd(c);
11588         }
11589     }
11590     options |= kopt;
11591     pushback(c);
11592     if (toklen()) {
11593         tokfix();
11594         compile_error(PARSER_ARG "unknown regexp option%s - %s",
11595                       toklen() > 1 ? "s" : "", tok());
11596     }
11597     return options | RE_OPTION_ENCODING(kcode);
11598 }
11599 
11600 static void
11601 dispose_string(VALUE str)
11602 {
11603     rb_str_free(str);
11604     rb_gc_force_recycle(str);
11605 }
11606 
11607 static int
11608 parser_tokadd_mbchar(struct parser_params *parser, int c)
11609 {
11610     int len = parser_precise_mbclen();
11611     if (!MBCLEN_CHARFOUND_P(len)) {
11612         compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
11613         return -1;
11614     }
11615     tokadd(c);
11616     lex_p += --len;
11617     if (len > 0) tokcopy(len);
11618     return c;
11619 }
11620 
11621 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
11622 
11623 static inline int
11624 simple_re_meta(int c)
11625 {
11626     switch (c) {
11627       case '$': case '*': case '+': case '.':
11628       case '?': case '^': case '|':
11629       case ')': case ']': case '}': case '>':
11630         return TRUE;
11631       default:
11632         return FALSE;
11633     }
11634 }
11635 
11636 static int
11637 parser_tokadd_string(struct parser_params *parser,
11638                      int func, int term, int paren, long *nest,
11639                      rb_encoding **encp)
11640 {
11641     int c;
11642     int has_nonascii = 0;
11643     rb_encoding *enc = *encp;
11644     char *errbuf = 0;
11645     static const char mixed_msg[] = "%s mixed within %s source";
11646 
11647 #define mixed_error(enc1, enc2) if (!errbuf) {  \
11648         size_t len = sizeof(mixed_msg) - 4;     \
11649         len += strlen(rb_enc_name(enc1));       \
11650         len += strlen(rb_enc_name(enc2));       \
11651         errbuf = ALLOCA_N(char, len);           \
11652         snprintf(errbuf, len, mixed_msg,        \
11653                  rb_enc_name(enc1),             \
11654                  rb_enc_name(enc2));            \
11655         yyerror(errbuf);                        \
11656     }
11657 #define mixed_escape(beg, enc1, enc2) do {      \
11658         const char *pos = lex_p;                \
11659         lex_p = (beg);                          \
11660         mixed_error((enc1), (enc2));            \
11661         lex_p = pos;                            \
11662     } while (0)
11663 
11664     while ((c = nextc()) != -1) {
11665         if (paren && c == paren) {
11666             ++*nest;
11667         }
11668         else if (c == term) {
11669             if (!nest || !*nest) {
11670                 pushback(c);
11671                 break;
11672             }
11673             --*nest;
11674         }
11675         else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
11676             int c2 = *lex_p;
11677             if (c2 == '$' || c2 == '@' || c2 == '{') {
11678                 pushback(c);
11679                 break;
11680             }
11681         }
11682         else if (c == '\\') {
11683             const char *beg = lex_p - 1;
11684             c = nextc();
11685             switch (c) {
11686               case '\n':
11687                 if (func & STR_FUNC_QWORDS) break;
11688                 if (func & STR_FUNC_EXPAND) continue;
11689                 tokadd('\\');
11690                 break;
11691 
11692               case '\\':
11693                 if (func & STR_FUNC_ESCAPE) tokadd(c);
11694                 break;
11695 
11696               case 'u':
11697                 if ((func & STR_FUNC_EXPAND) == 0) {
11698                     tokadd('\\');
11699                     break;
11700                 }
11701                 parser_tokadd_utf8(parser, &enc, 1,
11702                                    func & STR_FUNC_SYMBOL,
11703                                    func & STR_FUNC_REGEXP);
11704                 if (has_nonascii && enc != *encp) {
11705                     mixed_escape(beg, enc, *encp);
11706                 }
11707                 continue;
11708 
11709               default:
11710                 if (c == -1) return -1;
11711                 if (!ISASCII(c)) {
11712                     if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
11713                     goto non_ascii;
11714                 }
11715                 if (func & STR_FUNC_REGEXP) {
11716                     if (c == term && !simple_re_meta(c)) {
11717                         tokadd(c);
11718                         continue;
11719                     }
11720                     pushback(c);
11721                     if ((c = tokadd_escape(&enc)) < 0)
11722                         return -1;
11723                     if (has_nonascii && enc != *encp) {
11724                         mixed_escape(beg, enc, *encp);
11725                     }
11726                     continue;
11727                 }
11728                 else if (func & STR_FUNC_EXPAND) {
11729                     pushback(c);
11730                     if (func & STR_FUNC_ESCAPE) tokadd('\\');
11731                     c = read_escape(0, &enc);
11732                 }
11733                 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
11734                     /* ignore backslashed spaces in %w */
11735                 }
11736                 else if (c != term && !(paren && c == paren)) {
11737                     tokadd('\\');
11738                     pushback(c);
11739                     continue;
11740                 }
11741             }
11742         }
11743         else if (!parser_isascii()) {
11744           non_ascii:
11745             has_nonascii = 1;
11746             if (enc != *encp) {
11747                 mixed_error(enc, *encp);
11748                 continue;
11749             }
11750             if (tokadd_mbchar(c) == -1) return -1;
11751             continue;
11752         }
11753         else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
11754             pushback(c);
11755             break;
11756         }
11757         if (c & 0x80) {
11758             has_nonascii = 1;
11759             if (enc != *encp) {
11760                 mixed_error(enc, *encp);
11761                 continue;
11762             }
11763         }
11764         tokadd(c);
11765     }
11766     *encp = enc;
11767     return c;
11768 }
11769 
11770 #define NEW_STRTERM(func, term, paren) \
11771         rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
11772 
11773 #ifdef RIPPER
11774 static void
11775 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
11776 {
11777     if (!NIL_P(parser->delayed)) {
11778         ptrdiff_t len = lex_p - parser->tokp;
11779         if (len > 0) {
11780             rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
11781         }
11782         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
11783         parser->tokp = lex_p;
11784     }
11785 }
11786 
11787 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
11788 #else
11789 #define flush_string_content(enc) ((void)(enc))
11790 #endif
11791 
11792 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
11793 /* this can be shared with ripper, since it's independent from struct
11794  * parser_params. */
11795 #ifndef RIPPER
11796 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
11797 #define SPECIAL_PUNCT(idx) ( \
11798         BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
11799         BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
11800         BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
11801         BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
11802         BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
11803         BIT('0', idx))
11804 const unsigned int ruby_global_name_punct_bits[] = {
11805     SPECIAL_PUNCT(0),
11806     SPECIAL_PUNCT(1),
11807     SPECIAL_PUNCT(2),
11808 };
11809 #undef BIT
11810 #undef SPECIAL_PUNCT
11811 #endif
11812 
11813 static inline int
11814 is_global_name_punct(const char c)
11815 {
11816     if (c <= 0x20 || 0x7e < c) return 0;
11817     return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
11818 }
11819 
11820 static int
11821 parser_peek_variable_name(struct parser_params *parser)
11822 {
11823     int c;
11824     const char *p = lex_p;
11825 
11826     if (p + 1 >= lex_pend) return 0;
11827     c = *p++;
11828     switch (c) {
11829       case '$':
11830         if ((c = *p) == '-') {
11831             if (++p >= lex_pend) return 0;
11832             c = *p;
11833         }
11834         else if (is_global_name_punct(c) || ISDIGIT(c)) {
11835             return tSTRING_DVAR;
11836         }
11837         break;
11838       case '@':
11839         if ((c = *p) == '@') {
11840             if (++p >= lex_pend) return 0;
11841             c = *p;
11842         }
11843         break;
11844       case '{':
11845         lex_p = p;
11846         command_start = TRUE;
11847         return tSTRING_DBEG;
11848       default:
11849         return 0;
11850     }
11851     if (!ISASCII(c) || c == '_' || ISALPHA(c))
11852         return tSTRING_DVAR;
11853     return 0;
11854 }
11855 
11856 static int
11857 parser_parse_string(struct parser_params *parser, NODE *quote)
11858 {
11859     int func = (int)quote->nd_func;
11860     int term = nd_term(quote);
11861     int paren = nd_paren(quote);
11862     int c, space = 0;
11863     rb_encoding *enc = current_enc;
11864 
11865     if (func == -1) return tSTRING_END;
11866     c = nextc();
11867     if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
11868         do {c = nextc();} while (ISSPACE(c));
11869         space = 1;
11870     }
11871     if (c == term && !quote->nd_nest) {
11872         if (func & STR_FUNC_QWORDS) {
11873             quote->nd_func = -1;
11874             return ' ';
11875         }
11876         if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
11877         set_yylval_num(regx_options());
11878         return tREGEXP_END;
11879     }
11880     if (space) {
11881         pushback(c);
11882         return ' ';
11883     }
11884     newtok();
11885     if ((func & STR_FUNC_EXPAND) && c == '#') {
11886         int t = parser_peek_variable_name(parser);
11887         if (t) return t;
11888         tokadd('#');
11889         c = nextc();
11890     }
11891     pushback(c);
11892     if (tokadd_string(func, term, paren, &quote->nd_nest,
11893                       &enc) == -1) {
11894         ruby_sourceline = nd_line(quote);
11895         if (func & STR_FUNC_REGEXP) {
11896             if (parser->eofp)
11897                 compile_error(PARSER_ARG "unterminated regexp meets end of file");
11898             return tREGEXP_END;
11899         }
11900         else {
11901             if (parser->eofp)
11902                 compile_error(PARSER_ARG "unterminated string meets end of file");
11903             return tSTRING_END;
11904         }
11905     }
11906 
11907     tokfix();
11908     set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
11909     flush_string_content(enc);
11910 
11911     return tSTRING_CONTENT;
11912 }
11913 
11914 static int
11915 parser_heredoc_identifier(struct parser_params *parser)
11916 {
11917     int c = nextc(), term, func = 0;
11918     long len;
11919 
11920     if (c == '-') {
11921         c = nextc();
11922         func = STR_FUNC_INDENT;
11923     }
11924     switch (c) {
11925       case '\'':
11926         func |= str_squote; goto quoted;
11927       case '"':
11928         func |= str_dquote; goto quoted;
11929       case '`':
11930         func |= str_xquote;
11931       quoted:
11932         newtok();
11933         tokadd(func);
11934         term = c;
11935         while ((c = nextc()) != -1 && c != term) {
11936             if (tokadd_mbchar(c) == -1) return 0;
11937         }
11938         if (c == -1) {
11939             compile_error(PARSER_ARG "unterminated here document identifier");
11940             return 0;
11941         }
11942         break;
11943 
11944       default:
11945         if (!parser_is_identchar()) {
11946             pushback(c);
11947             if (func & STR_FUNC_INDENT) {
11948                 pushback('-');
11949             }
11950             return 0;
11951         }
11952         newtok();
11953         term = '"';
11954         tokadd(func |= str_dquote);
11955         do {
11956             if (tokadd_mbchar(c) == -1) return 0;
11957         } while ((c = nextc()) != -1 && parser_is_identchar());
11958         pushback(c);
11959         break;
11960     }
11961 
11962     tokfix();
11963 #ifdef RIPPER
11964     ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
11965 #endif
11966     len = lex_p - lex_pbeg;
11967     lex_goto_eol(parser);
11968     lex_strterm = rb_node_newnode(NODE_HEREDOC,
11969                                   STR_NEW(tok(), toklen()),     /* nd_lit */
11970                                   len,                          /* nd_nth */
11971                                   lex_lastline);                /* nd_orig */
11972     nd_set_line(lex_strterm, ruby_sourceline);
11973     ripper_flush(parser);
11974     return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
11975 }
11976 
11977 static void
11978 parser_heredoc_restore(struct parser_params *parser, NODE *here)
11979 {
11980     VALUE line;
11981 
11982     line = here->nd_orig;
11983     lex_lastline = line;
11984     lex_pbeg = RSTRING_PTR(line);
11985     lex_pend = lex_pbeg + RSTRING_LEN(line);
11986     lex_p = lex_pbeg + here->nd_nth;
11987     heredoc_end = ruby_sourceline;
11988     ruby_sourceline = nd_line(here);
11989     dispose_string(here->nd_lit);
11990     rb_gc_force_recycle((VALUE)here);
11991     ripper_flush(parser);
11992 }
11993 
11994 static int
11995 parser_whole_match_p(struct parser_params *parser,
11996     const char *eos, long len, int indent)
11997 {
11998     const char *p = lex_pbeg;
11999     long n;
12000 
12001     if (indent) {
12002         while (*p && ISSPACE(*p)) p++;
12003     }
12004     n = lex_pend - (p + len);
12005     if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12006     return strncmp(eos, p, len) == 0;
12007 }
12008 
12009 #ifdef RIPPER
12010 static void
12011 ripper_dispatch_heredoc_end(struct parser_params *parser)
12012 {
12013     if (!NIL_P(parser->delayed))
12014         ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12015     lex_goto_eol(parser);
12016     ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12017 }
12018 
12019 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12020 #else
12021 #define dispatch_heredoc_end() ((void)0)
12022 #endif
12023 
12024 static int
12025 parser_here_document(struct parser_params *parser, NODE *here)
12026 {
12027     int c, func, indent = 0;
12028     const char *eos, *p, *pend;
12029     long len;
12030     VALUE str = 0;
12031     rb_encoding *enc = current_enc;
12032 
12033     eos = RSTRING_PTR(here->nd_lit);
12034     len = RSTRING_LEN(here->nd_lit) - 1;
12035     indent = (func = *eos++) & STR_FUNC_INDENT;
12036 
12037     if ((c = nextc()) == -1) {
12038       error:
12039         compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12040 #ifdef RIPPER
12041         if (NIL_P(parser->delayed)) {
12042             ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12043         }
12044         else {
12045             if (str ||
12046                 ((len = lex_p - parser->tokp) > 0 &&
12047                  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12048                 rb_str_append(parser->delayed, str);
12049             }
12050             ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12051         }
12052         lex_goto_eol(parser);
12053 #endif
12054       restore:
12055         heredoc_restore(lex_strterm);
12056         lex_strterm = 0;
12057         return 0;
12058     }
12059     if (was_bol() && whole_match_p(eos, len, indent)) {
12060         dispatch_heredoc_end();
12061         heredoc_restore(lex_strterm);
12062         return tSTRING_END;
12063     }
12064 
12065     if (!(func & STR_FUNC_EXPAND)) {
12066         do {
12067             p = RSTRING_PTR(lex_lastline);
12068             pend = lex_pend;
12069             if (pend > p) {
12070                 switch (pend[-1]) {
12071                   case '\n':
12072                     if (--pend == p || pend[-1] != '\r') {
12073                         pend++;
12074                         break;
12075                     }
12076                   case '\r':
12077                     --pend;
12078                 }
12079             }
12080             if (str)
12081                 rb_str_cat(str, p, pend - p);
12082             else
12083                 str = STR_NEW(p, pend - p);
12084             if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12085             lex_goto_eol(parser);
12086             if (nextc() == -1) {
12087                 if (str) dispose_string(str);
12088                 goto error;
12089             }
12090         } while (!whole_match_p(eos, len, indent));
12091     }
12092     else {
12093         /*      int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12094         newtok();
12095         if (c == '#') {
12096             int t = parser_peek_variable_name(parser);
12097             if (t) return t;
12098             tokadd('#');
12099             c = nextc();
12100         }
12101         do {
12102             pushback(c);
12103             if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12104                 if (parser->eofp) goto error;
12105                 goto restore;
12106             }
12107             if (c != '\n') {
12108                 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12109                 flush_string_content(enc);
12110                 return tSTRING_CONTENT;
12111             }
12112             tokadd(nextc());
12113             /*      if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12114             if ((c = nextc()) == -1) goto error;
12115         } while (!whole_match_p(eos, len, indent));
12116         str = STR_NEW3(tok(), toklen(), enc, func);
12117     }
12118     dispatch_heredoc_end();
12119     heredoc_restore(lex_strterm);
12120     lex_strterm = NEW_STRTERM(-1, 0, 0);
12121     set_yylval_str(str);
12122     return tSTRING_CONTENT;
12123 }
12124 
12125 #include "lex.c"
12126 
12127 static void
12128 arg_ambiguous_gen(struct parser_params *parser)
12129 {
12130 #ifndef RIPPER
12131     rb_warning0("ambiguous first argument; put parentheses or even spaces");
12132 #else
12133     dispatch0(arg_ambiguous);
12134 #endif
12135 }
12136 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12137 
12138 static ID
12139 formal_argument_gen(struct parser_params *parser, ID lhs)
12140 {
12141 #ifndef RIPPER
12142     if (!is_local_id(lhs))
12143         yyerror("formal argument must be local variable");
12144 #endif
12145     shadowing_lvar(lhs);
12146     return lhs;
12147 }
12148 
12149 static int
12150 lvar_defined_gen(struct parser_params *parser, ID id)
12151 {
12152     return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
12153 }
12154 
12155 /* emacsen -*- hack */
12156 static long
12157 parser_encode_length(struct parser_params *parser, const char *name, long len)
12158 {
12159     long nlen;
12160 
12161     if (len > 5 && name[nlen = len - 5] == '-') {
12162         if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12163             return nlen;
12164     }
12165     if (len > 4 && name[nlen = len - 4] == '-') {
12166         if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12167             return nlen;
12168         if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12169             !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12170             /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12171             return nlen;
12172     }
12173     return len;
12174 }
12175 
12176 static void
12177 parser_set_encode(struct parser_params *parser, const char *name)
12178 {
12179     int idx = rb_enc_find_index(name);
12180     rb_encoding *enc;
12181     VALUE excargs[3];
12182 
12183     if (idx < 0) {
12184         excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12185       error:
12186         excargs[0] = rb_eArgError;
12187         excargs[2] = rb_make_backtrace();
12188         rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12189         rb_exc_raise(rb_make_exception(3, excargs));
12190     }
12191     enc = rb_enc_from_index(idx);
12192     if (!rb_enc_asciicompat(enc)) {
12193         excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
12194         goto error;
12195     }
12196     parser->enc = enc;
12197 #ifndef RIPPER
12198     if (ruby_debug_lines) {
12199         long i, n = RARRAY_LEN(ruby_debug_lines);
12200         const VALUE *p = RARRAY_PTR(ruby_debug_lines);
12201         for (i = 0; i < n; ++i) {
12202             rb_enc_associate_index(*p, idx);
12203         }
12204     }
12205 #endif
12206 }
12207 
12208 static int
12209 comment_at_top(struct parser_params *parser)
12210 {
12211     const char *p = lex_pbeg, *pend = lex_p - 1;
12212     if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
12213     while (p < pend) {
12214         if (!ISSPACE(*p)) return 0;
12215         p++;
12216     }
12217     return 1;
12218 }
12219 
12220 #ifndef RIPPER
12221 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
12222 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
12223 
12224 static void
12225 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
12226 {
12227     if (!comment_at_top(parser)) {
12228         return;
12229     }
12230     parser_set_encode(parser, val);
12231 }
12232 
12233 static void
12234 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
12235 {
12236     int *p = &parser->parser_token_info_enabled;
12237 
12238     switch (*val) {
12239       case 't': case 'T':
12240         if (strcasecmp(val, "true") == 0) {
12241             *p = TRUE;
12242             return;
12243         }
12244         break;
12245       case 'f': case 'F':
12246         if (strcasecmp(val, "false") == 0) {
12247             *p = FALSE;
12248             return;
12249         }
12250         break;
12251     }
12252     rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
12253 }
12254 
12255 struct magic_comment {
12256     const char *name;
12257     rb_magic_comment_setter_t func;
12258     rb_magic_comment_length_t length;
12259 };
12260 
12261 static const struct magic_comment magic_comments[] = {
12262     {"coding", magic_comment_encoding, parser_encode_length},
12263     {"encoding", magic_comment_encoding, parser_encode_length},
12264     {"warn_indent", parser_set_token_info},
12265 };
12266 #endif
12267 
12268 static const char *
12269 magic_comment_marker(const char *str, long len)
12270 {
12271     long i = 2;
12272 
12273     while (i < len) {
12274         switch (str[i]) {
12275           case '-':
12276             if (str[i-1] == '*' && str[i-2] == '-') {
12277                 return str + i + 1;
12278             }
12279             i += 2;
12280             break;
12281           case '*':
12282             if (i + 1 >= len) return 0;
12283             if (str[i+1] != '-') {
12284                 i += 4;
12285             }
12286             else if (str[i-1] != '-') {
12287                 i += 2;
12288             }
12289             else {
12290                 return str + i + 2;
12291             }
12292             break;
12293           default:
12294             i += 3;
12295             break;
12296         }
12297     }
12298     return 0;
12299 }
12300 
12301 static int
12302 parser_magic_comment(struct parser_params *parser, const char *str, long len)
12303 {
12304     VALUE name = 0, val = 0;
12305     const char *beg, *end, *vbeg, *vend;
12306 #define str_copy(_s, _p, _n) ((_s) \
12307         ? (void)(rb_str_resize((_s), (_n)), \
12308            MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
12309         : (void)((_s) = STR_NEW((_p), (_n))))
12310 
12311     if (len <= 7) return FALSE;
12312     if (!(beg = magic_comment_marker(str, len))) return FALSE;
12313     if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
12314     str = beg;
12315     len = end - beg - 3;
12316 
12317     /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
12318     while (len > 0) {
12319 #ifndef RIPPER
12320         const struct magic_comment *p = magic_comments;
12321 #endif
12322         char *s;
12323         int i;
12324         long n = 0;
12325 
12326         for (; len > 0 && *str; str++, --len) {
12327             switch (*str) {
12328               case '\'': case '"': case ':': case ';':
12329                 continue;
12330             }
12331             if (!ISSPACE(*str)) break;
12332         }
12333         for (beg = str; len > 0; str++, --len) {
12334             switch (*str) {
12335               case '\'': case '"': case ':': case ';':
12336                 break;
12337               default:
12338                 if (ISSPACE(*str)) break;
12339                 continue;
12340             }
12341             break;
12342         }
12343         for (end = str; len > 0 && ISSPACE(*str); str++, --len);
12344         if (!len) break;
12345         if (*str != ':') continue;
12346 
12347         do str++; while (--len > 0 && ISSPACE(*str));
12348         if (!len) break;
12349         if (*str == '"') {
12350             for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
12351                 if (*str == '\\') {
12352                     --len;
12353                     ++str;
12354                 }
12355             }
12356             vend = str;
12357             if (len) {
12358                 --len;
12359                 ++str;
12360             }
12361         }
12362         else {
12363             for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
12364             vend = str;
12365         }
12366         while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
12367 
12368         n = end - beg;
12369         str_copy(name, beg, n);
12370         s = RSTRING_PTR(name);
12371         for (i = 0; i < n; ++i) {
12372             if (s[i] == '-') s[i] = '_';
12373         }
12374 #ifndef RIPPER
12375         do {
12376             if (STRNCASECMP(p->name, s, n) == 0) {
12377                 n = vend - vbeg;
12378                 if (p->length) {
12379                     n = (*p->length)(parser, vbeg, n);
12380                 }
12381                 str_copy(val, vbeg, n);
12382                 (*p->func)(parser, s, RSTRING_PTR(val));
12383                 break;
12384             }
12385         } while (++p < magic_comments + numberof(magic_comments));
12386 #else
12387         str_copy(val, vbeg, vend - vbeg);
12388         dispatch2(magic_comment, name, val);
12389 #endif
12390     }
12391 
12392     return TRUE;
12393 }
12394 
12395 static void
12396 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
12397 {
12398     int sep = 0;
12399     const char *beg = str;
12400     VALUE s;
12401 
12402     for (;;) {
12403         if (send - str <= 6) return;
12404         switch (str[6]) {
12405           case 'C': case 'c': str += 6; continue;
12406           case 'O': case 'o': str += 5; continue;
12407           case 'D': case 'd': str += 4; continue;
12408           case 'I': case 'i': str += 3; continue;
12409           case 'N': case 'n': str += 2; continue;
12410           case 'G': case 'g': str += 1; continue;
12411           case '=': case ':':
12412             sep = 1;
12413             str += 6;
12414             break;
12415           default:
12416             str += 6;
12417             if (ISSPACE(*str)) break;
12418             continue;
12419         }
12420         if (STRNCASECMP(str-6, "coding", 6) == 0) break;
12421     }
12422     for (;;) {
12423         do {
12424             if (++str >= send) return;
12425         } while (ISSPACE(*str));
12426         if (sep) break;
12427         if (*str != '=' && *str != ':') return;
12428         sep = 1;
12429         str++;
12430     }
12431     beg = str;
12432     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
12433     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
12434     parser_set_encode(parser, RSTRING_PTR(s));
12435     rb_str_resize(s, 0);
12436 }
12437 
12438 static void
12439 parser_prepare(struct parser_params *parser)
12440 {
12441     int c = nextc();
12442     switch (c) {
12443       case '#':
12444         if (peek('!')) parser->has_shebang = 1;
12445         break;
12446       case 0xef:                /* UTF-8 BOM marker */
12447         if (lex_pend - lex_p >= 2 &&
12448             (unsigned char)lex_p[0] == 0xbb &&
12449             (unsigned char)lex_p[1] == 0xbf) {
12450             parser->enc = rb_utf8_encoding();
12451             lex_p += 2;
12452             lex_pbeg = lex_p;
12453             return;
12454         }
12455         break;
12456       case EOF:
12457         return;
12458     }
12459     pushback(c);
12460     parser->enc = rb_enc_get(lex_lastline);
12461 }
12462 
12463 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
12464 #define IS_END() IS_lex_state(EXPR_END_ANY)
12465 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
12466 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12467 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
12468 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
12469 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
12470 
12471 #ifndef RIPPER
12472 #define ambiguous_operator(op, syn) ( \
12473     rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
12474     rb_warning0("even though it seems like "syn""))
12475 #else
12476 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
12477 #endif
12478 #define warn_balanced(op, syn) ((void) \
12479     (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
12480      space_seen && !ISSPACE(c) && \
12481      (ambiguous_operator(op, syn), 0)))
12482 
12483 static int
12484 parser_yylex(struct parser_params *parser)
12485 {
12486     register int c;
12487     int space_seen = 0;
12488     int cmd_state;
12489     enum lex_state_e last_state;
12490     rb_encoding *enc;
12491     int mb;
12492 #ifdef RIPPER
12493     int fallthru = FALSE;
12494 #endif
12495 
12496     if (lex_strterm) {
12497         int token;
12498         if (nd_type(lex_strterm) == NODE_HEREDOC) {
12499             token = here_document(lex_strterm);
12500             if (token == tSTRING_END) {
12501                 lex_strterm = 0;
12502                 lex_state = EXPR_END;
12503             }
12504         }
12505         else {
12506             token = parse_string(lex_strterm);
12507             if (token == tSTRING_END || token == tREGEXP_END) {
12508                 rb_gc_force_recycle((VALUE)lex_strterm);
12509                 lex_strterm = 0;
12510                 lex_state = EXPR_END;
12511             }
12512         }
12513         return token;
12514     }
12515     cmd_state = command_start;
12516     command_start = FALSE;
12517   retry:
12518     last_state = lex_state;
12519     switch (c = nextc()) {
12520       case '\0':                /* NUL */
12521       case '\004':              /* ^D */
12522       case '\032':              /* ^Z */
12523       case -1:                  /* end of script. */
12524         return 0;
12525 
12526         /* white spaces */
12527       case ' ': case '\t': case '\f': case '\r':
12528       case '\13': /* '\v' */
12529         space_seen = 1;
12530 #ifdef RIPPER
12531         while ((c = nextc())) {
12532             switch (c) {
12533               case ' ': case '\t': case '\f': case '\r':
12534               case '\13': /* '\v' */
12535                 break;
12536               default:
12537                 goto outofloop;
12538             }
12539         }
12540       outofloop:
12541         pushback(c);
12542         ripper_dispatch_scan_event(parser, tSP);
12543 #endif
12544         goto retry;
12545 
12546       case '#':         /* it's a comment */
12547         /* no magic_comment in shebang line */
12548         if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
12549             if (comment_at_top(parser)) {
12550                 set_file_encoding(parser, lex_p, lex_pend);
12551             }
12552         }
12553         lex_p = lex_pend;
12554 #ifdef RIPPER
12555         ripper_dispatch_scan_event(parser, tCOMMENT);
12556         fallthru = TRUE;
12557 #endif
12558         /* fall through */
12559       case '\n':
12560         if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
12561 #ifdef RIPPER
12562             if (!fallthru) {
12563                 ripper_dispatch_scan_event(parser, tIGNORED_NL);
12564             }
12565             fallthru = FALSE;
12566 #endif
12567             goto retry;
12568         }
12569         while ((c = nextc())) {
12570             switch (c) {
12571               case ' ': case '\t': case '\f': case '\r':
12572               case '\13': /* '\v' */
12573                 space_seen = 1;
12574                 break;
12575               case '.': {
12576                   if ((c = nextc()) != '.') {
12577                       pushback(c);
12578                       pushback('.');
12579                       goto retry;
12580                   }
12581               }
12582               default:
12583                 --ruby_sourceline;
12584                 lex_nextline = lex_lastline;
12585               case -1:          /* EOF no decrement*/
12586                 lex_goto_eol(parser);
12587 #ifdef RIPPER
12588                 if (c != -1) {
12589                     parser->tokp = lex_p;
12590                 }
12591 #endif
12592                 goto normal_newline;
12593             }
12594         }
12595       normal_newline:
12596         command_start = TRUE;
12597         lex_state = EXPR_BEG;
12598         return '\n';
12599 
12600       case '*':
12601         if ((c = nextc()) == '*') {
12602             if ((c = nextc()) == '=') {
12603                 set_yylval_id(tPOW);
12604                 lex_state = EXPR_BEG;
12605                 return tOP_ASGN;
12606             }
12607             pushback(c);
12608             if (IS_SPCARG(c)) {
12609                 rb_warning0("`**' interpreted as argument prefix");
12610                 c = tDSTAR;
12611             }
12612             else if (IS_BEG()) {
12613                 c = tDSTAR;
12614             }
12615             else {
12616                 warn_balanced("**", "argument prefix");
12617                 c = tPOW;
12618             }
12619         }
12620         else {
12621             if (c == '=') {
12622                 set_yylval_id('*');
12623                 lex_state = EXPR_BEG;
12624                 return tOP_ASGN;
12625             }
12626             pushback(c);
12627             if (IS_SPCARG(c)) {
12628                 rb_warning0("`*' interpreted as argument prefix");
12629                 c = tSTAR;
12630             }
12631             else if (IS_BEG()) {
12632                 c = tSTAR;
12633             }
12634             else {
12635                 warn_balanced("*", "argument prefix");
12636                 c = '*';
12637             }
12638         }
12639         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
12640         return c;
12641 
12642       case '!':
12643         c = nextc();
12644         if (IS_AFTER_OPERATOR()) {
12645             lex_state = EXPR_ARG;
12646             if (c == '@') {
12647                 return '!';
12648             }
12649         }
12650         else {
12651             lex_state = EXPR_BEG;
12652         }
12653         if (c == '=') {
12654             return tNEQ;
12655         }
12656         if (c == '~') {
12657             return tNMATCH;
12658         }
12659         pushback(c);
12660         return '!';
12661 
12662       case '=':
12663         if (was_bol()) {
12664             /* skip embedded rd document */
12665             if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
12666 #ifdef RIPPER
12667                 int first_p = TRUE;
12668 
12669                 lex_goto_eol(parser);
12670                 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
12671 #endif
12672                 for (;;) {
12673                     lex_goto_eol(parser);
12674 #ifdef RIPPER
12675                     if (!first_p) {
12676                         ripper_dispatch_scan_event(parser, tEMBDOC);
12677                     }
12678                     first_p = FALSE;
12679 #endif
12680                     c = nextc();
12681                     if (c == -1) {
12682                         compile_error(PARSER_ARG "embedded document meets end of file");
12683                         return 0;
12684                     }
12685                     if (c != '=') continue;
12686                     if (strncmp(lex_p, "end", 3) == 0 &&
12687                         (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
12688                         break;
12689                     }
12690                 }
12691                 lex_goto_eol(parser);
12692 #ifdef RIPPER
12693                 ripper_dispatch_scan_event(parser, tEMBDOC_END);
12694 #endif
12695                 goto retry;
12696             }
12697         }
12698 
12699         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
12700         if ((c = nextc()) == '=') {
12701             if ((c = nextc()) == '=') {
12702                 return tEQQ;
12703             }
12704             pushback(c);
12705             return tEQ;
12706         }
12707         if (c == '~') {
12708             return tMATCH;
12709         }
12710         else if (c == '>') {
12711             return tASSOC;
12712         }
12713         pushback(c);
12714         return '=';
12715 
12716       case '<':
12717         last_state = lex_state;
12718         c = nextc();
12719         if (c == '<' &&
12720             !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
12721             !IS_END() &&
12722             (!IS_ARG() || space_seen)) {
12723             int token = heredoc_identifier();
12724             if (token) return token;
12725         }
12726         if (IS_AFTER_OPERATOR()) {
12727             lex_state = EXPR_ARG;
12728         }
12729         else {
12730             if (IS_lex_state(EXPR_CLASS))
12731                 command_start = TRUE;
12732             lex_state = EXPR_BEG;
12733         }
12734         if (c == '=') {
12735             if ((c = nextc()) == '>') {
12736                 return tCMP;
12737             }
12738             pushback(c);
12739             return tLEQ;
12740         }
12741         if (c == '<') {
12742             if ((c = nextc()) == '=') {
12743                 set_yylval_id(tLSHFT);
12744                 lex_state = EXPR_BEG;
12745                 return tOP_ASGN;
12746             }
12747             pushback(c);
12748             warn_balanced("<<", "here document");
12749             return tLSHFT;
12750         }
12751         pushback(c);
12752         return '<';
12753 
12754       case '>':
12755         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
12756         if ((c = nextc()) == '=') {
12757             return tGEQ;
12758         }
12759         if (c == '>') {
12760             if ((c = nextc()) == '=') {
12761                 set_yylval_id(tRSHFT);
12762                 lex_state = EXPR_BEG;
12763                 return tOP_ASGN;
12764             }
12765             pushback(c);
12766             return tRSHFT;
12767         }
12768         pushback(c);
12769         return '>';
12770 
12771       case '"':
12772         lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
12773         return tSTRING_BEG;
12774 
12775       case '`':
12776         if (IS_lex_state(EXPR_FNAME)) {
12777             lex_state = EXPR_ENDFN;
12778             return c;
12779         }
12780         if (IS_lex_state(EXPR_DOT)) {
12781             if (cmd_state)
12782                 lex_state = EXPR_CMDARG;
12783             else
12784                 lex_state = EXPR_ARG;
12785             return c;
12786         }
12787         lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
12788         return tXSTRING_BEG;
12789 
12790       case '\'':
12791         lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
12792         return tSTRING_BEG;
12793 
12794       case '?':
12795         if (IS_END()) {
12796             lex_state = EXPR_VALUE;
12797             return '?';
12798         }
12799         c = nextc();
12800         if (c == -1) {
12801             compile_error(PARSER_ARG "incomplete character syntax");
12802             return 0;
12803         }
12804         if (rb_enc_isspace(c, current_enc)) {
12805             if (!IS_ARG()) {
12806                 int c2 = 0;
12807                 switch (c) {
12808                   case ' ':
12809                     c2 = 's';
12810                     break;
12811                   case '\n':
12812                     c2 = 'n';
12813                     break;
12814                   case '\t':
12815                     c2 = 't';
12816                     break;
12817                   case '\v':
12818                     c2 = 'v';
12819                     break;
12820                   case '\r':
12821                     c2 = 'r';
12822                     break;
12823                   case '\f':
12824                     c2 = 'f';
12825                     break;
12826                 }
12827                 if (c2) {
12828                     rb_warnI("invalid character syntax; use ?\\%c", c2);
12829                 }
12830             }
12831           ternary:
12832             pushback(c);
12833             lex_state = EXPR_VALUE;
12834             return '?';
12835         }
12836         newtok();
12837         enc = current_enc;
12838         if (!parser_isascii()) {
12839             if (tokadd_mbchar(c) == -1) return 0;
12840         }
12841         else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
12842                  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
12843             goto ternary;
12844         }
12845         else if (c == '\\') {
12846             if (peek('u')) {
12847                 nextc();
12848                 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
12849                 if (0x80 <= c) {
12850                     tokaddmbc(c, enc);
12851                 }
12852                 else {
12853                     tokadd(c);
12854                 }
12855             }
12856             else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
12857                 nextc();
12858                 if (tokadd_mbchar(c) == -1) return 0;
12859             }
12860             else {
12861                 c = read_escape(0, &enc);
12862                 tokadd(c);
12863             }
12864         }
12865         else {
12866             tokadd(c);
12867         }
12868         tokfix();
12869         set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
12870         lex_state = EXPR_END;
12871         return tCHAR;
12872 
12873       case '&':
12874         if ((c = nextc()) == '&') {
12875             lex_state = EXPR_BEG;
12876             if ((c = nextc()) == '=') {
12877                 set_yylval_id(tANDOP);
12878                 lex_state = EXPR_BEG;
12879                 return tOP_ASGN;
12880             }
12881             pushback(c);
12882             return tANDOP;
12883         }
12884         else if (c == '=') {
12885             set_yylval_id('&');
12886             lex_state = EXPR_BEG;
12887             return tOP_ASGN;
12888         }
12889         pushback(c);
12890         if (IS_SPCARG(c)) {
12891             rb_warning0("`&' interpreted as argument prefix");
12892             c = tAMPER;
12893         }
12894         else if (IS_BEG()) {
12895             c = tAMPER;
12896         }
12897         else {
12898             warn_balanced("&", "argument prefix");
12899             c = '&';
12900         }
12901         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
12902         return c;
12903 
12904       case '|':
12905         if ((c = nextc()) == '|') {
12906             lex_state = EXPR_BEG;
12907             if ((c = nextc()) == '=') {
12908                 set_yylval_id(tOROP);
12909                 lex_state = EXPR_BEG;
12910                 return tOP_ASGN;
12911             }
12912             pushback(c);
12913             return tOROP;
12914         }
12915         if (c == '=') {
12916             set_yylval_id('|');
12917             lex_state = EXPR_BEG;
12918             return tOP_ASGN;
12919         }
12920         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
12921         pushback(c);
12922         return '|';
12923 
12924       case '+':
12925         c = nextc();
12926         if (IS_AFTER_OPERATOR()) {
12927             lex_state = EXPR_ARG;
12928             if (c == '@') {
12929                 return tUPLUS;
12930             }
12931             pushback(c);
12932             return '+';
12933         }
12934         if (c == '=') {
12935             set_yylval_id('+');
12936             lex_state = EXPR_BEG;
12937             return tOP_ASGN;
12938         }
12939         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
12940             lex_state = EXPR_BEG;
12941             pushback(c);
12942             if (c != -1 && ISDIGIT(c)) {
12943                 c = '+';
12944                 goto start_num;
12945             }
12946             return tUPLUS;
12947         }
12948         lex_state = EXPR_BEG;
12949         pushback(c);
12950         warn_balanced("+", "unary operator");
12951         return '+';
12952 
12953       case '-':
12954         c = nextc();
12955         if (IS_AFTER_OPERATOR()) {
12956             lex_state = EXPR_ARG;
12957             if (c == '@') {
12958                 return tUMINUS;
12959             }
12960             pushback(c);
12961             return '-';
12962         }
12963         if (c == '=') {
12964             set_yylval_id('-');
12965             lex_state = EXPR_BEG;
12966             return tOP_ASGN;
12967         }
12968         if (c == '>') {
12969             lex_state = EXPR_ENDFN;
12970             return tLAMBDA;
12971         }
12972         if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
12973             lex_state = EXPR_BEG;
12974             pushback(c);
12975             if (c != -1 && ISDIGIT(c)) {
12976                 return tUMINUS_NUM;
12977             }
12978             return tUMINUS;
12979         }
12980         lex_state = EXPR_BEG;
12981         pushback(c);
12982         warn_balanced("-", "unary operator");
12983         return '-';
12984 
12985       case '.':
12986         lex_state = EXPR_BEG;
12987         if ((c = nextc()) == '.') {
12988             if ((c = nextc()) == '.') {
12989                 return tDOT3;
12990             }
12991             pushback(c);
12992             return tDOT2;
12993         }
12994         pushback(c);
12995         if (c != -1 && ISDIGIT(c)) {
12996             yyerror("no .<digit> floating literal anymore; put 0 before dot");
12997         }
12998         lex_state = EXPR_DOT;
12999         return '.';
13000 
13001       start_num:
13002       case '0': case '1': case '2': case '3': case '4':
13003       case '5': case '6': case '7': case '8': case '9':
13004         {
13005             int is_float, seen_point, seen_e, nondigit;
13006 
13007             is_float = seen_point = seen_e = nondigit = 0;
13008             lex_state = EXPR_END;
13009             newtok();
13010             if (c == '-' || c == '+') {
13011                 tokadd(c);
13012                 c = nextc();
13013             }
13014             if (c == '0') {
13015 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13016                 int start = toklen();
13017                 c = nextc();
13018                 if (c == 'x' || c == 'X') {
13019                     /* hexadecimal */
13020                     c = nextc();
13021                     if (c != -1 && ISXDIGIT(c)) {
13022                         do {
13023                             if (c == '_') {
13024                                 if (nondigit) break;
13025                                 nondigit = c;
13026                                 continue;
13027                             }
13028                             if (!ISXDIGIT(c)) break;
13029                             nondigit = 0;
13030                             tokadd(c);
13031                         } while ((c = nextc()) != -1);
13032                     }
13033                     pushback(c);
13034                     tokfix();
13035                     if (toklen() == start) {
13036                         no_digits();
13037                     }
13038                     else if (nondigit) goto trailing_uc;
13039                     set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
13040                     return tINTEGER;
13041                 }
13042                 if (c == 'b' || c == 'B') {
13043                     /* binary */
13044                     c = nextc();
13045                     if (c == '0' || c == '1') {
13046                         do {
13047                             if (c == '_') {
13048                                 if (nondigit) break;
13049                                 nondigit = c;
13050                                 continue;
13051                             }
13052                             if (c != '0' && c != '1') break;
13053                             nondigit = 0;
13054                             tokadd(c);
13055                         } while ((c = nextc()) != -1);
13056                     }
13057                     pushback(c);
13058                     tokfix();
13059                     if (toklen() == start) {
13060                         no_digits();
13061                     }
13062                     else if (nondigit) goto trailing_uc;
13063                     set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
13064                     return tINTEGER;
13065                 }
13066                 if (c == 'd' || c == 'D') {
13067                     /* decimal */
13068                     c = nextc();
13069                     if (c != -1 && ISDIGIT(c)) {
13070                         do {
13071                             if (c == '_') {
13072                                 if (nondigit) break;
13073                                 nondigit = c;
13074                                 continue;
13075                             }
13076                             if (!ISDIGIT(c)) break;
13077                             nondigit = 0;
13078                             tokadd(c);
13079                         } while ((c = nextc()) != -1);
13080                     }
13081                     pushback(c);
13082                     tokfix();
13083                     if (toklen() == start) {
13084                         no_digits();
13085                     }
13086                     else if (nondigit) goto trailing_uc;
13087                     set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13088                     return tINTEGER;
13089                 }
13090                 if (c == '_') {
13091                     /* 0_0 */
13092                     goto octal_number;
13093                 }
13094                 if (c == 'o' || c == 'O') {
13095                     /* prefixed octal */
13096                     c = nextc();
13097                     if (c == -1 || c == '_' || !ISDIGIT(c)) {
13098                         no_digits();
13099                     }
13100                 }
13101                 if (c >= '0' && c <= '7') {
13102                     /* octal */
13103                   octal_number:
13104                     do {
13105                         if (c == '_') {
13106                             if (nondigit) break;
13107                             nondigit = c;
13108                             continue;
13109                         }
13110                         if (c < '0' || c > '9') break;
13111                         if (c > '7') goto invalid_octal;
13112                         nondigit = 0;
13113                         tokadd(c);
13114                     } while ((c = nextc()) != -1);
13115                     if (toklen() > start) {
13116                         pushback(c);
13117                         tokfix();
13118                         if (nondigit) goto trailing_uc;
13119                         set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
13120                         return tINTEGER;
13121                     }
13122                     if (nondigit) {
13123                         pushback(c);
13124                         goto trailing_uc;
13125                     }
13126                 }
13127                 if (c > '7' && c <= '9') {
13128                   invalid_octal:
13129                     yyerror("Invalid octal digit");
13130                 }
13131                 else if (c == '.' || c == 'e' || c == 'E') {
13132                     tokadd('0');
13133                 }
13134                 else {
13135                     pushback(c);
13136                     set_yylval_literal(INT2FIX(0));
13137                     return tINTEGER;
13138                 }
13139             }
13140 
13141             for (;;) {
13142                 switch (c) {
13143                   case '0': case '1': case '2': case '3': case '4':
13144                   case '5': case '6': case '7': case '8': case '9':
13145                     nondigit = 0;
13146                     tokadd(c);
13147                     break;
13148 
13149                   case '.':
13150                     if (nondigit) goto trailing_uc;
13151                     if (seen_point || seen_e) {
13152                         goto decode_num;
13153                     }
13154                     else {
13155                         int c0 = nextc();
13156                         if (c0 == -1 || !ISDIGIT(c0)) {
13157                             pushback(c0);
13158                             goto decode_num;
13159                         }
13160                         c = c0;
13161                     }
13162                     tokadd('.');
13163                     tokadd(c);
13164                     is_float++;
13165                     seen_point++;
13166                     nondigit = 0;
13167                     break;
13168 
13169                   case 'e':
13170                   case 'E':
13171                     if (nondigit) {
13172                         pushback(c);
13173                         c = nondigit;
13174                         goto decode_num;
13175                     }
13176                     if (seen_e) {
13177                         goto decode_num;
13178                     }
13179                     tokadd(c);
13180                     seen_e++;
13181                     is_float++;
13182                     nondigit = c;
13183                     c = nextc();
13184                     if (c != '-' && c != '+') continue;
13185                     tokadd(c);
13186                     nondigit = c;
13187                     break;
13188 
13189                   case '_':     /* `_' in number just ignored */
13190                     if (nondigit) goto decode_num;
13191                     nondigit = c;
13192                     break;
13193 
13194                   default:
13195                     goto decode_num;
13196                 }
13197                 c = nextc();
13198             }
13199 
13200           decode_num:
13201             pushback(c);
13202             if (nondigit) {
13203                 char tmp[30];
13204               trailing_uc:
13205                 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13206                 yyerror(tmp);
13207             }
13208             tokfix();
13209             if (is_float) {
13210                 double d = strtod(tok(), 0);
13211                 if (errno == ERANGE) {
13212                     rb_warningS("Float %s out of range", tok());
13213                     errno = 0;
13214                 }
13215                 set_yylval_literal(DBL2NUM(d));
13216                 return tFLOAT;
13217             }
13218             set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
13219             return tINTEGER;
13220         }
13221 
13222       case ')':
13223       case ']':
13224         paren_nest--;
13225       case '}':
13226         COND_LEXPOP();
13227         CMDARG_LEXPOP();
13228         if (c == ')')
13229             lex_state = EXPR_ENDFN;
13230         else
13231             lex_state = EXPR_ENDARG;
13232         if (c == '}') {
13233             if (!brace_nest--) c = tSTRING_DEND;
13234         }
13235         return c;
13236 
13237       case ':':
13238         c = nextc();
13239         if (c == ':') {
13240             if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
13241                 lex_state = EXPR_BEG;
13242                 return tCOLON3;
13243             }
13244             lex_state = EXPR_DOT;
13245             return tCOLON2;
13246         }
13247         if (IS_END() || ISSPACE(c)) {
13248             pushback(c);
13249             warn_balanced(":", "symbol literal");
13250             lex_state = EXPR_BEG;
13251             return ':';
13252         }
13253         switch (c) {
13254           case '\'':
13255             lex_strterm = NEW_STRTERM(str_ssym, c, 0);
13256             break;
13257           case '"':
13258             lex_strterm = NEW_STRTERM(str_dsym, c, 0);
13259             break;
13260           default:
13261             pushback(c);
13262             break;
13263         }
13264         lex_state = EXPR_FNAME;
13265         return tSYMBEG;
13266 
13267       case '/':
13268         if (IS_lex_state(EXPR_BEG_ANY)) {
13269             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13270             return tREGEXP_BEG;
13271         }
13272         if ((c = nextc()) == '=') {
13273             set_yylval_id('/');
13274             lex_state = EXPR_BEG;
13275             return tOP_ASGN;
13276         }
13277         pushback(c);
13278         if (IS_SPCARG(c)) {
13279             (void)arg_ambiguous();
13280             lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13281             return tREGEXP_BEG;
13282         }
13283         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13284         warn_balanced("/", "regexp literal");
13285         return '/';
13286 
13287       case '^':
13288         if ((c = nextc()) == '=') {
13289             set_yylval_id('^');
13290             lex_state = EXPR_BEG;
13291             return tOP_ASGN;
13292         }
13293         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13294         pushback(c);
13295         return '^';
13296 
13297       case ';':
13298         lex_state = EXPR_BEG;
13299         command_start = TRUE;
13300         return ';';
13301 
13302       case ',':
13303         lex_state = EXPR_BEG;
13304         return ',';
13305 
13306       case '~':
13307         if (IS_AFTER_OPERATOR()) {
13308             if ((c = nextc()) != '@') {
13309                 pushback(c);
13310             }
13311             lex_state = EXPR_ARG;
13312         }
13313         else {
13314             lex_state = EXPR_BEG;
13315         }
13316         return '~';
13317 
13318       case '(':
13319         if (IS_BEG()) {
13320             c = tLPAREN;
13321         }
13322         else if (IS_SPCARG(-1)) {
13323             c = tLPAREN_ARG;
13324         }
13325         paren_nest++;
13326         COND_PUSH(0);
13327         CMDARG_PUSH(0);
13328         lex_state = EXPR_BEG;
13329         return c;
13330 
13331       case '[':
13332         paren_nest++;
13333         if (IS_AFTER_OPERATOR()) {
13334             lex_state = EXPR_ARG;
13335             if ((c = nextc()) == ']') {
13336                 if ((c = nextc()) == '=') {
13337                     return tASET;
13338                 }
13339                 pushback(c);
13340                 return tAREF;
13341             }
13342             pushback(c);
13343             return '[';
13344         }
13345         else if (IS_BEG()) {
13346             c = tLBRACK;
13347         }
13348         else if (IS_ARG() && space_seen) {
13349             c = tLBRACK;
13350         }
13351         lex_state = EXPR_BEG;
13352         COND_PUSH(0);
13353         CMDARG_PUSH(0);
13354         return c;
13355 
13356       case '{':
13357         ++brace_nest;
13358         if (lpar_beg && lpar_beg == paren_nest) {
13359             lex_state = EXPR_BEG;
13360             lpar_beg = 0;
13361             --paren_nest;
13362             COND_PUSH(0);
13363             CMDARG_PUSH(0);
13364             return tLAMBEG;
13365         }
13366         if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
13367             c = '{';          /* block (primary) */
13368         else if (IS_lex_state(EXPR_ENDARG))
13369             c = tLBRACE_ARG;  /* block (expr) */
13370         else
13371             c = tLBRACE;      /* hash */
13372         COND_PUSH(0);
13373         CMDARG_PUSH(0);
13374         lex_state = EXPR_BEG;
13375         if (c != tLBRACE) command_start = TRUE;
13376         return c;
13377 
13378       case '\\':
13379         c = nextc();
13380         if (c == '\n') {
13381             space_seen = 1;
13382 #ifdef RIPPER
13383             ripper_dispatch_scan_event(parser, tSP);
13384 #endif
13385             goto retry; /* skip \\n */
13386         }
13387         pushback(c);
13388         return '\\';
13389 
13390       case '%':
13391         if (IS_lex_state(EXPR_BEG_ANY)) {
13392             int term;
13393             int paren;
13394 
13395             c = nextc();
13396           quotation:
13397             if (c == -1 || !ISALNUM(c)) {
13398                 term = c;
13399                 c = 'Q';
13400             }
13401             else {
13402                 term = nextc();
13403                 if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
13404                     yyerror("unknown type of %string");
13405                     return 0;
13406                 }
13407             }
13408             if (c == -1 || term == -1) {
13409                 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13410                 return 0;
13411             }
13412             paren = term;
13413             if (term == '(') term = ')';
13414             else if (term == '[') term = ']';
13415             else if (term == '{') term = '}';
13416             else if (term == '<') term = '>';
13417             else paren = 0;
13418 
13419             switch (c) {
13420               case 'Q':
13421                 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13422                 return tSTRING_BEG;
13423 
13424               case 'q':
13425                 lex_strterm = NEW_STRTERM(str_squote, term, paren);
13426                 return tSTRING_BEG;
13427 
13428               case 'W':
13429                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
13430                 do {c = nextc();} while (ISSPACE(c));
13431                 pushback(c);
13432                 return tWORDS_BEG;
13433 
13434               case 'w':
13435                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
13436                 do {c = nextc();} while (ISSPACE(c));
13437                 pushback(c);
13438                 return tQWORDS_BEG;
13439 
13440               case 'I':
13441                 lex_strterm = NEW_STRTERM(str_dword, term, paren);
13442                 do {c = nextc();} while (ISSPACE(c));
13443                 pushback(c);
13444                 return tSYMBOLS_BEG;
13445 
13446               case 'i':
13447                 lex_strterm = NEW_STRTERM(str_sword, term, paren);
13448                 do {c = nextc();} while (ISSPACE(c));
13449                 pushback(c);
13450                 return tQSYMBOLS_BEG;
13451 
13452               case 'x':
13453                 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13454                 return tXSTRING_BEG;
13455 
13456               case 'r':
13457                 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13458                 return tREGEXP_BEG;
13459 
13460               case 's':
13461                 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13462                 lex_state = EXPR_FNAME;
13463                 return tSYMBEG;
13464 
13465               default:
13466                 yyerror("unknown type of %string");
13467                 return 0;
13468             }
13469         }
13470         if ((c = nextc()) == '=') {
13471             set_yylval_id('%');
13472             lex_state = EXPR_BEG;
13473             return tOP_ASGN;
13474         }
13475         if (IS_SPCARG(c)) {
13476             goto quotation;
13477         }
13478         lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13479         pushback(c);
13480         warn_balanced("%%", "string literal");
13481         return '%';
13482 
13483       case '$':
13484         lex_state = EXPR_END;
13485         newtok();
13486         c = nextc();
13487         switch (c) {
13488           case '_':             /* $_: last read line string */
13489             c = nextc();
13490             if (parser_is_identchar()) {
13491                 tokadd('$');
13492                 tokadd('_');
13493                 break;
13494             }
13495             pushback(c);
13496             c = '_';
13497             /* fall through */
13498           case '~':             /* $~: match-data */
13499           case '*':             /* $*: argv */
13500           case '$':             /* $$: pid */
13501           case '?':             /* $?: last status */
13502           case '!':             /* $!: error string */
13503           case '@':             /* $@: error position */
13504           case '/':             /* $/: input record separator */
13505           case '\\':            /* $\: output record separator */
13506           case ';':             /* $;: field separator */
13507           case ',':             /* $,: output field separator */
13508           case '.':             /* $.: last read line number */
13509           case '=':             /* $=: ignorecase */
13510           case ':':             /* $:: load path */
13511           case '<':             /* $<: reading filename */
13512           case '>':             /* $>: default output handle */
13513           case '\"':            /* $": already loaded files */
13514             tokadd('$');
13515             tokadd(c);
13516             tokfix();
13517             set_yylval_name(rb_intern(tok()));
13518             return tGVAR;
13519 
13520           case '-':
13521             tokadd('$');
13522             tokadd(c);
13523             c = nextc();
13524             if (parser_is_identchar()) {
13525                 if (tokadd_mbchar(c) == -1) return 0;
13526             }
13527             else {
13528                 pushback(c);
13529             }
13530           gvar:
13531             tokfix();
13532             set_yylval_name(rb_intern(tok()));
13533             return tGVAR;
13534 
13535           case '&':             /* $&: last match */
13536           case '`':             /* $`: string before last match */
13537           case '\'':            /* $': string after last match */
13538           case '+':             /* $+: string matches last paren. */
13539             if (IS_lex_state_for(last_state, EXPR_FNAME)) {
13540                 tokadd('$');
13541                 tokadd(c);
13542                 goto gvar;
13543             }
13544             set_yylval_node(NEW_BACK_REF(c));
13545             return tBACK_REF;
13546 
13547           case '1': case '2': case '3':
13548           case '4': case '5': case '6':
13549           case '7': case '8': case '9':
13550             tokadd('$');
13551             do {
13552                 tokadd(c);
13553                 c = nextc();
13554             } while (c != -1 && ISDIGIT(c));
13555             pushback(c);
13556             if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
13557             tokfix();
13558             set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
13559             return tNTH_REF;
13560 
13561           default:
13562             if (!parser_is_identchar()) {
13563                 pushback(c);
13564                 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
13565                 return 0;
13566             }
13567           case '0':
13568             tokadd('$');
13569         }
13570         break;
13571 
13572       case '@':
13573         c = nextc();
13574         newtok();
13575         tokadd('@');
13576         if (c == '@') {
13577             tokadd('@');
13578             c = nextc();
13579         }
13580         if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
13581             pushback(c);
13582             if (tokidx == 1) {
13583                 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
13584             }
13585             else {
13586                 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
13587             }
13588             return 0;
13589         }
13590         break;
13591 
13592       case '_':
13593         if (was_bol() && whole_match_p("__END__", 7, 0)) {
13594             ruby__end__seen = 1;
13595             parser->eofp = Qtrue;
13596 #ifndef RIPPER
13597             return -1;
13598 #else
13599             lex_goto_eol(parser);
13600             ripper_dispatch_scan_event(parser, k__END__);
13601             return 0;
13602 #endif
13603         }
13604         newtok();
13605         break;
13606 
13607       default:
13608         if (!parser_is_identchar()) {
13609             rb_compile_error(PARSER_ARG  "Invalid char `\\x%02X' in expression", c);
13610             goto retry;
13611         }
13612 
13613         newtok();
13614         break;
13615     }
13616 
13617     mb = ENC_CODERANGE_7BIT;
13618     do {
13619         if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
13620         if (tokadd_mbchar(c) == -1) return 0;
13621         c = nextc();
13622     } while (parser_is_identchar());
13623     switch (tok()[0]) {
13624       case '@': case '$':
13625         pushback(c);
13626         break;
13627       default:
13628         if ((c == '!' || c == '?') && !peek('=')) {
13629             tokadd(c);
13630         }
13631         else {
13632             pushback(c);
13633         }
13634     }
13635     tokfix();
13636 
13637     {
13638         int result = 0;
13639 
13640         last_state = lex_state;
13641         switch (tok()[0]) {
13642           case '$':
13643             lex_state = EXPR_END;
13644             result = tGVAR;
13645             break;
13646           case '@':
13647             lex_state = EXPR_END;
13648             if (tok()[1] == '@')
13649                 result = tCVAR;
13650             else
13651                 result = tIVAR;
13652             break;
13653 
13654           default:
13655             if (toklast() == '!' || toklast() == '?') {
13656                 result = tFID;
13657             }
13658             else {
13659                 if (IS_lex_state(EXPR_FNAME)) {
13660                     if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
13661                         (!peek('=') || (peek_n('>', 1)))) {
13662                         result = tIDENTIFIER;
13663                         tokadd(c);
13664                         tokfix();
13665                     }
13666                     else {
13667                         pushback(c);
13668                     }
13669                 }
13670                 if (result == 0 && ISUPPER(tok()[0])) {
13671                     result = tCONSTANT;
13672                 }
13673                 else {
13674                     result = tIDENTIFIER;
13675                 }
13676             }
13677 
13678             if (IS_LABEL_POSSIBLE()) {
13679                 if (IS_LABEL_SUFFIX(0)) {
13680                     lex_state = EXPR_BEG;
13681                     nextc();
13682                     set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
13683                     return tLABEL;
13684                 }
13685             }
13686             if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
13687                 const struct kwtable *kw;
13688 
13689                 /* See if it is a reserved word.  */
13690                 kw = rb_reserved_word(tok(), toklen());
13691                 if (kw) {
13692                     enum lex_state_e state = lex_state;
13693                     lex_state = kw->state;
13694                     if (state == EXPR_FNAME) {
13695                         set_yylval_name(rb_intern(kw->name));
13696                         return kw->id[0];
13697                     }
13698                     if (lex_state == EXPR_BEG) {
13699                         command_start = TRUE;
13700                     }
13701                     if (kw->id[0] == keyword_do) {
13702                         if (lpar_beg && lpar_beg == paren_nest) {
13703                             lpar_beg = 0;
13704                             --paren_nest;
13705                             return keyword_do_LAMBDA;
13706                         }
13707                         if (COND_P()) return keyword_do_cond;
13708                         if (CMDARG_P() && state != EXPR_CMDARG)
13709                             return keyword_do_block;
13710                         if (state & (EXPR_BEG | EXPR_ENDARG))
13711                             return keyword_do_block;
13712                         return keyword_do;
13713                     }
13714                     if (state & (EXPR_BEG | EXPR_VALUE))
13715                         return kw->id[0];
13716                     else {
13717                         if (kw->id[0] != kw->id[1])
13718                             lex_state = EXPR_BEG;
13719                         return kw->id[1];
13720                     }
13721                 }
13722             }
13723 
13724             if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
13725                 if (cmd_state) {
13726                     lex_state = EXPR_CMDARG;
13727                 }
13728                 else {
13729                     lex_state = EXPR_ARG;
13730                 }
13731             }
13732             else if (lex_state == EXPR_FNAME) {
13733                 lex_state = EXPR_ENDFN;
13734             }
13735             else {
13736                 lex_state = EXPR_END;
13737             }
13738         }
13739         {
13740             ID ident = TOK_INTERN(!ENC_SINGLE(mb));
13741 
13742             set_yylval_name(ident);
13743             if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
13744                 is_local_id(ident) && lvar_defined(ident)) {
13745                 lex_state = EXPR_END;
13746             }
13747         }
13748         return result;
13749     }
13750 }
13751 
13752 #if YYPURE
13753 static int
13754 yylex(void *lval, void *p)
13755 #else
13756 yylex(void *p)
13757 #endif
13758 {
13759     struct parser_params *parser = (struct parser_params*)p;
13760     int t;
13761 
13762 #if YYPURE
13763     parser->parser_yylval = lval;
13764     parser->parser_yylval->val = Qundef;
13765 #endif
13766     t = parser_yylex(parser);
13767 #ifdef RIPPER
13768     if (!NIL_P(parser->delayed)) {
13769         ripper_dispatch_delayed_token(parser, t);
13770         return t;
13771     }
13772     if (t != 0)
13773         ripper_dispatch_scan_event(parser, t);
13774 #endif
13775 
13776     return t;
13777 }
13778 
13779 #ifndef RIPPER
13780 static NODE*
13781 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
13782 {
13783     NODE *n = (rb_node_newnode)(type, a0, a1, a2);
13784     nd_set_line(n, ruby_sourceline);
13785     return n;
13786 }
13787 
13788 static enum node_type
13789 nodetype(NODE *node)                    /* for debug */
13790 {
13791     return (enum node_type)nd_type(node);
13792 }
13793 
13794 static int
13795 nodeline(NODE *node)
13796 {
13797     return nd_line(node);
13798 }
13799 
13800 static NODE*
13801 newline_node(NODE *node)
13802 {
13803     if (node) {
13804         node = remove_begin(node);
13805         node->flags |= NODE_FL_NEWLINE;
13806     }
13807     return node;
13808 }
13809 
13810 static void
13811 fixpos(NODE *node, NODE *orig)
13812 {
13813     if (!node) return;
13814     if (!orig) return;
13815     if (orig == (NODE*)1) return;
13816     nd_set_line(node, nd_line(orig));
13817 }
13818 
13819 static void
13820 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
13821 {
13822     rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
13823 }
13824 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
13825 
13826 static void
13827 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
13828 {
13829     rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
13830 }
13831 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
13832 
13833 static NODE*
13834 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
13835 {
13836     NODE *end, *h = head, *nd;
13837 
13838     if (tail == 0) return head;
13839 
13840     if (h == 0) return tail;
13841     switch (nd_type(h)) {
13842       case NODE_LIT:
13843       case NODE_STR:
13844       case NODE_SELF:
13845       case NODE_TRUE:
13846       case NODE_FALSE:
13847       case NODE_NIL:
13848         parser_warning(h, "unused literal ignored");
13849         return tail;
13850       default:
13851         h = end = NEW_BLOCK(head);
13852         end->nd_end = end;
13853         fixpos(end, head);
13854         head = end;
13855         break;
13856       case NODE_BLOCK:
13857         end = h->nd_end;
13858         break;
13859     }
13860 
13861     nd = end->nd_head;
13862     switch (nd_type(nd)) {
13863       case NODE_RETURN:
13864       case NODE_BREAK:
13865       case NODE_NEXT:
13866       case NODE_REDO:
13867       case NODE_RETRY:
13868         if (RTEST(ruby_verbose)) {
13869             parser_warning(tail, "statement not reached");
13870         }
13871         break;
13872 
13873       default:
13874         break;
13875     }
13876 
13877     if (nd_type(tail) != NODE_BLOCK) {
13878         tail = NEW_BLOCK(tail);
13879         tail->nd_end = tail;
13880     }
13881     end->nd_next = tail;
13882     h->nd_end = tail->nd_end;
13883     return head;
13884 }
13885 
13886 /* append item to the list */
13887 static NODE*
13888 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
13889 {
13890     NODE *last;
13891 
13892     if (list == 0) return NEW_LIST(item);
13893     if (list->nd_next) {
13894         last = list->nd_next->nd_end;
13895     }
13896     else {
13897         last = list;
13898     }
13899 
13900     list->nd_alen += 1;
13901     last->nd_next = NEW_LIST(item);
13902     list->nd_next->nd_end = last->nd_next;
13903     return list;
13904 }
13905 
13906 /* concat two lists */
13907 static NODE*
13908 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
13909 {
13910     NODE *last;
13911 
13912     if (head->nd_next) {
13913         last = head->nd_next->nd_end;
13914     }
13915     else {
13916         last = head;
13917     }
13918 
13919     head->nd_alen += tail->nd_alen;
13920     last->nd_next = tail;
13921     if (tail->nd_next) {
13922         head->nd_next->nd_end = tail->nd_next->nd_end;
13923     }
13924     else {
13925         head->nd_next->nd_end = tail;
13926     }
13927 
13928     return head;
13929 }
13930 
13931 static int
13932 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
13933 {
13934     if (NIL_P(tail)) return 1;
13935     if (!rb_enc_compatible(head, tail)) {
13936         compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
13937                       rb_enc_name(rb_enc_get(head)),
13938                       rb_enc_name(rb_enc_get(tail)));
13939         rb_str_resize(head, 0);
13940         rb_str_resize(tail, 0);
13941         return 0;
13942     }
13943     rb_str_buf_append(head, tail);
13944     return 1;
13945 }
13946 
13947 /* concat two string literals */
13948 static NODE *
13949 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
13950 {
13951     enum node_type htype;
13952     NODE *headlast;
13953     VALUE lit;
13954 
13955     if (!head) return tail;
13956     if (!tail) return head;
13957 
13958     htype = nd_type(head);
13959     if (htype == NODE_EVSTR) {
13960         NODE *node = NEW_DSTR(Qnil);
13961         head = list_append(node, head);
13962         htype = NODE_DSTR;
13963     }
13964     switch (nd_type(tail)) {
13965       case NODE_STR:
13966         if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
13967             nd_type(headlast) == NODE_STR) {
13968             htype = NODE_STR;
13969             lit = headlast->nd_lit;
13970         }
13971         else {
13972             lit = head->nd_lit;
13973         }
13974         if (htype == NODE_STR) {
13975             if (!literal_concat0(parser, lit, tail->nd_lit)) {
13976               error:
13977                 rb_gc_force_recycle((VALUE)head);
13978                 rb_gc_force_recycle((VALUE)tail);
13979                 return 0;
13980             }
13981             rb_gc_force_recycle((VALUE)tail);
13982         }
13983         else {
13984             list_append(head, tail);
13985         }
13986         break;
13987 
13988       case NODE_DSTR:
13989         if (htype == NODE_STR) {
13990             if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
13991                 goto error;
13992             tail->nd_lit = head->nd_lit;
13993             rb_gc_force_recycle((VALUE)head);
13994             head = tail;
13995         }
13996         else if (NIL_P(tail->nd_lit)) {
13997           append:
13998             head->nd_alen += tail->nd_alen - 1;
13999             head->nd_next->nd_end->nd_next = tail->nd_next;
14000             head->nd_next->nd_end = tail->nd_next->nd_end;
14001             rb_gc_force_recycle((VALUE)tail);
14002         }
14003         else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14004                  nd_type(headlast) == NODE_STR) {
14005             lit = headlast->nd_lit;
14006             if (!literal_concat0(parser, lit, tail->nd_lit))
14007                 goto error;
14008             tail->nd_lit = Qnil;
14009             goto append;
14010         }
14011         else {
14012             nd_set_type(tail, NODE_ARRAY);
14013             tail->nd_head = NEW_STR(tail->nd_lit);
14014             list_concat(head, tail);
14015         }
14016         break;
14017 
14018       case NODE_EVSTR:
14019         if (htype == NODE_STR) {
14020             nd_set_type(head, NODE_DSTR);
14021             head->nd_alen = 1;
14022         }
14023         list_append(head, tail);
14024         break;
14025     }
14026     return head;
14027 }
14028 
14029 static NODE *
14030 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14031 {
14032     if (nd_type(node) == NODE_EVSTR) {
14033         node = list_append(NEW_DSTR(Qnil), node);
14034     }
14035     return node;
14036 }
14037 
14038 static NODE *
14039 new_evstr_gen(struct parser_params *parser, NODE *node)
14040 {
14041     NODE *head = node;
14042 
14043     if (node) {
14044         switch (nd_type(node)) {
14045           case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14046             return node;
14047         }
14048     }
14049     return NEW_EVSTR(head);
14050 }
14051 
14052 static NODE *
14053 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14054 {
14055     value_expr(recv);
14056     value_expr(arg1);
14057     return NEW_CALL(recv, id, NEW_LIST(arg1));
14058 }
14059 
14060 static NODE *
14061 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14062 {
14063     value_expr(recv);
14064     return NEW_CALL(recv, id, 0);
14065 }
14066 
14067 static NODE*
14068 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14069 {
14070     value_expr(node1);
14071     value_expr(node2);
14072     if (node1) {
14073         switch (nd_type(node1)) {
14074           case NODE_DREGX:
14075           case NODE_DREGX_ONCE:
14076             return NEW_MATCH2(node1, node2);
14077 
14078           case NODE_LIT:
14079             if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
14080                 return NEW_MATCH2(node1, node2);
14081             }
14082         }
14083     }
14084 
14085     if (node2) {
14086         switch (nd_type(node2)) {
14087           case NODE_DREGX:
14088           case NODE_DREGX_ONCE:
14089             return NEW_MATCH3(node2, node1);
14090 
14091           case NODE_LIT:
14092             if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
14093                 return NEW_MATCH3(node2, node1);
14094             }
14095         }
14096     }
14097 
14098     return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14099 }
14100 
14101 static NODE*
14102 gettable_gen(struct parser_params *parser, ID id)
14103 {
14104     switch (id) {
14105       case keyword_self:
14106         return NEW_SELF();
14107       case keyword_nil:
14108         return NEW_NIL();
14109       case keyword_true:
14110         return NEW_TRUE();
14111       case keyword_false:
14112         return NEW_FALSE();
14113       case keyword__FILE__:
14114         return NEW_STR(rb_external_str_new_with_enc(ruby_sourcefile, strlen(ruby_sourcefile),
14115                                                     rb_filesystem_encoding()));
14116       case keyword__LINE__:
14117         return NEW_LIT(INT2FIX(tokline));
14118       case keyword__ENCODING__:
14119         return NEW_LIT(rb_enc_from_encoding(current_enc));
14120     }
14121     switch (id_type(id)) {
14122       case ID_LOCAL:
14123         if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14124         if (local_id(id)) return NEW_LVAR(id);
14125         /* method call without arguments */
14126         return NEW_VCALL(id);
14127       case ID_GLOBAL:
14128         return NEW_GVAR(id);
14129       case ID_INSTANCE:
14130         return NEW_IVAR(id);
14131       case ID_CONST:
14132         return NEW_CONST(id);
14133       case ID_CLASS:
14134         return NEW_CVAR(id);
14135     }
14136     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14137     return 0;
14138 }
14139 #else  /* !RIPPER */
14140 static int
14141 id_is_var_gen(struct parser_params *parser, ID id)
14142 {
14143     if (is_notop_id(id)) {
14144         switch (id & ID_SCOPE_MASK) {
14145           case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14146             return 1;
14147           case ID_LOCAL:
14148             if (dyna_in_block() && dvar_defined(id)) return 1;
14149             if (local_id(id)) return 1;
14150             /* method call without arguments */
14151             return 0;
14152         }
14153     }
14154     compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14155     return 0;
14156 }
14157 #endif /* !RIPPER */
14158 
14159 #if PARSER_DEBUG
14160 static const char *
14161 lex_state_name(enum lex_state_e state)
14162 {
14163     static const char names[][12] = {
14164         "EXPR_BEG",    "EXPR_END",    "EXPR_ENDARG", "EXPR_ENDFN",  "EXPR_ARG",
14165         "EXPR_CMDARG", "EXPR_MID",    "EXPR_FNAME",  "EXPR_DOT",    "EXPR_CLASS",
14166         "EXPR_VALUE",
14167     };
14168 
14169     if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
14170         return names[ffs(state)];
14171     return NULL;
14172 }
14173 #endif
14174 
14175 #ifdef RIPPER
14176 static VALUE
14177 assignable_gen(struct parser_params *parser, VALUE lhs)
14178 #else
14179 static NODE*
14180 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14181 #endif
14182 {
14183 #ifdef RIPPER
14184     ID id = get_id(lhs);
14185 # define assignable_result(x) get_value(lhs)
14186 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14187 #else
14188 # define assignable_result(x) (x)
14189 #endif
14190     if (!id) return assignable_result(0);
14191     switch (id) {
14192       case keyword_self:
14193         yyerror("Can't change the value of self");
14194         goto error;
14195       case keyword_nil:
14196         yyerror("Can't assign to nil");
14197         goto error;
14198       case keyword_true:
14199         yyerror("Can't assign to true");
14200         goto error;
14201       case keyword_false:
14202         yyerror("Can't assign to false");
14203         goto error;
14204       case keyword__FILE__:
14205         yyerror("Can't assign to __FILE__");
14206         goto error;
14207       case keyword__LINE__:
14208         yyerror("Can't assign to __LINE__");
14209         goto error;
14210       case keyword__ENCODING__:
14211         yyerror("Can't assign to __ENCODING__");
14212         goto error;
14213     }
14214     switch (id_type(id)) {
14215       case ID_LOCAL:
14216         if (dyna_in_block()) {
14217             if (dvar_curr(id)) {
14218                 return assignable_result(NEW_DASGN_CURR(id, val));
14219             }
14220             else if (dvar_defined(id)) {
14221                 return assignable_result(NEW_DASGN(id, val));
14222             }
14223             else if (local_id(id)) {
14224                 return assignable_result(NEW_LASGN(id, val));
14225             }
14226             else {
14227                 dyna_var(id);
14228                 return assignable_result(NEW_DASGN_CURR(id, val));
14229             }
14230         }
14231         else {
14232             if (!local_id(id)) {
14233                 local_var(id);
14234             }
14235             return assignable_result(NEW_LASGN(id, val));
14236         }
14237         break;
14238       case ID_GLOBAL:
14239         return assignable_result(NEW_GASGN(id, val));
14240       case ID_INSTANCE:
14241         return assignable_result(NEW_IASGN(id, val));
14242       case ID_CONST:
14243         if (!in_def && !in_single)
14244             return assignable_result(NEW_CDECL(id, val, 0));
14245         yyerror("dynamic constant assignment");
14246         break;
14247       case ID_CLASS:
14248         return assignable_result(NEW_CVASGN(id, val));
14249       default:
14250         compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
14251     }
14252   error:
14253     return assignable_result(0);
14254 #undef assignable_result
14255 #undef parser_yyerror
14256 }
14257 
14258 static int
14259 is_private_local_id(ID name)
14260 {
14261     VALUE s;
14262     if (name == idUScore) return 1;
14263     if (!is_local_id(name)) return 0;
14264     s = rb_id2str(name);
14265     if (!s) return 0;
14266     return RSTRING_PTR(s)[0] == '_';
14267 }
14268 
14269 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
14270 
14271 static ID
14272 shadowing_lvar_gen(struct parser_params *parser, ID name)
14273 {
14274     if (is_private_local_id(name)) return name;
14275     if (dyna_in_block()) {
14276         if (dvar_curr(name)) {
14277             yyerror("duplicated argument name");
14278         }
14279         else if (dvar_defined_get(name) || local_id(name)) {
14280             rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
14281             vtable_add(lvtbl->vars, name);
14282             if (lvtbl->used) {
14283                 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
14284             }
14285         }
14286     }
14287     else {
14288         if (local_id(name)) {
14289             yyerror("duplicated argument name");
14290         }
14291     }
14292     return name;
14293 }
14294 
14295 static void
14296 new_bv_gen(struct parser_params *parser, ID name)
14297 {
14298     if (!name) return;
14299     if (!is_local_id(name)) {
14300         compile_error(PARSER_ARG "invalid local variable - %s",
14301                       rb_id2name(name));
14302         return;
14303     }
14304     shadowing_lvar(name);
14305     dyna_var(name);
14306 }
14307 
14308 #ifndef RIPPER
14309 static NODE *
14310 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
14311 {
14312     if (recv && nd_type(recv) == NODE_SELF)
14313         recv = (NODE *)1;
14314     return NEW_ATTRASGN(recv, tASET, idx);
14315 }
14316 
14317 static void
14318 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14319 {
14320     if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
14321         compile_error(PARSER_ARG "both block arg and actual block given");
14322     }
14323 }
14324 
14325 ID
14326 rb_id_attrset(ID id)
14327 {
14328     id &= ~ID_SCOPE_MASK;
14329     id |= ID_ATTRSET;
14330     return id;
14331 }
14332 
14333 static NODE *
14334 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
14335 {
14336     if (recv && nd_type(recv) == NODE_SELF)
14337         recv = (NODE *)1;
14338     return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
14339 }
14340 
14341 static void
14342 rb_backref_error_gen(struct parser_params *parser, NODE *node)
14343 {
14344     switch (nd_type(node)) {
14345       case NODE_NTH_REF:
14346         compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
14347         break;
14348       case NODE_BACK_REF:
14349         compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
14350         break;
14351     }
14352 }
14353 
14354 static NODE *
14355 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14356 {
14357     if (!node2) return node1;
14358     switch (nd_type(node1)) {
14359       case NODE_BLOCK_PASS:
14360         if (node1->nd_head)
14361             node1->nd_head = arg_concat(node1->nd_head, node2);
14362         else
14363             node1->nd_head = NEW_LIST(node2);
14364         return node1;
14365       case NODE_ARGSPUSH:
14366         if (nd_type(node2) != NODE_ARRAY) break;
14367         node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
14368         nd_set_type(node1, NODE_ARGSCAT);
14369         return node1;
14370       case NODE_ARGSCAT:
14371         if (nd_type(node2) != NODE_ARRAY ||
14372             nd_type(node1->nd_body) != NODE_ARRAY) break;
14373         node1->nd_body = list_concat(node1->nd_body, node2);
14374         return node1;
14375     }
14376     return NEW_ARGSCAT(node1, node2);
14377 }
14378 
14379 static NODE *
14380 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14381 {
14382     if (!node1) return NEW_LIST(node2);
14383     switch (nd_type(node1))  {
14384       case NODE_ARRAY:
14385         return list_append(node1, node2);
14386       case NODE_BLOCK_PASS:
14387         node1->nd_head = arg_append(node1->nd_head, node2);
14388         return node1;
14389       case NODE_ARGSPUSH:
14390         node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
14391         nd_set_type(node1, NODE_ARGSCAT);
14392         return node1;
14393     }
14394     return NEW_ARGSPUSH(node1, node2);
14395 }
14396 
14397 static NODE *
14398 splat_array(NODE* node)
14399 {
14400     if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
14401     if (nd_type(node) == NODE_ARRAY) return node;
14402     return 0;
14403 }
14404 
14405 static NODE *
14406 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
14407 {
14408     if (!lhs) return 0;
14409 
14410     switch (nd_type(lhs)) {
14411       case NODE_GASGN:
14412       case NODE_IASGN:
14413       case NODE_IASGN2:
14414       case NODE_LASGN:
14415       case NODE_DASGN:
14416       case NODE_DASGN_CURR:
14417       case NODE_MASGN:
14418       case NODE_CDECL:
14419       case NODE_CVASGN:
14420         lhs->nd_value = rhs;
14421         break;
14422 
14423       case NODE_ATTRASGN:
14424       case NODE_CALL:
14425         lhs->nd_args = arg_append(lhs->nd_args, rhs);
14426         break;
14427 
14428       default:
14429         /* should not happen */
14430         break;
14431     }
14432 
14433     return lhs;
14434 }
14435 
14436 static int
14437 value_expr_gen(struct parser_params *parser, NODE *node)
14438 {
14439     int cond = 0;
14440 
14441     if (!node) {
14442         rb_warning0("empty expression");
14443     }
14444     while (node) {
14445         switch (nd_type(node)) {
14446           case NODE_DEFN:
14447           case NODE_DEFS:
14448             parser_warning(node, "void value expression");
14449             return FALSE;
14450 
14451           case NODE_RETURN:
14452           case NODE_BREAK:
14453           case NODE_NEXT:
14454           case NODE_REDO:
14455           case NODE_RETRY:
14456             if (!cond) yyerror("void value expression");
14457             /* or "control never reach"? */
14458             return FALSE;
14459 
14460           case NODE_BLOCK:
14461             while (node->nd_next) {
14462                 node = node->nd_next;
14463             }
14464             node = node->nd_head;
14465             break;
14466 
14467           case NODE_BEGIN:
14468             node = node->nd_body;
14469             break;
14470 
14471           case NODE_IF:
14472             if (!node->nd_body) {
14473                 node = node->nd_else;
14474                 break;
14475             }
14476             else if (!node->nd_else) {
14477                 node = node->nd_body;
14478                 break;
14479             }
14480             if (!value_expr(node->nd_body)) return FALSE;
14481             node = node->nd_else;
14482             break;
14483 
14484           case NODE_AND:
14485           case NODE_OR:
14486             cond = 1;
14487             node = node->nd_2nd;
14488             break;
14489 
14490           default:
14491             return TRUE;
14492         }
14493     }
14494 
14495     return TRUE;
14496 }
14497 
14498 static void
14499 void_expr_gen(struct parser_params *parser, NODE *node)
14500 {
14501     const char *useless = 0;
14502 
14503     if (!RTEST(ruby_verbose)) return;
14504 
14505     if (!node) return;
14506     switch (nd_type(node)) {
14507       case NODE_CALL:
14508         switch (node->nd_mid) {
14509           case '+':
14510           case '-':
14511           case '*':
14512           case '/':
14513           case '%':
14514           case tPOW:
14515           case tUPLUS:
14516           case tUMINUS:
14517           case '|':
14518           case '^':
14519           case '&':
14520           case tCMP:
14521           case '>':
14522           case tGEQ:
14523           case '<':
14524           case tLEQ:
14525           case tEQ:
14526           case tNEQ:
14527             useless = rb_id2name(node->nd_mid);
14528             break;
14529         }
14530         break;
14531 
14532       case NODE_LVAR:
14533       case NODE_DVAR:
14534       case NODE_GVAR:
14535       case NODE_IVAR:
14536       case NODE_CVAR:
14537       case NODE_NTH_REF:
14538       case NODE_BACK_REF:
14539         useless = "a variable";
14540         break;
14541       case NODE_CONST:
14542         useless = "a constant";
14543         break;
14544       case NODE_LIT:
14545       case NODE_STR:
14546       case NODE_DSTR:
14547       case NODE_DREGX:
14548       case NODE_DREGX_ONCE:
14549         useless = "a literal";
14550         break;
14551       case NODE_COLON2:
14552       case NODE_COLON3:
14553         useless = "::";
14554         break;
14555       case NODE_DOT2:
14556         useless = "..";
14557         break;
14558       case NODE_DOT3:
14559         useless = "...";
14560         break;
14561       case NODE_SELF:
14562         useless = "self";
14563         break;
14564       case NODE_NIL:
14565         useless = "nil";
14566         break;
14567       case NODE_TRUE:
14568         useless = "true";
14569         break;
14570       case NODE_FALSE:
14571         useless = "false";
14572         break;
14573       case NODE_DEFINED:
14574         useless = "defined?";
14575         break;
14576     }
14577 
14578     if (useless) {
14579         int line = ruby_sourceline;
14580 
14581         ruby_sourceline = nd_line(node);
14582         rb_warnS("possibly useless use of %s in void context", useless);
14583         ruby_sourceline = line;
14584     }
14585 }
14586 
14587 static void
14588 void_stmts_gen(struct parser_params *parser, NODE *node)
14589 {
14590     if (!RTEST(ruby_verbose)) return;
14591     if (!node) return;
14592     if (nd_type(node) != NODE_BLOCK) return;
14593 
14594     for (;;) {
14595         if (!node->nd_next) return;
14596         void_expr0(node->nd_head);
14597         node = node->nd_next;
14598     }
14599 }
14600 
14601 static NODE *
14602 remove_begin(NODE *node)
14603 {
14604     NODE **n = &node, *n1 = node;
14605     while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
14606         *n = n1 = n1->nd_body;
14607     }
14608     return node;
14609 }
14610 
14611 static void
14612 reduce_nodes_gen(struct parser_params *parser, NODE **body)
14613 {
14614     NODE *node = *body;
14615 
14616     if (!node) {
14617         *body = NEW_NIL();
14618         return;
14619     }
14620 #define subnodes(n1, n2) \
14621     ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
14622      (!node->n2) ? (body = &node->n1, 1) : \
14623      (reduce_nodes(&node->n1), body = &node->n2, 1))
14624 
14625     while (node) {
14626         int newline = (int)(node->flags & NODE_FL_NEWLINE);
14627         switch (nd_type(node)) {
14628           end:
14629           case NODE_NIL:
14630             *body = 0;
14631             return;
14632           case NODE_RETURN:
14633             *body = node = node->nd_stts;
14634             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14635             continue;
14636           case NODE_BEGIN:
14637             *body = node = node->nd_body;
14638             if (newline && node) node->flags |= NODE_FL_NEWLINE;
14639             continue;
14640           case NODE_BLOCK:
14641             body = &node->nd_end->nd_head;
14642             break;
14643           case NODE_IF:
14644             if (subnodes(nd_body, nd_else)) break;
14645             return;
14646           case NODE_CASE:
14647             body = &node->nd_body;
14648             break;
14649           case NODE_WHEN:
14650             if (!subnodes(nd_body, nd_next)) goto end;
14651             break;
14652           case NODE_ENSURE:
14653             if (!subnodes(nd_head, nd_resq)) goto end;
14654             break;
14655           case NODE_RESCUE:
14656             if (node->nd_else) {
14657                 body = &node->nd_resq;
14658                 break;
14659             }
14660             if (!subnodes(nd_head, nd_resq)) goto end;
14661             break;
14662           default:
14663             return;
14664         }
14665         node = *body;
14666         if (newline && node) node->flags |= NODE_FL_NEWLINE;
14667     }
14668 
14669 #undef subnodes
14670 }
14671 
14672 static int
14673 is_static_content(NODE *node)
14674 {
14675     if (!node) return 1;
14676     switch (nd_type(node)) {
14677       case NODE_HASH:
14678         if (!(node = node->nd_head)) break;
14679       case NODE_ARRAY:
14680         do {
14681             if (!is_static_content(node->nd_head)) return 0;
14682         } while ((node = node->nd_next) != 0);
14683       case NODE_LIT:
14684       case NODE_STR:
14685       case NODE_NIL:
14686       case NODE_TRUE:
14687       case NODE_FALSE:
14688       case NODE_ZARRAY:
14689         break;
14690       default:
14691         return 0;
14692     }
14693     return 1;
14694 }
14695 
14696 static int
14697 assign_in_cond(struct parser_params *parser, NODE *node)
14698 {
14699     switch (nd_type(node)) {
14700       case NODE_MASGN:
14701         yyerror("multiple assignment in conditional");
14702         return 1;
14703 
14704       case NODE_LASGN:
14705       case NODE_DASGN:
14706       case NODE_DASGN_CURR:
14707       case NODE_GASGN:
14708       case NODE_IASGN:
14709         break;
14710 
14711       default:
14712         return 0;
14713     }
14714 
14715     if (!node->nd_value) return 1;
14716     if (is_static_content(node->nd_value)) {
14717         /* reports always */
14718         parser_warn(node->nd_value, "found = in conditional, should be ==");
14719     }
14720     return 1;
14721 }
14722 
14723 static void
14724 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14725 {
14726     if (!e_option_supplied(parser)) parser_warn(node, str);
14727 }
14728 
14729 static void
14730 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
14731 {
14732     if (!e_option_supplied(parser)) parser_warning(node, str);
14733 }
14734 
14735 static void
14736 fixup_nodes(NODE **rootnode)
14737 {
14738     NODE *node, *next, *head;
14739 
14740     for (node = *rootnode; node; node = next) {
14741         enum node_type type;
14742         VALUE val;
14743 
14744         next = node->nd_next;
14745         head = node->nd_head;
14746         rb_gc_force_recycle((VALUE)node);
14747         *rootnode = next;
14748         switch (type = nd_type(head)) {
14749           case NODE_DOT2:
14750           case NODE_DOT3:
14751             val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
14752                                type == NODE_DOT3);
14753             rb_gc_force_recycle((VALUE)head->nd_beg);
14754             rb_gc_force_recycle((VALUE)head->nd_end);
14755             nd_set_type(head, NODE_LIT);
14756             head->nd_lit = val;
14757             break;
14758           default:
14759             break;
14760         }
14761     }
14762 }
14763 
14764 static NODE *cond0(struct parser_params*,NODE*);
14765 
14766 static NODE*
14767 range_op(struct parser_params *parser, NODE *node)
14768 {
14769     enum node_type type;
14770 
14771     if (node == 0) return 0;
14772 
14773     type = nd_type(node);
14774     value_expr(node);
14775     if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
14776         warn_unless_e_option(parser, node, "integer literal in conditional range");
14777         return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
14778     }
14779     return cond0(parser, node);
14780 }
14781 
14782 static int
14783 literal_node(NODE *node)
14784 {
14785     if (!node) return 1;        /* same as NODE_NIL */
14786     switch (nd_type(node)) {
14787       case NODE_LIT:
14788       case NODE_STR:
14789       case NODE_DSTR:
14790       case NODE_EVSTR:
14791       case NODE_DREGX:
14792       case NODE_DREGX_ONCE:
14793       case NODE_DSYM:
14794         return 2;
14795       case NODE_TRUE:
14796       case NODE_FALSE:
14797       case NODE_NIL:
14798         return 1;
14799     }
14800     return 0;
14801 }
14802 
14803 static NODE*
14804 cond0(struct parser_params *parser, NODE *node)
14805 {
14806     if (node == 0) return 0;
14807     assign_in_cond(parser, node);
14808 
14809     switch (nd_type(node)) {
14810       case NODE_DSTR:
14811       case NODE_EVSTR:
14812       case NODE_STR:
14813         rb_warn0("string literal in condition");
14814         break;
14815 
14816       case NODE_DREGX:
14817       case NODE_DREGX_ONCE:
14818         warning_unless_e_option(parser, node, "regex literal in condition");
14819         return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
14820 
14821       case NODE_AND:
14822       case NODE_OR:
14823         node->nd_1st = cond0(parser, node->nd_1st);
14824         node->nd_2nd = cond0(parser, node->nd_2nd);
14825         break;
14826 
14827       case NODE_DOT2:
14828       case NODE_DOT3:
14829         node->nd_beg = range_op(parser, node->nd_beg);
14830         node->nd_end = range_op(parser, node->nd_end);
14831         if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
14832         else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
14833         if (!e_option_supplied(parser)) {
14834             int b = literal_node(node->nd_beg);
14835             int e = literal_node(node->nd_end);
14836             if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
14837                 parser_warn(node, "range literal in condition");
14838             }
14839         }
14840         break;
14841 
14842       case NODE_DSYM:
14843         parser_warning(node, "literal in condition");
14844         break;
14845 
14846       case NODE_LIT:
14847         if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
14848             warn_unless_e_option(parser, node, "regex literal in condition");
14849             nd_set_type(node, NODE_MATCH);
14850         }
14851         else {
14852             parser_warning(node, "literal in condition");
14853         }
14854       default:
14855         break;
14856     }
14857     return node;
14858 }
14859 
14860 static NODE*
14861 cond_gen(struct parser_params *parser, NODE *node)
14862 {
14863     if (node == 0) return 0;
14864     return cond0(parser, node);
14865 }
14866 
14867 static NODE*
14868 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
14869 {
14870     value_expr(left);
14871     if (left && (enum node_type)nd_type(left) == type) {
14872         NODE *node = left, *second;
14873         while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
14874             node = second;
14875         }
14876         node->nd_2nd = NEW_NODE(type, second, right, 0);
14877         return left;
14878     }
14879     return NEW_NODE(type, left, right, 0);
14880 }
14881 
14882 static void
14883 no_blockarg(struct parser_params *parser, NODE *node)
14884 {
14885     if (node && nd_type(node) == NODE_BLOCK_PASS) {
14886         compile_error(PARSER_ARG "block argument should not be given");
14887     }
14888 }
14889 
14890 static NODE *
14891 ret_args_gen(struct parser_params *parser, NODE *node)
14892 {
14893     if (node) {
14894         no_blockarg(parser, node);
14895         if (nd_type(node) == NODE_ARRAY) {
14896             if (node->nd_next == 0) {
14897                 node = node->nd_head;
14898             }
14899             else {
14900                 nd_set_type(node, NODE_VALUES);
14901             }
14902         }
14903     }
14904     return node;
14905 }
14906 
14907 static NODE *
14908 new_yield_gen(struct parser_params *parser, NODE *node)
14909 {
14910     if (node) no_blockarg(parser, node);
14911 
14912     return NEW_YIELD(node);
14913 }
14914 
14915 static NODE*
14916 negate_lit(NODE *node)
14917 {
14918     switch (TYPE(node->nd_lit)) {
14919       case T_FIXNUM:
14920         node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
14921         break;
14922       case T_BIGNUM:
14923         node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
14924         break;
14925       case T_FLOAT:
14926 #if USE_FLONUM
14927         if (FLONUM_P(node->nd_lit)) {
14928             node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
14929         }
14930         else {
14931             RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
14932         }
14933 #else
14934         RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
14935 #endif
14936         break;
14937       default:
14938         break;
14939     }
14940     return node;
14941 }
14942 
14943 static NODE *
14944 arg_blk_pass(NODE *node1, NODE *node2)
14945 {
14946     if (node2) {
14947         node2->nd_head = node1;
14948         return node2;
14949     }
14950     return node1;
14951 }
14952 
14953 
14954 static NODE*
14955 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
14956 {
14957     int saved_line = ruby_sourceline;
14958     struct rb_args_info *args = tail->nd_ainfo;
14959 
14960     args->pre_args_num   = m ? rb_long2int(m->nd_plen) : 0;
14961     args->pre_init       = m ? m->nd_next : 0;
14962 
14963     args->post_args_num  = p ? rb_long2int(p->nd_plen) : 0;
14964     args->post_init      = p ? p->nd_next : 0;
14965     args->first_post_arg = p ? p->nd_pid : 0;
14966 
14967     args->rest_arg       = r;
14968 
14969     args->opt_args       = o;
14970 
14971     ruby_sourceline = saved_line;
14972 
14973     return tail;
14974 }
14975 
14976 static NODE*
14977 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
14978 {
14979     int saved_line = ruby_sourceline;
14980     struct rb_args_info *args;
14981     NODE *kw_rest_arg = 0;
14982     NODE *node;
14983 
14984     args = ALLOC(struct rb_args_info);
14985     MEMZERO(args, struct rb_args_info, 1);
14986     node = NEW_NODE(NODE_ARGS, 0, 0, args);
14987 
14988     args->block_arg      = b;
14989     args->kw_args        = k;
14990     if (k && !kr) kr = internal_id();
14991     if (kr) {
14992         arg_var(kr);
14993         kw_rest_arg  = NEW_DVAR(kr);
14994     }
14995     args->kw_rest_arg    = kw_rest_arg;
14996 
14997     ruby_sourceline = saved_line;
14998     return node;
14999 }
15000 
15001 static NODE*
15002 dsym_node_gen(struct parser_params *parser, NODE *node)
15003 {
15004     VALUE lit;
15005 
15006     if (!node) {
15007         return NEW_LIT(ID2SYM(idNULL));
15008     }
15009 
15010     switch (nd_type(node)) {
15011       case NODE_DSTR:
15012         nd_set_type(node, NODE_DSYM);
15013         break;
15014       case NODE_STR:
15015         lit = node->nd_lit;
15016         node->nd_lit = ID2SYM(rb_intern_str(lit));
15017         nd_set_type(node, NODE_LIT);
15018         break;
15019       default:
15020         node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15021         break;
15022     }
15023     return node;
15024 }
15025 #endif /* !RIPPER */
15026 
15027 #ifndef RIPPER
15028 static NODE *
15029 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15030 {
15031     NODE *asgn;
15032 
15033     if (lhs) {
15034         ID vid = lhs->nd_vid;
15035         if (op == tOROP) {
15036             lhs->nd_value = rhs;
15037             asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15038             if (is_asgn_or_id(vid)) {
15039                 asgn->nd_aid = vid;
15040             }
15041         }
15042         else if (op == tANDOP) {
15043             lhs->nd_value = rhs;
15044             asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15045         }
15046         else {
15047             asgn = lhs;
15048             asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15049         }
15050     }
15051     else {
15052         asgn = NEW_BEGIN(0);
15053     }
15054     return asgn;
15055 }
15056 
15057 static NODE *
15058 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15059 {
15060     NODE *asgn;
15061 
15062     if (op == tOROP) {
15063         op = 0;
15064     }
15065     else if (op == tANDOP) {
15066         op = 1;
15067     }
15068     asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
15069     fixpos(asgn, lhs);
15070     return asgn;
15071 }
15072 
15073 static NODE *
15074 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15075 {
15076     NODE *asgn;
15077 
15078     if (op == tOROP) {
15079         op = 0;
15080     }
15081     else if (op == tANDOP) {
15082         op = 1;
15083     }
15084     if (lhs) {
15085         asgn = NEW_OP_CDECL(lhs, op, rhs);
15086     }
15087     else {
15088         asgn = NEW_BEGIN(0);
15089     }
15090     fixpos(asgn, lhs);
15091     return asgn;
15092 }
15093 #else
15094 static VALUE
15095 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
15096 {
15097     return dispatch3(opassign, lhs, op, rhs);
15098 }
15099 
15100 static VALUE
15101 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
15102 {
15103     VALUE recv = dispatch3(field, lhs, type, attr);
15104     return dispatch3(opassign, recv, op, rhs);
15105 }
15106 #endif
15107 
15108 static void
15109 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15110 {
15111     int i, cnt;
15112     ID *v, *u;
15113 
15114     if (!local->used) return;
15115     v = local->vars->tbl;
15116     u = local->used->tbl;
15117     cnt = local->used->pos;
15118     if (cnt != local->vars->pos) {
15119         rb_bug("local->used->pos != local->vars->pos");
15120     }
15121     for (i = 0; i < cnt; ++i) {
15122         if (!v[i] || (u[i] & LVAR_USED)) continue;
15123         if (is_private_local_id(v[i])) continue;
15124         rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15125     }
15126 }
15127 
15128 static void
15129 local_push_gen(struct parser_params *parser, int inherit_dvars)
15130 {
15131     struct local_vars *local;
15132 
15133     local = ALLOC(struct local_vars);
15134     local->prev = lvtbl;
15135     local->args = vtable_alloc(0);
15136     local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15137     local->used = !(inherit_dvars &&
15138                     (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
15139         RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15140     lvtbl = local;
15141 }
15142 
15143 static void
15144 local_pop_gen(struct parser_params *parser)
15145 {
15146     struct local_vars *local = lvtbl->prev;
15147     if (lvtbl->used) {
15148         warn_unused_var(parser, lvtbl);
15149         vtable_free(lvtbl->used);
15150     }
15151     vtable_free(lvtbl->args);
15152     vtable_free(lvtbl->vars);
15153     xfree(lvtbl);
15154     lvtbl = local;
15155 }
15156 
15157 #ifndef RIPPER
15158 static ID*
15159 vtable_tblcpy(ID *buf, const struct vtable *src)
15160 {
15161     int i, cnt = vtable_size(src);
15162 
15163     if (cnt > 0) {
15164         buf[0] = cnt;
15165         for (i = 0; i < cnt; i++) {
15166             buf[i] = src->tbl[i];
15167         }
15168         return buf;
15169     }
15170     return 0;
15171 }
15172 
15173 static ID*
15174 local_tbl_gen(struct parser_params *parser)
15175 {
15176     int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
15177     ID *buf;
15178 
15179     if (cnt <= 0) return 0;
15180     buf = ALLOC_N(ID, cnt + 1);
15181     vtable_tblcpy(buf+1, lvtbl->args);
15182     vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
15183     buf[0] = cnt;
15184     return buf;
15185 }
15186 #endif
15187 
15188 static int
15189 arg_var_gen(struct parser_params *parser, ID id)
15190 {
15191     vtable_add(lvtbl->args, id);
15192     return vtable_size(lvtbl->args) - 1;
15193 }
15194 
15195 static int
15196 local_var_gen(struct parser_params *parser, ID id)
15197 {
15198     vtable_add(lvtbl->vars, id);
15199     if (lvtbl->used) {
15200         vtable_add(lvtbl->used, (ID)ruby_sourceline);
15201     }
15202     return vtable_size(lvtbl->vars) - 1;
15203 }
15204 
15205 static int
15206 local_id_gen(struct parser_params *parser, ID id)
15207 {
15208     struct vtable *vars, *args, *used;
15209 
15210     vars = lvtbl->vars;
15211     args = lvtbl->args;
15212     used = lvtbl->used;
15213 
15214     while (vars && POINTER_P(vars->prev)) {
15215         vars = vars->prev;
15216         args = args->prev;
15217         if (used) used = used->prev;
15218     }
15219 
15220     if (vars && vars->prev == DVARS_INHERIT) {
15221         return rb_local_defined(id);
15222     }
15223     else if (vtable_included(args, id)) {
15224         return 1;
15225     }
15226     else {
15227         int i = vtable_included(vars, id);
15228         if (i && used) used->tbl[i-1] |= LVAR_USED;
15229         return i != 0;
15230     }
15231 }
15232 
15233 static const struct vtable *
15234 dyna_push_gen(struct parser_params *parser)
15235 {
15236     lvtbl->args = vtable_alloc(lvtbl->args);
15237     lvtbl->vars = vtable_alloc(lvtbl->vars);
15238     if (lvtbl->used) {
15239         lvtbl->used = vtable_alloc(lvtbl->used);
15240     }
15241     return lvtbl->args;
15242 }
15243 
15244 static void
15245 dyna_pop_1(struct parser_params *parser)
15246 {
15247     struct vtable *tmp;
15248 
15249     if ((tmp = lvtbl->used) != 0) {
15250         warn_unused_var(parser, lvtbl);
15251         lvtbl->used = lvtbl->used->prev;
15252         vtable_free(tmp);
15253     }
15254     tmp = lvtbl->args;
15255     lvtbl->args = lvtbl->args->prev;
15256     vtable_free(tmp);
15257     tmp = lvtbl->vars;
15258     lvtbl->vars = lvtbl->vars->prev;
15259     vtable_free(tmp);
15260 }
15261 
15262 static void
15263 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
15264 {
15265     while (lvtbl->args != lvargs) {
15266         dyna_pop_1(parser);
15267         if (!lvtbl->args) {
15268             struct local_vars *local = lvtbl->prev;
15269             xfree(lvtbl);
15270             lvtbl = local;
15271         }
15272     }
15273     dyna_pop_1(parser);
15274 }
15275 
15276 static int
15277 dyna_in_block_gen(struct parser_params *parser)
15278 {
15279     return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
15280 }
15281 
15282 static int
15283 dvar_defined_gen(struct parser_params *parser, ID id, int get)
15284 {
15285     struct vtable *vars, *args, *used;
15286     int i;
15287 
15288     args = lvtbl->args;
15289     vars = lvtbl->vars;
15290     used = lvtbl->used;
15291 
15292     while (POINTER_P(vars)) {
15293         if (vtable_included(args, id)) {
15294             return 1;
15295         }
15296         if ((i = vtable_included(vars, id)) != 0) {
15297             if (used) used->tbl[i-1] |= LVAR_USED;
15298             return 1;
15299         }
15300         args = args->prev;
15301         vars = vars->prev;
15302         if (get) used = 0;
15303         if (used) used = used->prev;
15304     }
15305 
15306     if (vars == DVARS_INHERIT) {
15307         return rb_dvar_defined(id);
15308     }
15309 
15310     return 0;
15311 }
15312 
15313 static int
15314 dvar_curr_gen(struct parser_params *parser, ID id)
15315 {
15316     return (vtable_included(lvtbl->args, id) ||
15317             vtable_included(lvtbl->vars, id));
15318 }
15319 
15320 #ifndef RIPPER
15321 static void
15322 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
15323 {
15324     int c = RE_OPTION_ENCODING_IDX(options);
15325 
15326     if (c) {
15327         int opt, idx;
15328         rb_char_to_option_kcode(c, &opt, &idx);
15329         if (idx != ENCODING_GET(str) &&
15330             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15331             goto error;
15332         }
15333         ENCODING_SET(str, idx);
15334     }
15335     else if (RE_OPTION_ENCODING_NONE(options)) {
15336         if (!ENCODING_IS_ASCII8BIT(str) &&
15337             rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15338             c = 'n';
15339             goto error;
15340         }
15341         rb_enc_associate(str, rb_ascii8bit_encoding());
15342     }
15343     else if (current_enc == rb_usascii_encoding()) {
15344         if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
15345             /* raise in re.c */
15346             rb_enc_associate(str, rb_usascii_encoding());
15347         }
15348         else {
15349             rb_enc_associate(str, rb_ascii8bit_encoding());
15350         }
15351     }
15352     return;
15353 
15354   error:
15355     compile_error(PARSER_ARG
15356         "regexp encoding option '%c' differs from source encoding '%s'",
15357         c, rb_enc_name(rb_enc_get(str)));
15358 }
15359 
15360 static int
15361 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
15362 {
15363     VALUE err;
15364     reg_fragment_setenc(str, options);
15365     err = rb_reg_check_preprocess(str);
15366     if (err != Qnil) {
15367         err = rb_obj_as_string(err);
15368         compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
15369         RB_GC_GUARD(err);
15370         return 0;
15371     }
15372     return 1;
15373 }
15374 
15375 typedef struct {
15376     struct parser_params* parser;
15377     rb_encoding *enc;
15378     NODE *succ_block;
15379     NODE *fail_block;
15380     int num;
15381 } reg_named_capture_assign_t;
15382 
15383 static int
15384 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
15385           int back_num, int *back_refs, OnigRegex regex, void *arg0)
15386 {
15387     reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
15388     struct parser_params* parser = arg->parser;
15389     rb_encoding *enc = arg->enc;
15390     long len = name_end - name;
15391     const char *s = (const char *)name;
15392     ID var;
15393 
15394     arg->num++;
15395 
15396     if (arg->succ_block == 0) {
15397         arg->succ_block = NEW_BEGIN(0);
15398         arg->fail_block = NEW_BEGIN(0);
15399     }
15400 
15401     if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
15402         (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
15403         !rb_enc_symname2_p(s, len, enc)) {
15404         return ST_CONTINUE;
15405     }
15406     var = rb_intern3(s, len, enc);
15407     if (dvar_defined(var) || local_id(var)) {
15408         rb_warningS("named capture conflicts a local variable - %s",
15409                     rb_id2name(var));
15410     }
15411     arg->succ_block = block_append(arg->succ_block,
15412         newline_node(node_assign(assignable(var,0),
15413             NEW_CALL(
15414               gettable(rb_intern("$~")),
15415               idAREF,
15416               NEW_LIST(NEW_LIT(ID2SYM(var))))
15417             )));
15418     arg->fail_block = block_append(arg->fail_block,
15419         newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
15420     return ST_CONTINUE;
15421 }
15422 
15423 static NODE *
15424 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
15425 {
15426     reg_named_capture_assign_t arg;
15427 
15428     arg.parser = parser;
15429     arg.enc = rb_enc_get(regexp);
15430     arg.succ_block = 0;
15431     arg.fail_block = 0;
15432     arg.num = 0;
15433     onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
15434 
15435     if (arg.num == 0)
15436         return match;
15437 
15438     return
15439         block_append(
15440             newline_node(match),
15441             NEW_IF(gettable(rb_intern("$~")),
15442                 block_append(
15443                     newline_node(arg.succ_block),
15444                     newline_node(
15445                         NEW_CALL(
15446                           gettable(rb_intern("$~")),
15447                           rb_intern("begin"),
15448                           NEW_LIST(NEW_LIT(INT2FIX(0)))))),
15449                 block_append(
15450                     newline_node(arg.fail_block),
15451                     newline_node(
15452                         NEW_LIT(Qnil)))));
15453 }
15454 
15455 static VALUE
15456 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
15457 {
15458     VALUE re;
15459     VALUE err;
15460 
15461     reg_fragment_setenc(str, options);
15462     err = rb_errinfo();
15463     re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
15464     if (NIL_P(re)) {
15465         ID mesg = rb_intern("mesg");
15466         VALUE m = rb_attr_get(rb_errinfo(), mesg);
15467         rb_set_errinfo(err);
15468         if (!NIL_P(err)) {
15469             rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
15470         }
15471         else {
15472             compile_error(PARSER_ARG "%s", RSTRING_PTR(m));
15473         }
15474         return Qnil;
15475     }
15476     return re;
15477 }
15478 
15479 void
15480 rb_gc_mark_parser(void)
15481 {
15482 }
15483 
15484 NODE*
15485 rb_parser_append_print(VALUE vparser, NODE *node)
15486 {
15487     NODE *prelude = 0;
15488     NODE *scope = node;
15489     struct parser_params *parser;
15490 
15491     if (!node) return node;
15492 
15493     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15494 
15495     node = node->nd_body;
15496 
15497     if (nd_type(node) == NODE_PRELUDE) {
15498         prelude = node;
15499         node = node->nd_body;
15500     }
15501 
15502     node = block_append(node,
15503                         NEW_FCALL(rb_intern("print"),
15504                                   NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
15505     if (prelude) {
15506         prelude->nd_body = node;
15507         scope->nd_body = prelude;
15508     }
15509     else {
15510         scope->nd_body = node;
15511     }
15512 
15513     return scope;
15514 }
15515 
15516 NODE *
15517 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
15518 {
15519     NODE *prelude = 0;
15520     NODE *scope = node;
15521     struct parser_params *parser;
15522 
15523     if (!node) return node;
15524 
15525     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15526 
15527     node = node->nd_body;
15528 
15529     if (nd_type(node) == NODE_PRELUDE) {
15530         prelude = node;
15531         node = node->nd_body;
15532     }
15533     if (split) {
15534         node = block_append(NEW_GASGN(rb_intern("$F"),
15535                                       NEW_CALL(NEW_GVAR(rb_intern("$_")),
15536                                                rb_intern("split"), 0)),
15537                             node);
15538     }
15539     if (chop) {
15540         node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
15541                                      rb_intern("chop!"), 0), node);
15542     }
15543 
15544     node = NEW_OPT_N(node);
15545 
15546     if (prelude) {
15547         prelude->nd_body = node;
15548         scope->nd_body = prelude;
15549     }
15550     else {
15551         scope->nd_body = node;
15552     }
15553 
15554     return scope;
15555 }
15556 
15557 static const struct {
15558     ID token;
15559     const char *name;
15560 } op_tbl[] = {
15561     {tDOT2,     ".."},
15562     {tDOT3,     "..."},
15563     {'+',       "+(binary)"},
15564     {'-',       "-(binary)"},
15565     {tPOW,      "**"},
15566     {tDSTAR,    "**"},
15567     {tUPLUS,    "+@"},
15568     {tUMINUS,   "-@"},
15569     {tCMP,      "<=>"},
15570     {tGEQ,      ">="},
15571     {tLEQ,      "<="},
15572     {tEQ,       "=="},
15573     {tEQQ,      "==="},
15574     {tNEQ,      "!="},
15575     {tMATCH,    "=~"},
15576     {tNMATCH,   "!~"},
15577     {tAREF,     "[]"},
15578     {tASET,     "[]="},
15579     {tLSHFT,    "<<"},
15580     {tRSHFT,    ">>"},
15581     {tCOLON2,   "::"},
15582 };
15583 
15584 #define op_tbl_count numberof(op_tbl)
15585 
15586 #ifndef ENABLE_SELECTOR_NAMESPACE
15587 #define ENABLE_SELECTOR_NAMESPACE 0
15588 #endif
15589 
15590 static struct symbols {
15591     ID last_id;
15592     st_table *sym_id;
15593     st_table *id_str;
15594 #if ENABLE_SELECTOR_NAMESPACE
15595     st_table *ivar2_id;
15596     st_table *id_ivar2;
15597 #endif
15598     VALUE op_sym[tLAST_OP_ID];
15599 } global_symbols = {tLAST_TOKEN};
15600 
15601 static const struct st_hash_type symhash = {
15602     rb_str_hash_cmp,
15603     rb_str_hash,
15604 };
15605 
15606 #if ENABLE_SELECTOR_NAMESPACE
15607 struct ivar2_key {
15608     ID id;
15609     VALUE klass;
15610 };
15611 
15612 static int
15613 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
15614 {
15615     if (key1->id == key2->id && key1->klass == key2->klass) {
15616         return 0;
15617     }
15618     return 1;
15619 }
15620 
15621 static int
15622 ivar2_hash(struct ivar2_key *key)
15623 {
15624     return (key->id << 8) ^ (key->klass >> 2);
15625 }
15626 
15627 static const struct st_hash_type ivar2_hash_type = {
15628     ivar2_cmp,
15629     ivar2_hash,
15630 };
15631 #endif
15632 
15633 void
15634 Init_sym(void)
15635 {
15636     global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
15637     global_symbols.id_str = st_init_numtable_with_size(1000);
15638 #if ENABLE_SELECTOR_NAMESPACE
15639     global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
15640     global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
15641 #endif
15642 
15643     (void)nodetype;
15644     (void)nodeline;
15645 #if PARSER_DEBUG
15646     (void)lex_state_name(-1);
15647 #endif
15648 
15649     Init_id();
15650 }
15651 
15652 void
15653 rb_gc_mark_symbols(void)
15654 {
15655     rb_mark_tbl(global_symbols.id_str);
15656     rb_gc_mark_locations(global_symbols.op_sym,
15657                          global_symbols.op_sym + numberof(global_symbols.op_sym));
15658 }
15659 #endif /* !RIPPER */
15660 
15661 static ID
15662 internal_id_gen(struct parser_params *parser)
15663 {
15664     ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
15665     id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
15666     return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
15667 }
15668 
15669 #ifndef RIPPER
15670 static int
15671 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
15672 {
15673     int mb = 0;
15674 
15675     if (m >= e) return 0;
15676     if (is_global_name_punct(*m)) {
15677         ++m;
15678     }
15679     else if (*m == '-') {
15680         ++m;
15681         if (m < e && is_identchar(m, e, enc)) {
15682             if (!ISASCII(*m)) mb = 1;
15683             m += rb_enc_mbclen(m, e, enc);
15684         }
15685     }
15686     else {
15687         if (!rb_enc_isdigit(*m, enc)) return 0;
15688         do {
15689             if (!ISASCII(*m)) mb = 1;
15690             ++m;
15691         } while (m < e && rb_enc_isdigit(*m, enc));
15692     }
15693     return m == e ? mb + 1 : 0;
15694 }
15695 
15696 int
15697 rb_symname_p(const char *name)
15698 {
15699     return rb_enc_symname_p(name, rb_ascii8bit_encoding());
15700 }
15701 
15702 int
15703 rb_enc_symname_p(const char *name, rb_encoding *enc)
15704 {
15705     return rb_enc_symname2_p(name, strlen(name), enc);
15706 }
15707 
15708 static int
15709 rb_enc_symname_type(const char *name, long len, rb_encoding *enc)
15710 {
15711     const char *m = name;
15712     const char *e = m + len;
15713     int type = ID_JUNK;
15714 
15715     if (!m || len <= 0) return -1;
15716     switch (*m) {
15717       case '\0':
15718         return -1;
15719 
15720       case '$':
15721         type = ID_GLOBAL;
15722         if (is_special_global_name(++m, e, enc)) return type;
15723         goto id;
15724 
15725       case '@':
15726         type = ID_INSTANCE;
15727         if (*++m == '@') {
15728             ++m;
15729             type = ID_CLASS;
15730         }
15731         goto id;
15732 
15733       case '<':
15734         switch (*++m) {
15735           case '<': ++m; break;
15736           case '=': if (*++m == '>') ++m; break;
15737           default: break;
15738         }
15739         break;
15740 
15741       case '>':
15742         switch (*++m) {
15743           case '>': case '=': ++m; break;
15744         }
15745         break;
15746 
15747       case '=':
15748         switch (*++m) {
15749           case '~': ++m; break;
15750           case '=': if (*++m == '=') ++m; break;
15751           default: return -1;
15752         }
15753         break;
15754 
15755       case '*':
15756         if (*++m == '*') ++m;
15757         break;
15758 
15759       case '+': case '-':
15760         if (*++m == '@') ++m;
15761         break;
15762 
15763       case '|': case '^': case '&': case '/': case '%': case '~': case '`':
15764         ++m;
15765         break;
15766 
15767       case '[':
15768         if (*++m != ']') return -1;
15769         if (*++m == '=') ++m;
15770         break;
15771 
15772       case '!':
15773         if (len == 1) return ID_JUNK;
15774         switch (*++m) {
15775           case '=': case '~': ++m; break;
15776           default: return -1;
15777         }
15778         break;
15779 
15780       default:
15781         type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
15782       id:
15783         if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
15784             return -1;
15785         while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
15786         switch (*m) {
15787           case '!': case '?':
15788             if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
15789             type = ID_JUNK;
15790             ++m;
15791             break;
15792           case '=':
15793             if (type != ID_CONST && type != ID_LOCAL) return -1;
15794             type = ID_ATTRSET;
15795             ++m;
15796             break;
15797         }
15798         break;
15799     }
15800     return m == e ? type : -1;
15801 }
15802 
15803 int
15804 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
15805 {
15806     return rb_enc_symname_type(name, len, enc) != -1;
15807 }
15808 
15809 static int
15810 rb_str_symname_type(VALUE name)
15811 {
15812     const char *ptr = StringValuePtr(name);
15813     long len = RSTRING_LEN(name);
15814     int type = rb_enc_symname_type(ptr, len, rb_enc_get(name));
15815     RB_GC_GUARD(name);
15816     return type;
15817 }
15818 
15819 static ID
15820 register_symid(ID id, const char *name, long len, rb_encoding *enc)
15821 {
15822     VALUE str = rb_enc_str_new(name, len, enc);
15823     return register_symid_str(id, str);
15824 }
15825 
15826 static ID
15827 register_symid_str(ID id, VALUE str)
15828 {
15829     OBJ_FREEZE(str);
15830     st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
15831     st_add_direct(global_symbols.id_str, id, (st_data_t)str);
15832     return id;
15833 }
15834 
15835 static int
15836 sym_check_asciionly(VALUE str)
15837 {
15838     if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
15839     switch (rb_enc_str_coderange(str)) {
15840       case ENC_CODERANGE_BROKEN:
15841         rb_raise(rb_eEncodingError, "invalid encoding symbol");
15842       case ENC_CODERANGE_7BIT:
15843         return TRUE;
15844     }
15845     return FALSE;
15846 }
15847 
15848 /*
15849  * _str_ itself will be registered at the global symbol table.  _str_
15850  * can be modified before the registration, since the encoding will be
15851  * set to ASCII-8BIT if it is a special global name.
15852  */
15853 static ID intern_str(VALUE str);
15854 
15855 ID
15856 rb_intern3(const char *name, long len, rb_encoding *enc)
15857 {
15858     VALUE str;
15859     st_data_t data;
15860     struct RString fake_str;
15861     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
15862     fake_str.basic.klass = rb_cString;
15863     fake_str.as.heap.len = len;
15864     fake_str.as.heap.ptr = (char *)name;
15865     fake_str.as.heap.aux.capa = len;
15866     str = (VALUE)&fake_str;
15867     rb_enc_associate(str, enc);
15868     OBJ_FREEZE(str);
15869 
15870     if (st_lookup(global_symbols.sym_id, str, &data))
15871         return (ID)data;
15872 
15873     str = rb_enc_str_new(name, len, enc); /* make true string */
15874     return intern_str(str);
15875 }
15876 
15877 static ID
15878 intern_str(VALUE str)
15879 {
15880     const char *name, *m, *e;
15881     long len, last;
15882     rb_encoding *enc, *symenc;
15883     unsigned char c;
15884     ID id;
15885     int mb;
15886 
15887     RSTRING_GETMEM(str, name, len);
15888     m = name;
15889     e = m + len;
15890     enc = rb_enc_get(str);
15891     symenc = enc;
15892 
15893     if (rb_cString && !rb_enc_asciicompat(enc)) {
15894         id = ID_JUNK;
15895         goto new_id;
15896     }
15897     last = len-1;
15898     id = 0;
15899     switch (*m) {
15900       case '$':
15901         id |= ID_GLOBAL;
15902         if ((mb = is_special_global_name(++m, e, enc)) != 0) {
15903             if (!--mb) symenc = rb_usascii_encoding();
15904             goto new_id;
15905         }
15906         break;
15907       case '@':
15908         if (m[1] == '@') {
15909             m++;
15910             id |= ID_CLASS;
15911         }
15912         else {
15913             id |= ID_INSTANCE;
15914         }
15915         m++;
15916         break;
15917       default:
15918         c = m[0];
15919         if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
15920             /* operators */
15921             int i;
15922 
15923             if (len == 1) {
15924                 id = c;
15925                 goto id_register;
15926             }
15927             for (i = 0; i < op_tbl_count; i++) {
15928                 if (*op_tbl[i].name == *m &&
15929                     strcmp(op_tbl[i].name, m) == 0) {
15930                     id = op_tbl[i].token;
15931                     goto id_register;
15932                 }
15933             }
15934         }
15935 
15936         if (m[last] == '=') {
15937             /* attribute assignment */
15938             id = rb_intern3(name, last, enc);
15939             if (id > tLAST_OP_ID && !is_attrset_id(id)) {
15940                 enc = rb_enc_get(rb_id2str(id));
15941                 id = rb_id_attrset(id);
15942                 goto id_register;
15943             }
15944             id = ID_ATTRSET;
15945         }
15946         else if (rb_enc_isupper(m[0], enc)) {
15947             id = ID_CONST;
15948         }
15949         else {
15950             id = ID_LOCAL;
15951         }
15952         break;
15953     }
15954     if (!rb_enc_isdigit(*m, enc)) {
15955         while (m <= name + last && is_identchar(m, e, enc)) {
15956             if (ISASCII(*m)) {
15957                 m++;
15958             }
15959             else {
15960                 m += rb_enc_mbclen(m, e, enc);
15961             }
15962         }
15963     }
15964     if (m - name < len) id = ID_JUNK;
15965     if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
15966   new_id:
15967     if (symenc != enc) rb_enc_associate(str, symenc);
15968     if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
15969         if (len > 20) {
15970             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
15971                      name);
15972         }
15973         else {
15974             rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
15975                      (int)len, name);
15976         }
15977     }
15978     id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
15979   id_register:
15980     return register_symid_str(id, str);
15981 }
15982 
15983 ID
15984 rb_intern2(const char *name, long len)
15985 {
15986     return rb_intern3(name, len, rb_usascii_encoding());
15987 }
15988 
15989 #undef rb_intern
15990 ID
15991 rb_intern(const char *name)
15992 {
15993     return rb_intern2(name, strlen(name));
15994 }
15995 
15996 ID
15997 rb_intern_str(VALUE str)
15998 {
15999     st_data_t id;
16000 
16001     if (st_lookup(global_symbols.sym_id, str, &id))
16002         return (ID)id;
16003     return intern_str(rb_str_dup(str));
16004 }
16005 
16006 VALUE
16007 rb_id2str(ID id)
16008 {
16009     st_data_t data;
16010 
16011     if (id < tLAST_TOKEN) {
16012         int i = 0;
16013 
16014         if (id < INT_MAX && rb_ispunct((int)id)) {
16015             VALUE str = global_symbols.op_sym[i = (int)id];
16016             if (!str) {
16017                 char name[2];
16018                 name[0] = (char)id;
16019                 name[1] = 0;
16020                 str = rb_usascii_str_new(name, 1);
16021                 OBJ_FREEZE(str);
16022                 global_symbols.op_sym[i] = str;
16023             }
16024             return str;
16025         }
16026         for (i = 0; i < op_tbl_count; i++) {
16027             if (op_tbl[i].token == id) {
16028                 VALUE str = global_symbols.op_sym[i];
16029                 if (!str) {
16030                     str = rb_usascii_str_new2(op_tbl[i].name);
16031                     OBJ_FREEZE(str);
16032                     global_symbols.op_sym[i] = str;
16033                 }
16034                 return str;
16035             }
16036         }
16037     }
16038 
16039     if (st_lookup(global_symbols.id_str, id, &data)) {
16040         VALUE str = (VALUE)data;
16041         if (RBASIC(str)->klass == 0)
16042             RBASIC(str)->klass = rb_cString;
16043         return str;
16044     }
16045 
16046     if (is_attrset_id(id)) {
16047         ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
16048         VALUE str;
16049 
16050         while (!(str = rb_id2str(id2))) {
16051             if (!is_local_id(id2)) return 0;
16052             id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
16053         }
16054         str = rb_str_dup(str);
16055         rb_str_cat(str, "=", 1);
16056         rb_intern_str(str);
16057         if (st_lookup(global_symbols.id_str, id, &data)) {
16058             VALUE str = (VALUE)data;
16059             if (RBASIC(str)->klass == 0)
16060                 RBASIC(str)->klass = rb_cString;
16061             return str;
16062         }
16063     }
16064     return 0;
16065 }
16066 
16067 const char *
16068 rb_id2name(ID id)
16069 {
16070     VALUE str = rb_id2str(id);
16071 
16072     if (!str) return 0;
16073     return RSTRING_PTR(str);
16074 }
16075 
16076 static int
16077 symbols_i(VALUE sym, ID value, VALUE ary)
16078 {
16079     rb_ary_push(ary, ID2SYM(value));
16080     return ST_CONTINUE;
16081 }
16082 
16083 /*
16084  *  call-seq:
16085  *     Symbol.all_symbols    => array
16086  *
16087  *  Returns an array of all the symbols currently in Ruby's symbol
16088  *  table.
16089  *
16090  *     Symbol.all_symbols.size    #=> 903
16091  *     Symbol.all_symbols[1,20]   #=> [:floor, :ARGV, :Binding, :symlink,
16092  *                                     :chown, :EOFError, :$;, :String,
16093  *                                     :LOCK_SH, :"setuid?", :$<,
16094  *                                     :default_proc, :compact, :extend,
16095  *                                     :Tms, :getwd, :$=, :ThreadGroup,
16096  *                                     :wait2, :$>]
16097  */
16098 
16099 VALUE
16100 rb_sym_all_symbols(void)
16101 {
16102     VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
16103 
16104     st_foreach(global_symbols.sym_id, symbols_i, ary);
16105     return ary;
16106 }
16107 
16108 int
16109 rb_is_const_id(ID id)
16110 {
16111     return is_const_id(id);
16112 }
16113 
16114 int
16115 rb_is_class_id(ID id)
16116 {
16117     return is_class_id(id);
16118 }
16119 
16120 int
16121 rb_is_global_id(ID id)
16122 {
16123     return is_global_id(id);
16124 }
16125 
16126 int
16127 rb_is_instance_id(ID id)
16128 {
16129     return is_instance_id(id);
16130 }
16131 
16132 int
16133 rb_is_attrset_id(ID id)
16134 {
16135     return is_attrset_id(id);
16136 }
16137 
16138 int
16139 rb_is_local_id(ID id)
16140 {
16141     return is_local_id(id);
16142 }
16143 
16144 int
16145 rb_is_junk_id(ID id)
16146 {
16147     return is_junk_id(id);
16148 }
16149 
16161 ID
16162 rb_check_id(volatile VALUE *namep)
16163 {
16164     st_data_t id;
16165     VALUE tmp;
16166     VALUE name = *namep;
16167 
16168     if (SYMBOL_P(name)) {
16169         return SYM2ID(name);
16170     }
16171     else if (!RB_TYPE_P(name, T_STRING)) {
16172         tmp = rb_check_string_type(name);
16173         if (NIL_P(tmp)) {
16174             tmp = rb_inspect(name);
16175             rb_raise(rb_eTypeError, "%s is not a symbol",
16176                      RSTRING_PTR(tmp));
16177         }
16178         name = tmp;
16179         *namep = name;
16180     }
16181 
16182     sym_check_asciionly(name);
16183 
16184     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
16185         return (ID)id;
16186 
16187     if (rb_is_attrset_name(name)) {
16188         struct RString fake_str;
16189         const VALUE localname = (VALUE)&fake_str;
16190         /* make local name by chopping '=' */
16191         fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16192         fake_str.basic.klass = rb_cString;
16193         fake_str.as.heap.len = RSTRING_LEN(name) - 1;
16194         fake_str.as.heap.ptr = RSTRING_PTR(name);
16195         fake_str.as.heap.aux.capa = fake_str.as.heap.len;
16196         rb_enc_copy(localname, name);
16197         OBJ_FREEZE(localname);
16198 
16199         if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
16200             return rb_id_attrset((ID)id);
16201         }
16202         RB_GC_GUARD(name);
16203     }
16204 
16205     return (ID)0;
16206 }
16207 
16208 ID
16209 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
16210 {
16211     st_data_t id;
16212     struct RString fake_str;
16213     const VALUE name = (VALUE)&fake_str;
16214     fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16215     fake_str.basic.klass = rb_cString;
16216     fake_str.as.heap.len = len;
16217     fake_str.as.heap.ptr = (char *)ptr;
16218     fake_str.as.heap.aux.capa = len;
16219     rb_enc_associate(name, enc);
16220 
16221     sym_check_asciionly(name);
16222 
16223     if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
16224         return (ID)id;
16225 
16226     if (rb_is_attrset_name(name)) {
16227         fake_str.as.heap.len = len - 1;
16228         if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
16229             return rb_id_attrset((ID)id);
16230         }
16231     }
16232 
16233     return (ID)0;
16234 }
16235 
16236 int
16237 rb_is_const_name(VALUE name)
16238 {
16239     return rb_str_symname_type(name) == ID_CONST;
16240 }
16241 
16242 int
16243 rb_is_class_name(VALUE name)
16244 {
16245     return rb_str_symname_type(name) == ID_CLASS;
16246 }
16247 
16248 int
16249 rb_is_global_name(VALUE name)
16250 {
16251     return rb_str_symname_type(name) == ID_GLOBAL;
16252 }
16253 
16254 int
16255 rb_is_instance_name(VALUE name)
16256 {
16257     return rb_str_symname_type(name) == ID_INSTANCE;
16258 }
16259 
16260 int
16261 rb_is_attrset_name(VALUE name)
16262 {
16263     return rb_str_symname_type(name) == ID_ATTRSET;
16264 }
16265 
16266 int
16267 rb_is_local_name(VALUE name)
16268 {
16269     return rb_str_symname_type(name) == ID_LOCAL;
16270 }
16271 
16272 int
16273 rb_is_method_name(VALUE name)
16274 {
16275     switch (rb_str_symname_type(name)) {
16276       case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
16277         return TRUE;
16278     }
16279     return FALSE;
16280 }
16281 
16282 int
16283 rb_is_junk_name(VALUE name)
16284 {
16285     return rb_str_symname_type(name) == -1;
16286 }
16287 
16288 #endif /* !RIPPER */
16289 
16290 static void
16291 parser_initialize(struct parser_params *parser)
16292 {
16293     parser->eofp = Qfalse;
16294 
16295     parser->parser_lex_strterm = 0;
16296     parser->parser_cond_stack = 0;
16297     parser->parser_cmdarg_stack = 0;
16298     parser->parser_class_nest = 0;
16299     parser->parser_paren_nest = 0;
16300     parser->parser_lpar_beg = 0;
16301     parser->parser_brace_nest = 0;
16302     parser->parser_in_single = 0;
16303     parser->parser_in_def = 0;
16304     parser->parser_in_defined = 0;
16305     parser->parser_compile_for_eval = 0;
16306     parser->parser_cur_mid = 0;
16307     parser->parser_tokenbuf = NULL;
16308     parser->parser_tokidx = 0;
16309     parser->parser_toksiz = 0;
16310     parser->parser_heredoc_end = 0;
16311     parser->parser_command_start = TRUE;
16312     parser->parser_deferred_nodes = 0;
16313     parser->parser_lex_pbeg = 0;
16314     parser->parser_lex_p = 0;
16315     parser->parser_lex_pend = 0;
16316     parser->parser_lvtbl = 0;
16317     parser->parser_ruby__end__seen = 0;
16318     parser->parser_ruby_sourcefile = 0;
16319 #ifndef RIPPER
16320     parser->is_ripper = 0;
16321     parser->parser_eval_tree_begin = 0;
16322     parser->parser_eval_tree = 0;
16323 #else
16324     parser->is_ripper = 1;
16325     parser->parser_ruby_sourcefile_string = Qnil;
16326     parser->delayed = Qnil;
16327 
16328     parser->result = Qnil;
16329     parser->parsing_thread = Qnil;
16330     parser->toplevel_p = TRUE;
16331 #endif
16332 #ifdef YYMALLOC
16333     parser->heap = NULL;
16334 #endif
16335     parser->enc = rb_utf8_encoding();
16336 }
16337 
16338 #ifdef RIPPER
16339 #define parser_mark ripper_parser_mark
16340 #define parser_free ripper_parser_free
16341 #endif
16342 
16343 static void
16344 parser_mark(void *ptr)
16345 {
16346     struct parser_params *p = (struct parser_params*)ptr;
16347 
16348     rb_gc_mark((VALUE)p->parser_lex_strterm);
16349     rb_gc_mark((VALUE)p->parser_deferred_nodes);
16350     rb_gc_mark(p->parser_lex_input);
16351     rb_gc_mark(p->parser_lex_lastline);
16352     rb_gc_mark(p->parser_lex_nextline);
16353 #ifndef RIPPER
16354     rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
16355     rb_gc_mark((VALUE)p->parser_eval_tree) ;
16356     rb_gc_mark(p->debug_lines);
16357 #else
16358     rb_gc_mark(p->parser_ruby_sourcefile_string);
16359     rb_gc_mark(p->delayed);
16360     rb_gc_mark(p->value);
16361     rb_gc_mark(p->result);
16362     rb_gc_mark(p->parsing_thread);
16363 #endif
16364 #ifdef YYMALLOC
16365     rb_gc_mark((VALUE)p->heap);
16366 #endif
16367 }
16368 
16369 static void
16370 parser_free(void *ptr)
16371 {
16372     struct parser_params *p = (struct parser_params*)ptr;
16373     struct local_vars *local, *prev;
16374 
16375     if (p->parser_tokenbuf) {
16376         xfree(p->parser_tokenbuf);
16377     }
16378     for (local = p->parser_lvtbl; local; local = prev) {
16379         if (local->vars) xfree(local->vars);
16380         prev = local->prev;
16381         xfree(local);
16382     }
16383 #ifndef RIPPER
16384     xfree(p->parser_ruby_sourcefile);
16385 #endif
16386     xfree(p);
16387 }
16388 
16389 static size_t
16390 parser_memsize(const void *ptr)
16391 {
16392     struct parser_params *p = (struct parser_params*)ptr;
16393     struct local_vars *local;
16394     size_t size = sizeof(*p);
16395 
16396     if (!ptr) return 0;
16397     size += p->parser_toksiz;
16398     for (local = p->parser_lvtbl; local; local = local->prev) {
16399         size += sizeof(*local);
16400         if (local->vars) size += local->vars->capa * sizeof(ID);
16401     }
16402 #ifndef RIPPER
16403     if (p->parser_ruby_sourcefile) {
16404         size += strlen(p->parser_ruby_sourcefile) + 1;
16405     }
16406 #endif
16407     return size;
16408 }
16409 
16410 static
16411 #ifndef RIPPER
16412 const
16413 #endif
16414 rb_data_type_t parser_data_type = {
16415     "parser",
16416     {
16417         parser_mark,
16418         parser_free,
16419         parser_memsize,
16420     },
16421 };
16422 
16423 #ifndef RIPPER
16424 #undef rb_reserved_word
16425 
16426 const struct kwtable *
16427 rb_reserved_word(const char *str, unsigned int len)
16428 {
16429     return reserved_word(str, len);
16430 }
16431 
16432 static struct parser_params *
16433 parser_new(void)
16434 {
16435     struct parser_params *p;
16436 
16437     p = ALLOC_N(struct parser_params, 1);
16438     MEMZERO(p, struct parser_params, 1);
16439     parser_initialize(p);
16440     return p;
16441 }
16442 
16443 VALUE
16444 rb_parser_new(void)
16445 {
16446     struct parser_params *p = parser_new();
16447 
16448     return TypedData_Wrap_Struct(0, &parser_data_type, p);
16449 }
16450 
16451 /*
16452  *  call-seq:
16453  *    ripper#end_seen?   -> Boolean
16454  *
16455  *  Return true if parsed source ended by +\_\_END\_\_+.
16456  */
16457 VALUE
16458 rb_parser_end_seen_p(VALUE vparser)
16459 {
16460     struct parser_params *parser;
16461 
16462     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16463     return ruby__end__seen ? Qtrue : Qfalse;
16464 }
16465 
16466 /*
16467  *  call-seq:
16468  *    ripper#encoding   -> encoding
16469  *
16470  *  Return encoding of the source.
16471  */
16472 VALUE
16473 rb_parser_encoding(VALUE vparser)
16474 {
16475     struct parser_params *parser;
16476 
16477     TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16478     return rb_enc_from_encoding(current_enc);
16479 }
16480 
16481 /*
16482  *  call-seq:
16483  *    ripper.yydebug   -> true or false
16484  *
16485  *  Get yydebug.
16486  */
16487 VALUE
16488 rb_parser_get_yydebug(VALUE self)
16489 {
16490     struct parser_params *parser;
16491 
16492     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16493     return yydebug ? Qtrue : Qfalse;
16494 }
16495 
16496 /*
16497  *  call-seq:
16498  *    ripper.yydebug = flag
16499  *
16500  *  Set yydebug.
16501  */
16502 VALUE
16503 rb_parser_set_yydebug(VALUE self, VALUE flag)
16504 {
16505     struct parser_params *parser;
16506 
16507     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16508     yydebug = RTEST(flag);
16509     return flag;
16510 }
16511 
16512 #ifdef YYMALLOC
16513 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
16514 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
16515 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
16516                            (n)->u3.cnt = (c), (p))
16517 
16518 void *
16519 rb_parser_malloc(struct parser_params *parser, size_t size)
16520 {
16521     size_t cnt = HEAPCNT(1, size);
16522     NODE *n = NEWHEAP();
16523     void *ptr = xmalloc(size);
16524 
16525     return ADD2HEAP(n, cnt, ptr);
16526 }
16527 
16528 void *
16529 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
16530 {
16531     size_t cnt = HEAPCNT(nelem, size);
16532     NODE *n = NEWHEAP();
16533     void *ptr = xcalloc(nelem, size);
16534 
16535     return ADD2HEAP(n, cnt, ptr);
16536 }
16537 
16538 void *
16539 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
16540 {
16541     NODE *n;
16542     size_t cnt = HEAPCNT(1, size);
16543 
16544     if (ptr && (n = parser->heap) != NULL) {
16545         do {
16546             if (n->u1.node == ptr) {
16547                 n->u1.node = ptr = xrealloc(ptr, size);
16548                 if (n->u3.cnt) n->u3.cnt = cnt;
16549                 return ptr;
16550             }
16551         } while ((n = n->u2.node) != NULL);
16552     }
16553     n = NEWHEAP();
16554     ptr = xrealloc(ptr, size);
16555     return ADD2HEAP(n, cnt, ptr);
16556 }
16557 
16558 void
16559 rb_parser_free(struct parser_params *parser, void *ptr)
16560 {
16561     NODE **prev = &parser->heap, *n;
16562 
16563     while ((n = *prev) != NULL) {
16564         if (n->u1.node == ptr) {
16565             *prev = n->u2.node;
16566             rb_gc_force_recycle((VALUE)n);
16567             break;
16568         }
16569         prev = &n->u2.node;
16570     }
16571     xfree(ptr);
16572 }
16573 #endif
16574 #endif
16575 
16576 #ifdef RIPPER
16577 #ifdef RIPPER_DEBUG
16578 extern int rb_is_pointer_to_heap(VALUE);
16579 
16580 /* :nodoc: */
16581 static VALUE
16582 ripper_validate_object(VALUE self, VALUE x)
16583 {
16584     if (x == Qfalse) return x;
16585     if (x == Qtrue) return x;
16586     if (x == Qnil) return x;
16587     if (x == Qundef)
16588         rb_raise(rb_eArgError, "Qundef given");
16589     if (FIXNUM_P(x)) return x;
16590     if (SYMBOL_P(x)) return x;
16591     if (!rb_is_pointer_to_heap(x))
16592         rb_raise(rb_eArgError, "invalid pointer: %p", x);
16593     switch (TYPE(x)) {
16594       case T_STRING:
16595       case T_OBJECT:
16596       case T_ARRAY:
16597       case T_BIGNUM:
16598       case T_FLOAT:
16599         return x;
16600       case T_NODE:
16601         if (nd_type(x) != NODE_LASGN) {
16602             rb_raise(rb_eArgError, "NODE given: %p", x);
16603         }
16604         return ((NODE *)x)->nd_rval;
16605       default:
16606         rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
16607                  x, rb_obj_classname(x));
16608     }
16609     return x;
16610 }
16611 #endif
16612 
16613 #define validate(x) ((x) = get_value(x))
16614 
16615 static VALUE
16616 ripper_dispatch0(struct parser_params *parser, ID mid)
16617 {
16618     return rb_funcall(parser->value, mid, 0);
16619 }
16620 
16621 static VALUE
16622 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
16623 {
16624     validate(a);
16625     return rb_funcall(parser->value, mid, 1, a);
16626 }
16627 
16628 static VALUE
16629 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
16630 {
16631     validate(a);
16632     validate(b);
16633     return rb_funcall(parser->value, mid, 2, a, b);
16634 }
16635 
16636 static VALUE
16637 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
16638 {
16639     validate(a);
16640     validate(b);
16641     validate(c);
16642     return rb_funcall(parser->value, mid, 3, a, b, c);
16643 }
16644 
16645 static VALUE
16646 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
16647 {
16648     validate(a);
16649     validate(b);
16650     validate(c);
16651     validate(d);
16652     return rb_funcall(parser->value, mid, 4, a, b, c, d);
16653 }
16654 
16655 static VALUE
16656 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
16657 {
16658     validate(a);
16659     validate(b);
16660     validate(c);
16661     validate(d);
16662     validate(e);
16663     return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
16664 }
16665 
16666 static VALUE
16667 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
16668 {
16669     validate(a);
16670     validate(b);
16671     validate(c);
16672     validate(d);
16673     validate(e);
16674     validate(f);
16675     validate(g);
16676     return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
16677 }
16678 
16679 static const struct kw_assoc {
16680     ID id;
16681     const char *name;
16682 } keyword_to_name[] = {
16683     {keyword_class,     "class"},
16684     {keyword_module,    "module"},
16685     {keyword_def,       "def"},
16686     {keyword_undef,     "undef"},
16687     {keyword_begin,     "begin"},
16688     {keyword_rescue,    "rescue"},
16689     {keyword_ensure,    "ensure"},
16690     {keyword_end,       "end"},
16691     {keyword_if,        "if"},
16692     {keyword_unless,    "unless"},
16693     {keyword_then,      "then"},
16694     {keyword_elsif,     "elsif"},
16695     {keyword_else,      "else"},
16696     {keyword_case,      "case"},
16697     {keyword_when,      "when"},
16698     {keyword_while,     "while"},
16699     {keyword_until,     "until"},
16700     {keyword_for,       "for"},
16701     {keyword_break,     "break"},
16702     {keyword_next,      "next"},
16703     {keyword_redo,      "redo"},
16704     {keyword_retry,     "retry"},
16705     {keyword_in,        "in"},
16706     {keyword_do,        "do"},
16707     {keyword_do_cond,   "do"},
16708     {keyword_do_block,  "do"},
16709     {keyword_return,    "return"},
16710     {keyword_yield,     "yield"},
16711     {keyword_super,     "super"},
16712     {keyword_self,      "self"},
16713     {keyword_nil,       "nil"},
16714     {keyword_true,      "true"},
16715     {keyword_false,     "false"},
16716     {keyword_and,       "and"},
16717     {keyword_or,        "or"},
16718     {keyword_not,       "not"},
16719     {modifier_if,       "if"},
16720     {modifier_unless,   "unless"},
16721     {modifier_while,    "while"},
16722     {modifier_until,    "until"},
16723     {modifier_rescue,   "rescue"},
16724     {keyword_alias,     "alias"},
16725     {keyword_defined,   "defined?"},
16726     {keyword_BEGIN,     "BEGIN"},
16727     {keyword_END,       "END"},
16728     {keyword__LINE__,   "__LINE__"},
16729     {keyword__FILE__,   "__FILE__"},
16730     {keyword__ENCODING__, "__ENCODING__"},
16731     {0, NULL}
16732 };
16733 
16734 static const char*
16735 keyword_id_to_str(ID id)
16736 {
16737     const struct kw_assoc *a;
16738 
16739     for (a = keyword_to_name; a->id; a++) {
16740         if (a->id == id)
16741             return a->name;
16742     }
16743     return NULL;
16744 }
16745 
16746 #undef ripper_id2sym
16747 static VALUE
16748 ripper_id2sym(ID id)
16749 {
16750     const char *name;
16751     char buf[8];
16752 
16753     if (id <= 256) {
16754         buf[0] = (char)id;
16755         buf[1] = '\0';
16756         return ID2SYM(rb_intern2(buf, 1));
16757     }
16758     if ((name = keyword_id_to_str(id))) {
16759         return ID2SYM(rb_intern(name));
16760     }
16761     switch (id) {
16762       case tOROP:
16763         name = "||";
16764         break;
16765       case tANDOP:
16766         name = "&&";
16767         break;
16768       default:
16769         name = rb_id2name(id);
16770         if (!name) {
16771             rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
16772         }
16773         return ID2SYM(id);
16774     }
16775     return ID2SYM(rb_intern(name));
16776 }
16777 
16778 static ID
16779 ripper_get_id(VALUE v)
16780 {
16781     NODE *nd;
16782     if (!RB_TYPE_P(v, T_NODE)) return 0;
16783     nd = (NODE *)v;
16784     if (nd_type(nd) != NODE_LASGN) return 0;
16785     return nd->nd_vid;
16786 }
16787 
16788 static VALUE
16789 ripper_get_value(VALUE v)
16790 {
16791     NODE *nd;
16792     if (v == Qundef) return Qnil;
16793     if (!RB_TYPE_P(v, T_NODE)) return v;
16794     nd = (NODE *)v;
16795     if (nd_type(nd) != NODE_LASGN) return Qnil;
16796     return nd->nd_rval;
16797 }
16798 
16799 static void
16800 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
16801 {
16802     VALUE str;
16803     va_list args;
16804 
16805     va_start(args, fmt);
16806     str = rb_vsprintf(fmt, args);
16807     va_end(args);
16808     rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
16809 }
16810 
16811 static void
16812 ripper_warn0(struct parser_params *parser, const char *fmt)
16813 {
16814     rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
16815 }
16816 
16817 static void
16818 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
16819 {
16820     rb_funcall(parser->value, rb_intern("warn"), 2,
16821                STR_NEW2(fmt), INT2NUM(a));
16822 }
16823 
16824 static void
16825 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
16826 {
16827     rb_funcall(parser->value, rb_intern("warn"), 2,
16828                STR_NEW2(fmt), STR_NEW2(str));
16829 }
16830 
16831 static void
16832 ripper_warning0(struct parser_params *parser, const char *fmt)
16833 {
16834     rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
16835 }
16836 
16837 static void
16838 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
16839 {
16840     rb_funcall(parser->value, rb_intern("warning"), 2,
16841                STR_NEW2(fmt), STR_NEW2(str));
16842 }
16843 
16844 static VALUE
16845 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
16846 {
16847     return rb_io_gets(src);
16848 }
16849 
16850 static VALUE
16851 ripper_s_allocate(VALUE klass)
16852 {
16853     struct parser_params *p;
16854     VALUE self;
16855 
16856     p = ALLOC_N(struct parser_params, 1);
16857     MEMZERO(p, struct parser_params, 1);
16858     self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
16859     p->value = self;
16860     return self;
16861 }
16862 
16863 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
16864 
16865 /*
16866  *  call-seq:
16867  *    Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
16868  *
16869  *  Create a new Ripper object.
16870  *  _src_ must be a String, an IO, or an Object which has #gets method.
16871  *
16872  *  This method does not starts parsing.
16873  *  See also Ripper#parse and Ripper.parse.
16874  */
16875 static VALUE
16876 ripper_initialize(int argc, VALUE *argv, VALUE self)
16877 {
16878     struct parser_params *parser;
16879     VALUE src, fname, lineno;
16880 
16881     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16882     rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
16883     if (RB_TYPE_P(src, T_FILE)) {
16884         parser->parser_lex_gets = ripper_lex_get_generic;
16885     }
16886     else {
16887         StringValue(src);
16888         parser->parser_lex_gets = lex_get_str;
16889     }
16890     parser->parser_lex_input = src;
16891     parser->eofp = Qfalse;
16892     if (NIL_P(fname)) {
16893         fname = STR_NEW2("(ripper)");
16894     }
16895     else {
16896         StringValue(fname);
16897     }
16898     parser_initialize(parser);
16899 
16900     parser->parser_ruby_sourcefile_string = fname;
16901     parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
16902     parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
16903 
16904     return Qnil;
16905 }
16906 
16907 struct ripper_args {
16908     struct parser_params *parser;
16909     int argc;
16910     VALUE *argv;
16911 };
16912 
16913 static VALUE
16914 ripper_parse0(VALUE parser_v)
16915 {
16916     struct parser_params *parser;
16917 
16918     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16919     parser_prepare(parser);
16920     ripper_yyparse((void*)parser);
16921     return parser->result;
16922 }
16923 
16924 static VALUE
16925 ripper_ensure(VALUE parser_v)
16926 {
16927     struct parser_params *parser;
16928 
16929     TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16930     parser->parsing_thread = Qnil;
16931     return Qnil;
16932 }
16933 
16934 /*
16935  *  call-seq:
16936  *    ripper#parse
16937  *
16938  *  Start parsing and returns the value of the root action.
16939  */
16940 static VALUE
16941 ripper_parse(VALUE self)
16942 {
16943     struct parser_params *parser;
16944 
16945     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16946     if (!ripper_initialized_p(parser)) {
16947         rb_raise(rb_eArgError, "method called for uninitialized object");
16948     }
16949     if (!NIL_P(parser->parsing_thread)) {
16950         if (parser->parsing_thread == rb_thread_current())
16951             rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
16952         else
16953             rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
16954     }
16955     parser->parsing_thread = rb_thread_current();
16956     rb_ensure(ripper_parse0, self, ripper_ensure, self);
16957 
16958     return parser->result;
16959 }
16960 
16961 /*
16962  *  call-seq:
16963  *    ripper#column   -> Integer
16964  *
16965  *  Return column number of current parsing line.
16966  *  This number starts from 0.
16967  */
16968 static VALUE
16969 ripper_column(VALUE self)
16970 {
16971     struct parser_params *parser;
16972     long col;
16973 
16974     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16975     if (!ripper_initialized_p(parser)) {
16976         rb_raise(rb_eArgError, "method called for uninitialized object");
16977     }
16978     if (NIL_P(parser->parsing_thread)) return Qnil;
16979     col = parser->tokp - parser->parser_lex_pbeg;
16980     return LONG2NUM(col);
16981 }
16982 
16983 /*
16984  *  call-seq:
16985  *    ripper#filename   -> String
16986  *
16987  *  Return current parsing filename.
16988  */
16989 static VALUE
16990 ripper_filename(VALUE self)
16991 {
16992     struct parser_params *parser;
16993 
16994     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16995     if (!ripper_initialized_p(parser)) {
16996         rb_raise(rb_eArgError, "method called for uninitialized object");
16997     }
16998     return parser->parser_ruby_sourcefile_string;
16999 }
17000 
17001 /*
17002  *  call-seq:
17003  *    ripper#lineno   -> Integer
17004  *
17005  *  Return line number of current parsing line.
17006  *  This number starts from 1.
17007  */
17008 static VALUE
17009 ripper_lineno(VALUE self)
17010 {
17011     struct parser_params *parser;
17012 
17013     TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17014     if (!ripper_initialized_p(parser)) {
17015         rb_raise(rb_eArgError, "method called for uninitialized object");
17016     }
17017     if (NIL_P(parser->parsing_thread)) return Qnil;
17018     return INT2NUM(parser->parser_ruby_sourceline);
17019 }
17020 
17021 #ifdef RIPPER_DEBUG
17022 /* :nodoc: */
17023 static VALUE
17024 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17025 {
17026     StringValue(msg);
17027     if (obj == Qundef) {
17028         rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17029     }
17030     return Qnil;
17031 }
17032 
17033 /* :nodoc: */
17034 static VALUE
17035 ripper_value(VALUE self, VALUE obj)
17036 {
17037     return ULONG2NUM(obj);
17038 }
17039 #endif
17040 
17041 
17042 void
17043 Init_ripper(void)
17044 {
17045     parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17046 
17047     ripper_init_eventids1();
17048     ripper_init_eventids2();
17049     /* ensure existing in symbol table */
17050     (void)rb_intern("||");
17051     (void)rb_intern("&&");
17052 
17053     InitVM(ripper);
17054 }
17055 
17056 void
17057 InitVM_ripper(void)
17058 {
17059     VALUE Ripper;
17060 
17061     Ripper = rb_define_class("Ripper", rb_cObject);
17062     rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17063     rb_define_alloc_func(Ripper, ripper_s_allocate);
17064     rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17065     rb_define_method(Ripper, "parse", ripper_parse, 0);
17066     rb_define_method(Ripper, "column", ripper_column, 0);
17067     rb_define_method(Ripper, "filename", ripper_filename, 0);
17068     rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17069     rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17070     rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17071     rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17072     rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17073 #ifdef RIPPER_DEBUG
17074     rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17075     rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17076     rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17077 #endif
17078 
17079     ripper_init_eventids1_table(Ripper);
17080     ripper_init_eventids2_table(Ripper);
17081 
17082 # if 0
17083     /* Hack to let RDoc document SCRIPT_LINES__ */
17084 
17085     /*
17086      * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
17087      * after the assignment will be added as an Array of lines with the file
17088      * name as the key.
17089      */
17090     rb_define_global_const("SCRIPT_LINES__", Qnil);
17091 #endif
17092 
17093 }
17094 #endif /* RIPPER */
17095 
17096