github.com/rohankumardubey/syslog-redirector-golang@v0.0.0-20140320174030-4859f03d829a/src/cmd/gc/y.tab.c (about)

     1  /* A Bison parser, made by GNU Bison 2.5.  */
     2  
     3  /* Bison implementation for Yacc-like parsers in C
     4     
     5        Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
     6     
     7     This program is free software: you can redistribute it and/or modify
     8     it under the terms of the GNU General Public License as published by
     9     the Free Software Foundation, either version 3 of the License, or
    10     (at your option) any later version.
    11     
    12     This program is distributed in the hope that it will be useful,
    13     but WITHOUT ANY WARRANTY; without even the implied warranty of
    14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15     GNU General Public License for more details.
    16     
    17     You should have received a copy of the GNU General Public License
    18     along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
    19  
    20  /* As a special exception, you may create a larger work that contains
    21     part or all of the Bison parser skeleton and distribute that work
    22     under terms of your choice, so long as that work isn't itself a
    23     parser generator using the skeleton or a modified version thereof
    24     as a parser skeleton.  Alternatively, if you modify or redistribute
    25     the parser skeleton itself, you may (at your option) remove this
    26     special exception, which will cause the skeleton and the resulting
    27     Bison output files to be licensed under the GNU General Public
    28     License without this special exception.
    29     
    30     This special exception was added by the Free Software Foundation in
    31     version 2.2 of Bison.  */
    32  
    33  /* C LALR(1) parser skeleton written by Richard Stallman, by
    34     simplifying the original so-called "semantic" parser.  */
    35  
    36  /* All symbols defined below should begin with yy or YY, to avoid
    37     infringing on user name space.  This should be done even for local
    38     variables, as they might otherwise be expanded by user macros.
    39     There are some unavoidable exceptions within include files to
    40     define necessary library symbols; they are noted "INFRINGES ON
    41     USER NAME SPACE" below.  */
    42  
    43  /* Identify Bison output.  */
    44  #define YYBISON 1
    45  
    46  /* Bison version.  */
    47  #define YYBISON_VERSION "2.5"
    48  
    49  /* Skeleton name.  */
    50  #define YYSKELETON_NAME "yacc.c"
    51  
    52  /* Pure parsers.  */
    53  #define YYPURE 0
    54  
    55  /* Push parsers.  */
    56  #define YYPUSH 0
    57  
    58  /* Pull parsers.  */
    59  #define YYPULL 1
    60  
    61  /* Using locations.  */
    62  #define YYLSP_NEEDED 0
    63  
    64  
    65  
    66  /* Copy the first part of user declarations.  */
    67  
    68  /* Line 268 of yacc.c  */
    69  #line 20 "go.y"
    70  
    71  #include <u.h>
    72  #include <stdio.h>	/* if we don't, bison will, and go.h re-#defines getc */
    73  #include <libc.h>
    74  #include "go.h"
    75  
    76  static void fixlbrace(int);
    77  
    78  
    79  /* Line 268 of yacc.c  */
    80  #line 81 "y.tab.c"
    81  
    82  /* Enabling traces.  */
    83  #ifndef YYDEBUG
    84  # define YYDEBUG 0
    85  #endif
    86  
    87  /* Enabling verbose error messages.  */
    88  #ifdef YYERROR_VERBOSE
    89  # undef YYERROR_VERBOSE
    90  # define YYERROR_VERBOSE 1
    91  #else
    92  # define YYERROR_VERBOSE 1
    93  #endif
    94  
    95  /* Enabling the token table.  */
    96  #ifndef YYTOKEN_TABLE
    97  # define YYTOKEN_TABLE 0
    98  #endif
    99  
   100  
   101  /* Tokens.  */
   102  #ifndef YYTOKENTYPE
   103  # define YYTOKENTYPE
   104     /* Put the tokens into the symbol table, so that GDB and other debuggers
   105        know about them.  */
   106     enum yytokentype {
   107       LLITERAL = 258,
   108       LASOP = 259,
   109       LCOLAS = 260,
   110       LBREAK = 261,
   111       LCASE = 262,
   112       LCHAN = 263,
   113       LCONST = 264,
   114       LCONTINUE = 265,
   115       LDDD = 266,
   116       LDEFAULT = 267,
   117       LDEFER = 268,
   118       LELSE = 269,
   119       LFALL = 270,
   120       LFOR = 271,
   121       LFUNC = 272,
   122       LGO = 273,
   123       LGOTO = 274,
   124       LIF = 275,
   125       LIMPORT = 276,
   126       LINTERFACE = 277,
   127       LMAP = 278,
   128       LNAME = 279,
   129       LPACKAGE = 280,
   130       LRANGE = 281,
   131       LRETURN = 282,
   132       LSELECT = 283,
   133       LSTRUCT = 284,
   134       LSWITCH = 285,
   135       LTYPE = 286,
   136       LVAR = 287,
   137       LANDAND = 288,
   138       LANDNOT = 289,
   139       LBODY = 290,
   140       LCOMM = 291,
   141       LDEC = 292,
   142       LEQ = 293,
   143       LGE = 294,
   144       LGT = 295,
   145       LIGNORE = 296,
   146       LINC = 297,
   147       LLE = 298,
   148       LLSH = 299,
   149       LLT = 300,
   150       LNE = 301,
   151       LOROR = 302,
   152       LRSH = 303,
   153       NotPackage = 304,
   154       NotParen = 305,
   155       PreferToRightParen = 306
   156     };
   157  #endif
   158  /* Tokens.  */
   159  #define LLITERAL 258
   160  #define LASOP 259
   161  #define LCOLAS 260
   162  #define LBREAK 261
   163  #define LCASE 262
   164  #define LCHAN 263
   165  #define LCONST 264
   166  #define LCONTINUE 265
   167  #define LDDD 266
   168  #define LDEFAULT 267
   169  #define LDEFER 268
   170  #define LELSE 269
   171  #define LFALL 270
   172  #define LFOR 271
   173  #define LFUNC 272
   174  #define LGO 273
   175  #define LGOTO 274
   176  #define LIF 275
   177  #define LIMPORT 276
   178  #define LINTERFACE 277
   179  #define LMAP 278
   180  #define LNAME 279
   181  #define LPACKAGE 280
   182  #define LRANGE 281
   183  #define LRETURN 282
   184  #define LSELECT 283
   185  #define LSTRUCT 284
   186  #define LSWITCH 285
   187  #define LTYPE 286
   188  #define LVAR 287
   189  #define LANDAND 288
   190  #define LANDNOT 289
   191  #define LBODY 290
   192  #define LCOMM 291
   193  #define LDEC 292
   194  #define LEQ 293
   195  #define LGE 294
   196  #define LGT 295
   197  #define LIGNORE 296
   198  #define LINC 297
   199  #define LLE 298
   200  #define LLSH 299
   201  #define LLT 300
   202  #define LNE 301
   203  #define LOROR 302
   204  #define LRSH 303
   205  #define NotPackage 304
   206  #define NotParen 305
   207  #define PreferToRightParen 306
   208  
   209  
   210  
   211  
   212  #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
   213  typedef union YYSTYPE
   214  {
   215  
   216  /* Line 293 of yacc.c  */
   217  #line 28 "go.y"
   218  
   219  	Node*		node;
   220  	NodeList*		list;
   221  	Type*		type;
   222  	Sym*		sym;
   223  	struct	Val	val;
   224  	int		i;
   225  
   226  
   227  
   228  /* Line 293 of yacc.c  */
   229  #line 230 "y.tab.c"
   230  } YYSTYPE;
   231  # define YYSTYPE_IS_TRIVIAL 1
   232  # define yystype YYSTYPE /* obsolescent; will be withdrawn */
   233  # define YYSTYPE_IS_DECLARED 1
   234  #endif
   235  
   236  
   237  /* Copy the second part of user declarations.  */
   238  
   239  
   240  /* Line 343 of yacc.c  */
   241  #line 242 "y.tab.c"
   242  
   243  #ifdef short
   244  # undef short
   245  #endif
   246  
   247  #ifdef YYTYPE_UINT8
   248  typedef YYTYPE_UINT8 yytype_uint8;
   249  #else
   250  typedef unsigned char yytype_uint8;
   251  #endif
   252  
   253  #ifdef YYTYPE_INT8
   254  typedef YYTYPE_INT8 yytype_int8;
   255  #elif (defined __STDC__ || defined __C99__FUNC__ \
   256       || defined __cplusplus || defined _MSC_VER)
   257  typedef signed char yytype_int8;
   258  #else
   259  typedef short int yytype_int8;
   260  #endif
   261  
   262  #ifdef YYTYPE_UINT16
   263  typedef YYTYPE_UINT16 yytype_uint16;
   264  #else
   265  typedef unsigned short int yytype_uint16;
   266  #endif
   267  
   268  #ifdef YYTYPE_INT16
   269  typedef YYTYPE_INT16 yytype_int16;
   270  #else
   271  typedef short int yytype_int16;
   272  #endif
   273  
   274  #ifndef YYSIZE_T
   275  # ifdef __SIZE_TYPE__
   276  #  define YYSIZE_T __SIZE_TYPE__
   277  # elif defined size_t
   278  #  define YYSIZE_T size_t
   279  # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
   280       || defined __cplusplus || defined _MSC_VER)
   281  #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
   282  #  define YYSIZE_T size_t
   283  # else
   284  #  define YYSIZE_T unsigned int
   285  # endif
   286  #endif
   287  
   288  #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
   289  
   290  #ifndef YY_
   291  # if defined YYENABLE_NLS && YYENABLE_NLS
   292  #  if ENABLE_NLS
   293  #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
   294  #   define YY_(msgid) dgettext ("bison-runtime", msgid)
   295  #  endif
   296  # endif
   297  # ifndef YY_
   298  #  define YY_(msgid) msgid
   299  # endif
   300  #endif
   301  
   302  /* Suppress unused-variable warnings by "using" E.  */
   303  #if ! defined lint || defined __GNUC__
   304  # define YYUSE(e) ((void) (e))
   305  #else
   306  # define YYUSE(e) /* empty */
   307  #endif
   308  
   309  /* Identity function, used to suppress warnings about constant conditions.  */
   310  #ifndef lint
   311  # define YYID(n) (n)
   312  #else
   313  #if (defined __STDC__ || defined __C99__FUNC__ \
   314       || defined __cplusplus || defined _MSC_VER)
   315  static int
   316  YYID (int yyi)
   317  #else
   318  static int
   319  YYID (yyi)
   320      int yyi;
   321  #endif
   322  {
   323    return yyi;
   324  }
   325  #endif
   326  
   327  #if ! defined yyoverflow || YYERROR_VERBOSE
   328  
   329  /* The parser invokes alloca or malloc; define the necessary symbols.  */
   330  
   331  # ifdef YYSTACK_USE_ALLOCA
   332  #  if YYSTACK_USE_ALLOCA
   333  #   ifdef __GNUC__
   334  #    define YYSTACK_ALLOC __builtin_alloca
   335  #   elif defined __BUILTIN_VA_ARG_INCR
   336  #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
   337  #   elif defined _AIX
   338  #    define YYSTACK_ALLOC __alloca
   339  #   elif defined _MSC_VER
   340  #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
   341  #    define alloca _alloca
   342  #   else
   343  #    define YYSTACK_ALLOC alloca
   344  #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
   345       || defined __cplusplus || defined _MSC_VER)
   346  #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
   347  #     ifndef EXIT_SUCCESS
   348  #      define EXIT_SUCCESS 0
   349  #     endif
   350  #    endif
   351  #   endif
   352  #  endif
   353  # endif
   354  
   355  # ifdef YYSTACK_ALLOC
   356     /* Pacify GCC's `empty if-body' warning.  */
   357  #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
   358  #  ifndef YYSTACK_ALLOC_MAXIMUM
   359      /* The OS might guarantee only one guard page at the bottom of the stack,
   360         and a page size can be as small as 4096 bytes.  So we cannot safely
   361         invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
   362         to allow for a few compiler-allocated temporary stack slots.  */
   363  #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
   364  #  endif
   365  # else
   366  #  define YYSTACK_ALLOC YYMALLOC
   367  #  define YYSTACK_FREE YYFREE
   368  #  ifndef YYSTACK_ALLOC_MAXIMUM
   369  #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
   370  #  endif
   371  #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
   372         && ! ((defined YYMALLOC || defined malloc) \
   373  	     && (defined YYFREE || defined free)))
   374  #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
   375  #   ifndef EXIT_SUCCESS
   376  #    define EXIT_SUCCESS 0
   377  #   endif
   378  #  endif
   379  #  ifndef YYMALLOC
   380  #   define YYMALLOC malloc
   381  #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
   382       || defined __cplusplus || defined _MSC_VER)
   383  void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
   384  #   endif
   385  #  endif
   386  #  ifndef YYFREE
   387  #   define YYFREE free
   388  #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
   389       || defined __cplusplus || defined _MSC_VER)
   390  void free (void *); /* INFRINGES ON USER NAME SPACE */
   391  #   endif
   392  #  endif
   393  # endif
   394  #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
   395  
   396  
   397  #if (! defined yyoverflow \
   398       && (! defined __cplusplus \
   399  	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
   400  
   401  /* A type that is properly aligned for any stack member.  */
   402  union yyalloc
   403  {
   404    yytype_int16 yyss_alloc;
   405    YYSTYPE yyvs_alloc;
   406  };
   407  
   408  /* The size of the maximum gap between one aligned stack and the next.  */
   409  # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
   410  
   411  /* The size of an array large to enough to hold all stacks, each with
   412     N elements.  */
   413  # define YYSTACK_BYTES(N) \
   414       ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
   415        + YYSTACK_GAP_MAXIMUM)
   416  
   417  # define YYCOPY_NEEDED 1
   418  
   419  /* Relocate STACK from its old location to the new one.  The
   420     local variables YYSIZE and YYSTACKSIZE give the old and new number of
   421     elements in the stack, and YYPTR gives the new location of the
   422     stack.  Advance YYPTR to a properly aligned location for the next
   423     stack.  */
   424  # define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
   425      do									\
   426        {									\
   427  	YYSIZE_T yynewbytes;						\
   428  	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
   429  	Stack = &yyptr->Stack_alloc;					\
   430  	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
   431  	yyptr += yynewbytes / sizeof (*yyptr);				\
   432        }									\
   433      while (YYID (0))
   434  
   435  #endif
   436  
   437  #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
   438  /* Copy COUNT objects from FROM to TO.  The source and destination do
   439     not overlap.  */
   440  # ifndef YYCOPY
   441  #  if defined __GNUC__ && 1 < __GNUC__
   442  #   define YYCOPY(To, From, Count) \
   443        __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
   444  #  else
   445  #   define YYCOPY(To, From, Count)		\
   446        do					\
   447  	{					\
   448  	  YYSIZE_T yyi;				\
   449  	  for (yyi = 0; yyi < (Count); yyi++)	\
   450  	    (To)[yyi] = (From)[yyi];		\
   451  	}					\
   452        while (YYID (0))
   453  #  endif
   454  # endif
   455  #endif /* !YYCOPY_NEEDED */
   456  
   457  /* YYFINAL -- State number of the termination state.  */
   458  #define YYFINAL  4
   459  /* YYLAST -- Last index in YYTABLE.  */
   460  #define YYLAST   2270
   461  
   462  /* YYNTOKENS -- Number of terminals.  */
   463  #define YYNTOKENS  76
   464  /* YYNNTS -- Number of nonterminals.  */
   465  #define YYNNTS  142
   466  /* YYNRULES -- Number of rules.  */
   467  #define YYNRULES  351
   468  /* YYNRULES -- Number of states.  */
   469  #define YYNSTATES  667
   470  
   471  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
   472  #define YYUNDEFTOK  2
   473  #define YYMAXUTOK   306
   474  
   475  #define YYTRANSLATE(YYX)						\
   476    ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
   477  
   478  /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
   479  static const yytype_uint8 yytranslate[] =
   480  {
   481         0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   482         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   483         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   484         2,     2,     2,    69,     2,     2,    64,    55,    56,     2,
   485        59,    60,    53,    49,    75,    50,    63,    54,     2,     2,
   486         2,     2,     2,     2,     2,     2,     2,     2,    66,    62,
   487         2,    65,     2,    73,    74,     2,     2,     2,     2,     2,
   488         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   489         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   490         2,    71,     2,    72,    52,     2,     2,     2,     2,     2,
   491         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   492         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   493         2,     2,     2,    67,    51,    68,    70,     2,     2,     2,
   494         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   495         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   496         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   497         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   498         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   499         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   500         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   501         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   502         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   503         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   504         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   505         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   506         2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
   507         5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
   508        15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
   509        25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
   510        35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
   511        45,    46,    47,    48,    57,    58,    61
   512  };
   513  
   514  #if YYDEBUG
   515  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
   516     YYRHS.  */
   517  static const yytype_uint16 yyprhs[] =
   518  {
   519         0,     0,     3,     8,     9,    13,    14,    18,    19,    23,
   520        26,    32,    36,    40,    43,    45,    49,    51,    54,    57,
   521        62,    63,    65,    66,    71,    72,    74,    76,    78,    80,
   522        83,    89,    93,    96,   102,   110,   114,   117,   123,   127,
   523       129,   132,   137,   141,   146,   150,   152,   155,   157,   159,
   524       162,   164,   168,   172,   176,   179,   182,   186,   192,   198,
   525       201,   202,   207,   208,   212,   213,   216,   217,   222,   227,
   526       232,   238,   240,   242,   245,   246,   250,   252,   256,   257,
   527       258,   259,   268,   269,   275,   276,   279,   280,   283,   284,
   528       285,   293,   294,   300,   302,   306,   310,   314,   318,   322,
   529       326,   330,   334,   338,   342,   346,   350,   354,   358,   362,
   530       366,   370,   374,   378,   382,   384,   387,   390,   393,   396,
   531       399,   402,   405,   408,   412,   418,   425,   427,   429,   433,
   532       439,   445,   450,   457,   466,   468,   474,   480,   486,   494,
   533       496,   497,   501,   503,   508,   510,   515,   517,   521,   523,
   534       525,   527,   529,   531,   533,   535,   536,   538,   540,   542,
   535       544,   549,   554,   556,   558,   560,   563,   565,   567,   569,
   536       571,   573,   577,   579,   581,   583,   586,   588,   590,   592,
   537       594,   598,   600,   602,   604,   606,   608,   610,   612,   614,
   538       616,   620,   625,   630,   633,   637,   643,   645,   647,   650,
   539       654,   660,   664,   670,   674,   678,   684,   693,   699,   708,
   540       714,   715,   719,   720,   722,   726,   728,   733,   736,   737,
   541       741,   743,   747,   749,   753,   755,   759,   761,   765,   767,
   542       771,   775,   778,   783,   787,   793,   799,   801,   805,   807,
   543       810,   812,   816,   821,   823,   826,   829,   831,   833,   837,
   544       838,   841,   842,   844,   846,   848,   850,   852,   854,   856,
   545       858,   860,   861,   866,   868,   871,   874,   877,   880,   883,
   546       886,   888,   892,   894,   898,   900,   904,   906,   910,   912,
   547       916,   918,   920,   924,   928,   929,   932,   933,   935,   936,
   548       938,   939,   941,   942,   944,   945,   947,   948,   950,   951,
   549       953,   954,   956,   957,   959,   964,   969,   975,   982,   987,
   550       992,   994,   996,   998,  1000,  1002,  1004,  1006,  1008,  1010,
   551      1014,  1019,  1025,  1030,  1035,  1038,  1041,  1046,  1050,  1054,
   552      1060,  1064,  1069,  1073,  1079,  1081,  1082,  1084,  1088,  1090,
   553      1092,  1095,  1097,  1099,  1105,  1106,  1109,  1111,  1115,  1117,
   554      1121,  1123
   555  };
   556  
   557  /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
   558  static const yytype_int16 yyrhs[] =
   559  {
   560        77,     0,    -1,    79,    78,    81,   166,    -1,    -1,    25,
   561       141,    62,    -1,    -1,    80,    86,    88,    -1,    -1,    81,
   562        82,    62,    -1,    21,    83,    -1,    21,    59,    84,   190,
   563        60,    -1,    21,    59,    60,    -1,    85,    86,    88,    -1,
   564        85,    88,    -1,    83,    -1,    84,    62,    83,    -1,     3,
   565        -1,   141,     3,    -1,    63,     3,    -1,    25,    24,    87,
   566        62,    -1,    -1,    24,    -1,    -1,    89,   214,    64,    64,
   567        -1,    -1,    91,    -1,   158,    -1,   181,    -1,     1,    -1,
   568        32,    93,    -1,    32,    59,   167,   190,    60,    -1,    32,
   569        59,    60,    -1,    92,    94,    -1,    92,    59,    94,   190,
   570        60,    -1,    92,    59,    94,    62,   168,   190,    60,    -1,
   571        92,    59,    60,    -1,    31,    97,    -1,    31,    59,   169,
   572       190,    60,    -1,    31,    59,    60,    -1,     9,    -1,   185,
   573       146,    -1,   185,   146,    65,   186,    -1,   185,    65,   186,
   574        -1,   185,   146,    65,   186,    -1,   185,    65,   186,    -1,
   575        94,    -1,   185,   146,    -1,   185,    -1,   141,    -1,    96,
   576       146,    -1,   126,    -1,   126,     4,   126,    -1,   186,    65,
   577       186,    -1,   186,     5,   186,    -1,   126,    42,    -1,   126,
   578        37,    -1,     7,   187,    66,    -1,     7,   187,    65,   126,
   579        66,    -1,     7,   187,     5,   126,    66,    -1,    12,    66,
   580        -1,    -1,    67,   101,   183,    68,    -1,    -1,    99,   103,
   581       183,    -1,    -1,   104,   102,    -1,    -1,    35,   106,   183,
   582        68,    -1,   186,    65,    26,   126,    -1,   186,     5,    26,
   583       126,    -1,   194,    62,   194,    62,   194,    -1,   194,    -1,
   584       107,    -1,   108,   105,    -1,    -1,    16,   111,   109,    -1,
   585       194,    -1,   194,    62,   194,    -1,    -1,    -1,    -1,    20,
   586       114,   112,   115,   105,   116,   119,   120,    -1,    -1,    14,
   587        20,   118,   112,   105,    -1,    -1,   119,   117,    -1,    -1,
   588        14,   100,    -1,    -1,    -1,    30,   122,   112,   123,    35,
   589       104,    68,    -1,    -1,    28,   125,    35,   104,    68,    -1,
   590       127,    -1,   126,    47,   126,    -1,   126,    33,   126,    -1,
   591       126,    38,   126,    -1,   126,    46,   126,    -1,   126,    45,
   592       126,    -1,   126,    43,   126,    -1,   126,    39,   126,    -1,
   593       126,    40,   126,    -1,   126,    49,   126,    -1,   126,    50,
   594       126,    -1,   126,    51,   126,    -1,   126,    52,   126,    -1,
   595       126,    53,   126,    -1,   126,    54,   126,    -1,   126,    55,
   596       126,    -1,   126,    56,   126,    -1,   126,    34,   126,    -1,
   597       126,    44,   126,    -1,   126,    48,   126,    -1,   126,    36,
   598       126,    -1,   134,    -1,    53,   127,    -1,    56,   127,    -1,
   599        49,   127,    -1,    50,   127,    -1,    69,   127,    -1,    70,
   600       127,    -1,    52,   127,    -1,    36,   127,    -1,   134,    59,
   601        60,    -1,   134,    59,   187,   191,    60,    -1,   134,    59,
   602       187,    11,   191,    60,    -1,     3,    -1,   143,    -1,   134,
   603        63,   141,    -1,   134,    63,    59,   135,    60,    -1,   134,
   604        63,    59,    31,    60,    -1,   134,    71,   126,    72,    -1,
   605       134,    71,   192,    66,   192,    72,    -1,   134,    71,   192,
   606        66,   192,    66,   192,    72,    -1,   128,    -1,   149,    59,
   607       126,   191,    60,    -1,   150,   137,   130,   189,    68,    -1,
   608       129,    67,   130,   189,    68,    -1,    59,   135,    60,    67,
   609       130,   189,    68,    -1,   165,    -1,    -1,   126,    66,   133,
   610        -1,   126,    -1,    67,   130,   189,    68,    -1,   126,    -1,
   611        67,   130,   189,    68,    -1,   129,    -1,    59,   135,    60,
   612        -1,   126,    -1,   147,    -1,   146,    -1,    35,    -1,    67,
   613        -1,   141,    -1,   141,    -1,    -1,   138,    -1,    24,    -1,
   614       142,    -1,    73,    -1,    74,     3,    63,    24,    -1,    74,
   615         3,    63,    73,    -1,   141,    -1,   138,    -1,    11,    -1,
   616        11,   146,    -1,   155,    -1,   161,    -1,   153,    -1,   154,
   617        -1,   152,    -1,    59,   146,    60,    -1,   155,    -1,   161,
   618        -1,   153,    -1,    53,   147,    -1,   161,    -1,   153,    -1,
   619       154,    -1,   152,    -1,    59,   146,    60,    -1,   161,    -1,
   620       153,    -1,   153,    -1,   155,    -1,   161,    -1,   153,    -1,
   621       154,    -1,   152,    -1,   143,    -1,   143,    63,   141,    -1,
   622        71,   192,    72,   146,    -1,    71,    11,    72,   146,    -1,
   623         8,   148,    -1,     8,    36,   146,    -1,    23,    71,   146,
   624        72,   146,    -1,   156,    -1,   157,    -1,    53,   146,    -1,
   625        36,     8,   146,    -1,    29,   137,   170,   190,    68,    -1,
   626        29,   137,    68,    -1,    22,   137,   171,   190,    68,    -1,
   627        22,   137,    68,    -1,    17,   159,   162,    -1,   141,    59,
   628       179,    60,   163,    -1,    59,   179,    60,   141,    59,   179,
   629        60,   163,    -1,   200,    59,   195,    60,   210,    -1,    59,
   630       215,    60,   141,    59,   195,    60,   210,    -1,    17,    59,
   631       179,    60,   163,    -1,    -1,    67,   183,    68,    -1,    -1,
   632       151,    -1,    59,   179,    60,    -1,   161,    -1,   164,   137,
   633       183,    68,    -1,   164,     1,    -1,    -1,   166,    90,    62,
   634        -1,    93,    -1,   167,    62,    93,    -1,    95,    -1,   168,
   635        62,    95,    -1,    97,    -1,   169,    62,    97,    -1,   172,
   636        -1,   170,    62,   172,    -1,   175,    -1,   171,    62,   175,
   637        -1,   184,   146,   198,    -1,   174,   198,    -1,    59,   174,
   638        60,   198,    -1,    53,   174,   198,    -1,    59,    53,   174,
   639        60,   198,    -1,    53,    59,   174,    60,   198,    -1,    24,
   640        -1,    24,    63,   141,    -1,   173,    -1,   138,   176,    -1,
   641       173,    -1,    59,   173,    60,    -1,    59,   179,    60,   163,
   642        -1,   136,    -1,   141,   136,    -1,   141,   145,    -1,   145,
   643        -1,   177,    -1,   178,    75,   177,    -1,    -1,   178,   191,
   644        -1,    -1,   100,    -1,    91,    -1,   181,    -1,     1,    -1,
   645        98,    -1,   110,    -1,   121,    -1,   124,    -1,   113,    -1,
   646        -1,   144,    66,   182,   180,    -1,    15,    -1,     6,   140,
   647        -1,    10,   140,    -1,    18,   128,    -1,    13,   128,    -1,
   648        19,   138,    -1,    27,   193,    -1,   180,    -1,   183,    62,
   649       180,    -1,   138,    -1,   184,    75,   138,    -1,   139,    -1,
   650       185,    75,   139,    -1,   126,    -1,   186,    75,   126,    -1,
   651       135,    -1,   187,    75,   135,    -1,   131,    -1,   132,    -1,
   652       188,    75,   131,    -1,   188,    75,   132,    -1,    -1,   188,
   653       191,    -1,    -1,    62,    -1,    -1,    75,    -1,    -1,   126,
   654        -1,    -1,   186,    -1,    -1,    98,    -1,    -1,   215,    -1,
   655        -1,   216,    -1,    -1,   217,    -1,    -1,     3,    -1,    21,
   656        24,     3,    62,    -1,    32,   200,   202,    62,    -1,     9,
   657       200,    65,   213,    62,    -1,     9,   200,   202,    65,   213,
   658        62,    -1,    31,   201,   202,    62,    -1,    17,   160,   162,
   659        62,    -1,   142,    -1,   200,    -1,   204,    -1,   205,    -1,
   660       206,    -1,   204,    -1,   206,    -1,   142,    -1,    24,    -1,
   661        71,    72,   202,    -1,    71,     3,    72,   202,    -1,    23,
   662        71,   202,    72,   202,    -1,    29,    67,   196,    68,    -1,
   663        22,    67,   197,    68,    -1,    53,   202,    -1,     8,   203,
   664        -1,     8,    59,   205,    60,    -1,     8,    36,   202,    -1,
   665        36,     8,   202,    -1,    17,    59,   195,    60,   210,    -1,
   666       141,   202,   198,    -1,   141,    11,   202,   198,    -1,   141,
   667       202,   198,    -1,   141,    59,   195,    60,   210,    -1,   202,
   668        -1,    -1,   211,    -1,    59,   195,    60,    -1,   202,    -1,
   669         3,    -1,    50,     3,    -1,   141,    -1,   212,    -1,    59,
   670       212,    49,   212,    60,    -1,    -1,   214,   199,    -1,   207,
   671        -1,   215,    75,   207,    -1,   208,    -1,   216,    62,   208,
   672        -1,   209,    -1,   217,    62,   209,    -1
   673  };
   674  
   675  /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
   676  static const yytype_uint16 yyrline[] =
   677  {
   678         0,   124,   124,   133,   139,   150,   150,   165,   166,   169,
   679       170,   171,   174,   211,   222,   223,   226,   233,   240,   249,
   680       263,   264,   271,   271,   284,   288,   289,   293,   298,   304,
   681       308,   312,   316,   322,   328,   334,   339,   343,   347,   353,
   682       359,   363,   367,   373,   377,   383,   384,   388,   394,   403,
   683       409,   427,   432,   444,   460,   465,   472,   492,   510,   519,
   684       538,   537,   552,   551,   582,   585,   592,   591,   602,   608,
   685       617,   628,   634,   637,   645,   644,   655,   661,   673,   677,
   686       682,   672,   703,   702,   715,   718,   724,   727,   739,   743,
   687       738,   761,   760,   776,   777,   781,   785,   789,   793,   797,
   688       801,   805,   809,   813,   817,   821,   825,   829,   833,   837,
   689       841,   845,   849,   854,   860,   861,   865,   876,   880,   884,
   690       888,   893,   897,   907,   911,   916,   924,   928,   929,   940,
   691       944,   948,   952,   956,   964,   965,   971,   978,   984,   991,
   692       994,  1001,  1007,  1024,  1031,  1032,  1039,  1040,  1059,  1060,
   693      1063,  1066,  1070,  1081,  1090,  1096,  1099,  1102,  1109,  1110,
   694      1116,  1129,  1144,  1152,  1164,  1169,  1175,  1176,  1177,  1178,
   695      1179,  1180,  1186,  1187,  1188,  1189,  1195,  1196,  1197,  1198,
   696      1199,  1205,  1206,  1209,  1212,  1213,  1214,  1215,  1216,  1219,
   697      1220,  1233,  1237,  1242,  1247,  1252,  1256,  1257,  1260,  1266,
   698      1273,  1279,  1286,  1292,  1303,  1317,  1346,  1386,  1411,  1429,
   699      1438,  1441,  1449,  1453,  1457,  1464,  1470,  1475,  1487,  1490,
   700      1500,  1501,  1507,  1508,  1514,  1518,  1524,  1525,  1531,  1535,
   701      1541,  1564,  1569,  1575,  1581,  1588,  1597,  1606,  1621,  1627,
   702      1632,  1636,  1643,  1656,  1657,  1663,  1669,  1672,  1676,  1682,
   703      1685,  1694,  1697,  1698,  1702,  1703,  1709,  1710,  1711,  1712,
   704      1713,  1715,  1714,  1729,  1734,  1738,  1742,  1746,  1750,  1755,
   705      1774,  1780,  1788,  1792,  1798,  1802,  1808,  1812,  1818,  1822,
   706      1831,  1835,  1839,  1843,  1849,  1852,  1860,  1861,  1863,  1864,
   707      1867,  1870,  1873,  1876,  1879,  1882,  1885,  1888,  1891,  1894,
   708      1897,  1900,  1903,  1906,  1912,  1916,  1920,  1924,  1928,  1932,
   709      1952,  1959,  1970,  1971,  1972,  1975,  1976,  1979,  1983,  1993,
   710      1997,  2001,  2005,  2009,  2013,  2017,  2023,  2029,  2037,  2045,
   711      2051,  2058,  2074,  2096,  2100,  2106,  2109,  2112,  2116,  2126,
   712      2130,  2145,  2153,  2154,  2166,  2167,  2170,  2174,  2180,  2184,
   713      2190,  2194
   714  };
   715  #endif
   716  
   717  #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
   718  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   719     First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
   720  const char *yytname[] =
   721  {
   722    "$end", "error", "$undefined", "LLITERAL", "LASOP", "LCOLAS", "LBREAK",
   723    "LCASE", "LCHAN", "LCONST", "LCONTINUE", "LDDD", "LDEFAULT", "LDEFER",
   724    "LELSE", "LFALL", "LFOR", "LFUNC", "LGO", "LGOTO", "LIF", "LIMPORT",
   725    "LINTERFACE", "LMAP", "LNAME", "LPACKAGE", "LRANGE", "LRETURN",
   726    "LSELECT", "LSTRUCT", "LSWITCH", "LTYPE", "LVAR", "LANDAND", "LANDNOT",
   727    "LBODY", "LCOMM", "LDEC", "LEQ", "LGE", "LGT", "LIGNORE", "LINC", "LLE",
   728    "LLSH", "LLT", "LNE", "LOROR", "LRSH", "'+'", "'-'", "'|'", "'^'", "'*'",
   729    "'/'", "'%'", "'&'", "NotPackage", "NotParen", "'('", "')'",
   730    "PreferToRightParen", "';'", "'.'", "'$'", "'='", "':'", "'{'", "'}'",
   731    "'!'", "'~'", "'['", "']'", "'?'", "'@'", "','", "$accept", "file",
   732    "package", "loadsys", "$@1", "imports", "import", "import_stmt",
   733    "import_stmt_list", "import_here", "import_package", "import_safety",
   734    "import_there", "$@2", "xdcl", "common_dcl", "lconst", "vardcl",
   735    "constdcl", "constdcl1", "typedclname", "typedcl", "simple_stmt", "case",
   736    "compound_stmt", "$@3", "caseblock", "$@4", "caseblock_list",
   737    "loop_body", "$@5", "range_stmt", "for_header", "for_body", "for_stmt",
   738    "$@6", "if_header", "if_stmt", "$@7", "$@8", "$@9", "elseif", "$@10",
   739    "elseif_list", "else", "switch_stmt", "$@11", "$@12", "select_stmt",
   740    "$@13", "expr", "uexpr", "pseudocall", "pexpr_no_paren", "start_complit",
   741    "keyval", "bare_complitexpr", "complitexpr", "pexpr", "expr_or_type",
   742    "name_or_type", "lbrace", "new_name", "dcl_name", "onew_name", "sym",
   743    "hidden_importsym", "name", "labelname", "dotdotdot", "ntype",
   744    "non_expr_type", "non_recvchantype", "convtype", "comptype",
   745    "fnret_type", "dotname", "othertype", "ptrtype", "recvchantype",
   746    "structtype", "interfacetype", "xfndcl", "fndcl", "hidden_fndcl",
   747    "fntype", "fnbody", "fnres", "fnlitdcl", "fnliteral", "xdcl_list",
   748    "vardcl_list", "constdcl_list", "typedcl_list", "structdcl_list",
   749    "interfacedcl_list", "structdcl", "packname", "embed", "interfacedcl",
   750    "indcl", "arg_type", "arg_type_list", "oarg_type_list_ocomma", "stmt",
   751    "non_dcl_stmt", "$@14", "stmt_list", "new_name_list", "dcl_name_list",
   752    "expr_list", "expr_or_type_list", "keyval_list", "braced_keyval_list",
   753    "osemi", "ocomma", "oexpr", "oexpr_list", "osimple_stmt",
   754    "ohidden_funarg_list", "ohidden_structdcl_list",
   755    "ohidden_interfacedcl_list", "oliteral", "hidden_import",
   756    "hidden_pkg_importsym", "hidden_pkgtype", "hidden_type",
   757    "hidden_type_non_recv_chan", "hidden_type_misc", "hidden_type_recv_chan",
   758    "hidden_type_func", "hidden_funarg", "hidden_structdcl",
   759    "hidden_interfacedcl", "ohidden_funres", "hidden_funres",
   760    "hidden_literal", "hidden_constant", "hidden_import_list",
   761    "hidden_funarg_list", "hidden_structdcl_list",
   762    "hidden_interfacedcl_list", 0
   763  };
   764  #endif
   765  
   766  # ifdef YYPRINT
   767  /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
   768     token YYLEX-NUM.  */
   769  static const yytype_uint16 yytoknum[] =
   770  {
   771         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
   772       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
   773       275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
   774       285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
   775       295,   296,   297,   298,   299,   300,   301,   302,   303,    43,
   776        45,   124,    94,    42,    47,    37,    38,   304,   305,    40,
   777        41,   306,    59,    46,    36,    61,    58,   123,   125,    33,
   778       126,    91,    93,    63,    64,    44
   779  };
   780  # endif
   781  
   782  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
   783  static const yytype_uint8 yyr1[] =
   784  {
   785         0,    76,    77,    78,    78,    80,    79,    81,    81,    82,
   786        82,    82,    83,    83,    84,    84,    85,    85,    85,    86,
   787        87,    87,    89,    88,    90,    90,    90,    90,    90,    91,
   788        91,    91,    91,    91,    91,    91,    91,    91,    91,    92,
   789        93,    93,    93,    94,    94,    95,    95,    95,    96,    97,
   790        98,    98,    98,    98,    98,    98,    99,    99,    99,    99,
   791       101,   100,   103,   102,   104,   104,   106,   105,   107,   107,
   792       108,   108,   108,   109,   111,   110,   112,   112,   114,   115,
   793       116,   113,   118,   117,   119,   119,   120,   120,   122,   123,
   794       121,   125,   124,   126,   126,   126,   126,   126,   126,   126,
   795       126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
   796       126,   126,   126,   126,   127,   127,   127,   127,   127,   127,
   797       127,   127,   127,   128,   128,   128,   129,   129,   129,   129,
   798       129,   129,   129,   129,   129,   129,   129,   129,   129,   129,
   799       130,   131,   132,   132,   133,   133,   134,   134,   135,   135,
   800       136,   137,   137,   138,   139,   140,   140,   141,   141,   141,
   801       142,   142,   143,   144,   145,   145,   146,   146,   146,   146,
   802       146,   146,   147,   147,   147,   147,   148,   148,   148,   148,
   803       148,   149,   149,   150,   151,   151,   151,   151,   151,   152,
   804       152,   153,   153,   153,   153,   153,   153,   153,   154,   155,
   805       156,   156,   157,   157,   158,   159,   159,   160,   160,   161,
   806       162,   162,   163,   163,   163,   164,   165,   165,   166,   166,
   807       167,   167,   168,   168,   169,   169,   170,   170,   171,   171,
   808       172,   172,   172,   172,   172,   172,   173,   173,   174,   175,
   809       175,   175,   176,   177,   177,   177,   177,   178,   178,   179,
   810       179,   180,   180,   180,   180,   180,   181,   181,   181,   181,
   811       181,   182,   181,   181,   181,   181,   181,   181,   181,   181,
   812       183,   183,   184,   184,   185,   185,   186,   186,   187,   187,
   813       188,   188,   188,   188,   189,   189,   190,   190,   191,   191,
   814       192,   192,   193,   193,   194,   194,   195,   195,   196,   196,
   815       197,   197,   198,   198,   199,   199,   199,   199,   199,   199,
   816       200,   201,   202,   202,   202,   203,   203,   204,   204,   204,
   817       204,   204,   204,   204,   204,   204,   204,   204,   205,   206,
   818       207,   207,   208,   209,   209,   210,   210,   211,   211,   212,
   819       212,   212,   213,   213,   214,   214,   215,   215,   216,   216,
   820       217,   217
   821  };
   822  
   823  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
   824  static const yytype_uint8 yyr2[] =
   825  {
   826         0,     2,     4,     0,     3,     0,     3,     0,     3,     2,
   827         5,     3,     3,     2,     1,     3,     1,     2,     2,     4,
   828         0,     1,     0,     4,     0,     1,     1,     1,     1,     2,
   829         5,     3,     2,     5,     7,     3,     2,     5,     3,     1,
   830         2,     4,     3,     4,     3,     1,     2,     1,     1,     2,
   831         1,     3,     3,     3,     2,     2,     3,     5,     5,     2,
   832         0,     4,     0,     3,     0,     2,     0,     4,     4,     4,
   833         5,     1,     1,     2,     0,     3,     1,     3,     0,     0,
   834         0,     8,     0,     5,     0,     2,     0,     2,     0,     0,
   835         7,     0,     5,     1,     3,     3,     3,     3,     3,     3,
   836         3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
   837         3,     3,     3,     3,     1,     2,     2,     2,     2,     2,
   838         2,     2,     2,     3,     5,     6,     1,     1,     3,     5,
   839         5,     4,     6,     8,     1,     5,     5,     5,     7,     1,
   840         0,     3,     1,     4,     1,     4,     1,     3,     1,     1,
   841         1,     1,     1,     1,     1,     0,     1,     1,     1,     1,
   842         4,     4,     1,     1,     1,     2,     1,     1,     1,     1,
   843         1,     3,     1,     1,     1,     2,     1,     1,     1,     1,
   844         3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
   845         3,     4,     4,     2,     3,     5,     1,     1,     2,     3,
   846         5,     3,     5,     3,     3,     5,     8,     5,     8,     5,
   847         0,     3,     0,     1,     3,     1,     4,     2,     0,     3,
   848         1,     3,     1,     3,     1,     3,     1,     3,     1,     3,
   849         3,     2,     4,     3,     5,     5,     1,     3,     1,     2,
   850         1,     3,     4,     1,     2,     2,     1,     1,     3,     0,
   851         2,     0,     1,     1,     1,     1,     1,     1,     1,     1,
   852         1,     0,     4,     1,     2,     2,     2,     2,     2,     2,
   853         1,     3,     1,     3,     1,     3,     1,     3,     1,     3,
   854         1,     1,     3,     3,     0,     2,     0,     1,     0,     1,
   855         0,     1,     0,     1,     0,     1,     0,     1,     0,     1,
   856         0,     1,     0,     1,     4,     4,     5,     6,     4,     4,
   857         1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
   858         4,     5,     4,     4,     2,     2,     4,     3,     3,     5,
   859         3,     4,     3,     5,     1,     0,     1,     3,     1,     1,
   860         2,     1,     1,     5,     0,     2,     1,     3,     1,     3,
   861         1,     3
   862  };
   863  
   864  /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
   865     Performed when YYTABLE doesn't specify something else to do.  Zero
   866     means the default is an error.  */
   867  static const yytype_uint16 yydefact[] =
   868  {
   869         5,     0,     3,     0,     1,     0,     7,     0,    22,   157,
   870       159,     0,     0,   158,   218,    20,     6,   344,     0,     4,
   871         0,     0,     0,    21,     0,     0,     0,    16,     0,     0,
   872         9,    22,     0,     8,    28,   126,   155,     0,    39,   155,
   873         0,   263,    74,     0,     0,     0,    78,     0,     0,   292,
   874        91,     0,    88,     0,     0,     0,     0,     0,     0,     0,
   875         0,     0,     0,     0,   290,     0,    25,     0,   256,   257,
   876       260,   258,   259,    50,    93,   134,   146,   114,   163,   162,
   877       127,     0,     0,     0,   183,   196,   197,    26,   215,     0,
   878       139,    27,     0,    19,     0,     0,     0,     0,     0,     0,
   879       345,   160,   161,    11,    14,   286,    18,    22,    13,    17,
   880       156,   264,   153,     0,     0,     0,     0,   162,   189,   193,
   881       179,   177,   178,   176,   265,   134,     0,   294,   249,     0,
   882       210,   134,   268,   294,   151,   152,     0,     0,   276,   293,
   883       269,     0,     0,   294,     0,     0,    36,    48,     0,    29,
   884       274,   154,     0,   122,   117,   118,   121,   115,   116,     0,
   885         0,   148,     0,   149,   174,   172,   173,   119,   120,     0,
   886       291,     0,   219,     0,    32,     0,     0,     0,     0,     0,
   887        55,     0,     0,     0,    54,     0,     0,     0,     0,     0,
   888         0,     0,     0,     0,     0,     0,     0,     0,     0,   140,
   889         0,     0,   290,   261,     0,   140,   217,     0,     0,     0,
   890         0,   310,     0,     0,   210,     0,     0,   311,     0,     0,
   891        23,   287,     0,    12,   249,     0,     0,   194,   170,   168,
   892       169,   166,   167,   198,     0,     0,   295,    72,     0,    75,
   893         0,    71,   164,   243,   162,   246,   150,   247,   288,     0,
   894       249,     0,   204,    79,    76,   157,     0,   203,     0,   286,
   895       240,   228,     0,    64,     0,     0,   201,   272,   286,   226,
   896       238,   302,     0,    89,    38,   224,   286,    49,    31,   220,
   897       286,     0,     0,    40,     0,   175,   147,     0,     0,    35,
   898       286,     0,     0,    51,    95,   110,   113,    96,   100,   101,
   899        99,   111,    98,    97,    94,   112,   102,   103,   104,   105,
   900       106,   107,   108,   109,   284,   123,   278,   288,     0,   128,
   901       291,     0,     0,   288,   284,   255,    60,   253,   252,   270,
   902       254,     0,    53,    52,   277,     0,     0,     0,     0,   318,
   903         0,     0,     0,     0,     0,   317,     0,   312,   313,   314,
   904         0,   346,     0,     0,   296,     0,     0,     0,    15,    10,
   905         0,     0,     0,   180,   190,    66,    73,     0,     0,   294,
   906       165,   244,   245,   289,   250,   212,     0,     0,     0,   294,
   907         0,   236,     0,   249,   239,   287,     0,     0,     0,     0,
   908       302,     0,     0,   287,     0,   303,   231,     0,   302,     0,
   909       287,     0,   287,     0,    42,   275,     0,     0,     0,   199,
   910       170,   168,   169,   167,   140,   192,   191,   287,     0,    44,
   911         0,   140,   142,   280,   281,   288,     0,   288,   289,     0,
   912         0,     0,   131,   290,   262,   289,     0,     0,     0,     0,
   913       216,     0,     0,   325,   315,   316,   296,   300,     0,   298,
   914         0,   324,   339,     0,     0,   341,   342,     0,     0,     0,
   915         0,     0,   302,     0,     0,   309,     0,   297,   304,   308,
   916       305,   212,   171,     0,     0,     0,     0,   248,   249,   162,
   917       213,   188,   186,   187,   184,   185,   209,   212,   211,    80,
   918        77,   237,   241,     0,   229,   202,   195,     0,     0,    92,
   919        62,    65,     0,   233,     0,   302,   227,   200,   273,   230,
   920        64,   225,    37,   221,    30,    41,     0,   284,    45,   222,
   921       286,    47,    33,    43,   284,     0,   289,   285,   137,     0,
   922       279,   124,   130,   129,     0,   135,   136,     0,   271,   327,
   923         0,     0,   318,     0,   317,     0,   334,   350,   301,     0,
   924         0,     0,   348,   299,   328,   340,     0,   306,     0,   319,
   925         0,   302,   330,     0,   347,   335,     0,    69,    68,   294,
   926         0,   249,   205,    84,   212,     0,    59,     0,   302,   302,
   927       232,     0,   171,     0,   287,     0,    46,     0,   140,   144,
   928       141,   282,   283,   125,   290,   132,    61,   326,   335,   296,
   929       323,     0,     0,   302,   322,     0,     0,   320,   307,   331,
   930       296,   296,   338,   207,   336,    67,    70,   214,     0,    86,
   931       242,     0,     0,    56,     0,    63,   235,   234,    90,   138,
   932       223,    34,   143,   284,     0,   329,     0,   351,   321,   332,
   933       349,     0,     0,     0,   212,     0,    85,    81,     0,     0,
   934         0,   133,   335,   343,   335,   337,   206,    82,    87,    58,
   935        57,   145,   333,   208,   294,     0,    83
   936  };
   937  
   938  /* YYDEFGOTO[NTERM-NUM].  */
   939  static const yytype_int16 yydefgoto[] =
   940  {
   941        -1,     1,     6,     2,     3,    14,    21,    30,   105,    31,
   942         8,    24,    16,    17,    65,   327,    67,   149,   518,   519,
   943       145,   146,    68,   500,   328,   438,   501,   577,   388,   366,
   944       473,   237,   238,   239,    69,   127,   253,    70,   133,   378,
   945       573,   646,   664,   619,   647,    71,   143,   399,    72,   141,
   946        73,    74,    75,    76,   314,   423,   424,   590,    77,   316,
   947       243,   136,    78,   150,   111,   117,    13,    80,    81,   245,
   948       246,   163,   119,    82,    83,   480,   228,    84,   230,   231,
   949        85,    86,    87,   130,   214,    88,   252,   486,    89,    90,
   950        22,   280,   520,   276,   268,   259,   269,   270,   271,   261,
   951       384,   247,   248,   249,   329,   330,   322,   331,   272,   152,
   952        92,   317,   425,   426,   222,   374,   171,   140,   254,   466,
   953       551,   545,   396,   100,   212,   218,   612,   443,   347,   348,
   954       349,   351,   552,   547,   613,   614,   456,   457,    25,   467,
   955       553,   548
   956  };
   957  
   958  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   959     STATE-NUM.  */
   960  #define YYPACT_NINF -474
   961  static const yytype_int16 yypact[] =
   962  {
   963      -474,    48,    28,    35,  -474,   258,  -474,    37,  -474,  -474,
   964      -474,    61,    12,  -474,    85,   107,  -474,  -474,    70,  -474,
   965       156,    82,  1059,  -474,   122,   328,    22,  -474,    56,   199,
   966      -474,    35,   211,  -474,  -474,  -474,   258,   767,  -474,   258,
   967       459,  -474,  -474,   152,   459,   258,  -474,    23,   145,  1650,
   968      -474,    23,  -474,   294,   359,  1650,  1650,  1650,  1650,  1650,
   969      1650,  1693,  1650,  1650,  1289,   159,  -474,   412,  -474,  -474,
   970      -474,  -474,  -474,   939,  -474,  -474,   157,   302,  -474,   168,
   971      -474,   175,   184,    23,   204,  -474,  -474,  -474,   219,    54,
   972      -474,  -474,    47,  -474,   227,   -12,   269,   227,   227,   239,
   973      -474,  -474,  -474,  -474,  -474,   240,  -474,  -474,  -474,  -474,
   974      -474,  -474,  -474,   250,  1813,  1813,  1813,  -474,   259,  -474,
   975      -474,  -474,  -474,  -474,  -474,    64,   302,  1650,  1805,   262,
   976       260,   174,  -474,  1650,  -474,  -474,   221,  1813,  2166,   255,
   977      -474,   290,   237,  1650,   304,  1813,  -474,  -474,   420,  -474,
   978      -474,  -474,   580,  -474,  -474,  -474,  -474,  -474,  -474,  1736,
   979      1693,  2166,   280,  -474,   253,  -474,    50,  -474,  -474,   275,
   980      2166,   285,  -474,   430,  -474,   612,  1650,  1650,  1650,  1650,
   981      -474,  1650,  1650,  1650,  -474,  1650,  1650,  1650,  1650,  1650,
   982      1650,  1650,  1650,  1650,  1650,  1650,  1650,  1650,  1650,  -474,
   983      1332,   428,  1650,  -474,  1650,  -474,  -474,  1234,  1650,  1650,
   984      1650,  -474,   763,   258,   260,   293,   369,  -474,  1992,  1992,
   985      -474,    51,   326,  -474,  1805,   392,  1813,  -474,  -474,  -474,
   986      -474,  -474,  -474,  -474,   341,   258,  -474,  -474,   371,  -474,
   987        89,   342,  1813,  -474,  1805,  -474,  -474,  -474,   335,   360,
   988      1805,  1234,  -474,  -474,   357,    99,   399,  -474,   365,   380,
   989      -474,  -474,   377,  -474,   173,   151,  -474,  -474,   381,  -474,
   990      -474,   456,  1779,  -474,  -474,  -474,   401,  -474,  -474,  -474,
   991       404,  1650,   258,   366,  1838,  -474,   405,  1813,  1813,  -474,
   992       407,  1650,   410,  2166,   650,  -474,  2190,   877,   877,   877,
   993       877,  -474,   877,   877,  2214,  -474,   461,   461,   461,   461,
   994      -474,  -474,  -474,  -474,  1387,  -474,  -474,    52,  1442,  -474,
   995      2064,   411,  1160,  2031,  1387,  -474,  -474,  -474,  -474,  -474,
   996      -474,    19,   255,   255,  2166,  1905,   447,   441,   439,  -474,
   997       444,   505,  1992,   225,    27,  -474,   454,  -474,  -474,  -474,
   998      1931,  -474,   125,   458,   258,   460,   465,   466,  -474,  -474,
   999       463,  1813,   480,  -474,  -474,  -474,  -474,  1497,  1552,  1650,
  1000      -474,  -474,  -474,  1805,  -474,  1872,   484,    24,   371,  1650,
  1001       258,   485,   487,  1805,  -474,   472,   481,  1813,    81,   399,
  1002       456,   399,   490,   289,   483,  -474,  -474,   258,   456,   519,
  1003       258,   495,   258,   496,   255,  -474,  1650,  1897,  1813,  -474,
  1004       321,   349,   350,   354,  -474,  -474,  -474,   258,   497,   255,
  1005      1650,  -474,  2094,  -474,  -474,   488,   491,   489,  1693,   498,
  1006       500,   502,  -474,  1650,  -474,  -474,   506,   503,  1234,  1160,
  1007      -474,  1992,   534,  -474,  -474,  -474,   258,  1958,  1992,   258,
  1008      1992,  -474,  -474,   565,   149,  -474,  -474,   510,   504,  1992,
  1009       225,  1992,   456,   258,   258,  -474,   514,   507,  -474,  -474,
  1010      -474,  1872,  -474,  1234,  1650,  1650,   515,  -474,  1805,   520,
  1011      -474,  -474,  -474,  -474,  -474,  -474,  -474,  1872,  -474,  -474,
  1012      -474,  -474,  -474,   518,  -474,  -474,  -474,  1693,   517,  -474,
  1013      -474,  -474,   524,  -474,   525,   456,  -474,  -474,  -474,  -474,
  1014      -474,  -474,  -474,  -474,  -474,   255,   526,  1387,  -474,  -474,
  1015       527,   612,  -474,   255,  1387,  1595,  1387,  -474,  -474,   530,
  1016      -474,  -474,  -474,  -474,   116,  -474,  -474,   141,  -474,  -474,
  1017       539,   540,   521,   542,   546,   538,  -474,  -474,   548,   543,
  1018      1992,   549,  -474,   552,  -474,  -474,   562,  -474,  1992,  -474,
  1019       556,   456,  -474,   560,  -474,  1984,   238,  2166,  2166,  1650,
  1020       561,  1805,  -474,  -474,  1872,    32,  -474,  1160,   456,   456,
  1021      -474,   186,   370,   554,   258,   563,   410,   557,  -474,  2166,
  1022      -474,  -474,  -474,  -474,  1650,  -474,  -474,  -474,  1984,   258,
  1023      -474,  1958,  1992,   456,  -474,   258,   149,  -474,  -474,  -474,
  1024       258,   258,  -474,  -474,  -474,  -474,  -474,  -474,   564,   613,
  1025      -474,  1650,  1650,  -474,  1693,   566,  -474,  -474,  -474,  -474,
  1026      -474,  -474,  -474,  1387,   558,  -474,   571,  -474,  -474,  -474,
  1027      -474,   577,   582,   583,  1872,    36,  -474,  -474,  2118,  2142,
  1028       572,  -474,  1984,  -474,  1984,  -474,  -474,  -474,  -474,  -474,
  1029      -474,  -474,  -474,  -474,  1650,   371,  -474
  1030  };
  1031  
  1032  /* YYPGOTO[NTERM-NUM].  */
  1033  static const yytype_int16 yypgoto[] =
  1034  {
  1035      -474,  -474,  -474,  -474,  -474,  -474,  -474,   -15,  -474,  -474,
  1036       616,  -474,    -3,  -474,  -474,   622,  -474,  -125,   -27,    66,
  1037      -474,  -124,  -112,  -474,    11,  -474,  -474,  -474,   147,  -368,
  1038      -474,  -474,  -474,  -474,  -474,  -474,  -140,  -474,  -474,  -474,
  1039      -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,
  1040       532,    10,   247,  -474,  -194,   132,   135,  -474,   279,   -59,
  1041       418,    67,     5,   384,   624,   425,   317,    20,  -474,   424,
  1042       636,   509,  -474,  -474,  -474,  -474,   -36,   -37,   -31,   -49,
  1043      -474,  -474,  -474,  -474,  -474,   -32,   464,  -473,  -474,  -474,
  1044      -474,  -474,  -474,  -474,  -474,  -474,   277,  -119,  -231,   287,
  1045      -474,   300,  -474,  -205,  -300,   652,  -474,  -242,  -474,   -63,
  1046       106,   182,  -474,  -316,  -241,  -285,  -195,  -474,  -111,  -420,
  1047      -474,  -474,  -245,  -474,   402,  -474,  -176,  -474,   345,   249,
  1048       346,   218,    87,    96,  -415,  -474,  -429,   252,  -474,   522,
  1049      -474,  -474
  1050  };
  1051  
  1052  /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
  1053     positive, shift that token.  If negative, reduce the rule which
  1054     number is the opposite.  If YYTABLE_NINF, syntax error.  */
  1055  #define YYTABLE_NINF -277
  1056  static const yytype_int16 yytable[] =
  1057  {
  1058       121,   120,   162,   273,   175,   123,   122,   321,   437,   377,
  1059       489,   324,   165,   104,   572,   236,   241,   260,   386,   360,
  1060       275,   236,   434,   279,   164,   556,   541,   394,   108,   166,
  1061       458,   236,   429,   390,   392,   401,   346,   621,   436,   403,
  1062       174,   110,   356,   357,   110,   376,   101,   213,     4,   418,
  1063       132,  -215,   208,     5,    27,   206,   657,   118,   134,    27,
  1064         7,    15,    11,   427,    18,   153,   154,   155,   156,   157,
  1065       158,  -267,   167,   168,    19,     9,  -267,   229,   229,   229,
  1066         9,   439,   232,   232,   232,  -215,   439,   440,   497,   134,
  1067       135,   229,   488,   498,   367,   102,   232,   622,   623,   459,
  1068       229,   620,  -236,   326,   223,   232,    20,   624,   229,  -181,
  1069       175,   165,   209,   232,    29,   229,   103,  -215,   142,    29,
  1070       232,   135,   210,   164,    10,    11,  -267,   428,   166,    10,
  1071        11,    23,  -267,    26,   118,   118,   118,   382,   229,   538,
  1072       527,   258,   529,   232,    33,   503,   290,   267,   118,   499,
  1073       205,   165,   452,   509,   368,   139,   207,   118,   502,    27,
  1074       504,  -236,   380,   164,   210,   118,   451,  -236,   166,   153,
  1075       157,   656,   118,     9,   462,   381,     9,   641,   493,   636,
  1076         9,  -266,   594,   635,    93,   463,  -266,   229,   595,   229,
  1077       642,   643,   232,   497,   232,   118,   537,   381,   498,   453,
  1078       464,   583,   106,   439,   391,   229,   358,   229,   587,   596,
  1079       232,   128,   232,   229,   109,    28,   137,   562,   232,    29,
  1080       517,   172,    10,    11,   199,    10,    11,   524,   452,    10,
  1081        11,   566,   389,   240,  -153,   229,  -266,   662,   534,   663,
  1082       232,   203,  -266,   204,   118,   255,   118,   411,   410,     9,
  1083       229,   229,   413,   412,   628,   232,   232,   236,   476,   431,
  1084       580,   255,   118,  -182,   118,   539,   260,   236,   490,   165,
  1085       118,   546,   549,   570,   554,   453,   511,   513,  -181,   585,
  1086       256,   164,     9,   559,   454,   561,   166,   125,  -183,   257,
  1087       264,   131,   118,   216,    10,    11,   265,   666,    10,    11,
  1088       439,    11,   221,   220,   118,   266,   615,   118,   118,   224,
  1089        10,    11,  -182,   255,   332,   333,   609,   650,     9,   126,
  1090      -183,   250,   235,   126,   229,   263,   484,   251,     9,   232,
  1091       210,    10,    11,   626,   627,   625,   229,    94,   482,   481,
  1092       286,   232,   264,   485,   483,    95,   229,   287,   265,    96,
  1093       229,   232,   354,   144,   521,   232,  -179,   288,   639,    97,
  1094        98,   200,    10,    11,   274,   201,   618,    10,    11,   530,
  1095       229,   229,   355,   202,   603,   232,   232,    10,    11,   165,
  1096      -179,   118,   607,     9,  -177,  -178,   359,   404,  -179,  -176,
  1097       258,   164,    99,   118,   633,   118,   166,   419,   267,   634,
  1098       361,   363,   508,   118,   369,  -180,   365,   118,  -177,  -178,
  1099       373,   211,   211,  -176,   211,   211,  -177,  -178,   148,   379,
  1100       375,  -176,   484,   381,   383,   546,   638,   118,   118,  -180,
  1101        12,   406,    10,    11,   482,   481,     9,  -180,   484,   485,
  1102       483,   229,   385,   393,     9,    32,   232,    79,   165,   387,
  1103       482,   481,     9,    32,     9,   485,   483,   236,   616,   395,
  1104       164,   112,    35,   400,   112,   166,   402,    37,   129,   417,
  1105       112,   173,   414,   332,   333,   420,   113,   433,   147,   151,
  1106       278,    47,    48,     9,   229,    10,    11,   318,    51,   232,
  1107       289,   118,   151,    10,    11,   178,   255,   215,   118,   217,
  1108       219,    10,    11,    10,    11,   186,   446,   118,   447,   190,
  1109       448,   449,   515,   450,   195,   196,   197,   198,    61,   460,
  1110       465,   521,   468,   471,   665,   484,   523,   469,   470,   345,
  1111        64,   256,    10,    11,   229,   345,   345,   482,   481,   232,
  1112       472,   118,   485,   483,   487,    10,    11,   492,   380,   495,
  1113       505,   507,   236,   244,   510,   512,   514,   522,   531,   528,
  1114       532,   112,   533,   526,   435,   530,   535,   112,   555,   147,
  1115       341,   536,   557,   151,   565,   165,   558,   569,   574,   571,
  1116      -157,   138,   464,   576,   578,   579,   582,   164,    37,   584,
  1117       593,   118,   166,   161,   118,   484,   170,   113,   151,   597,
  1118       598,   599,    47,    48,     9,  -158,   600,   482,   481,    51,
  1119       601,   606,   485,   483,   605,   602,   225,   604,   608,   610,
  1120        37,   617,   629,   631,   644,   632,   319,   645,   439,   113,
  1121       651,   652,    79,   115,    47,    48,     9,   653,   350,   226,
  1122       661,    51,   654,   655,    66,   281,    32,   107,   225,   244,
  1123       630,    64,   345,    10,    11,   282,   658,   581,   591,   345,
  1124       364,   592,   371,   124,   118,   115,   405,   345,   372,   285,
  1125       506,   226,   494,   477,    91,   244,    79,   291,   353,   575,
  1126       444,   445,   564,    64,   178,    10,    11,   282,   181,   182,
  1127       183,   540,   640,   185,   186,   187,   188,   637,   190,   191,
  1128       192,   193,   194,   195,   196,   197,   198,   151,   293,   294,
  1129       295,   296,   560,   297,   298,   299,     0,   300,   301,   302,
  1130       303,   304,   305,   306,   307,   308,   309,   310,   311,   312,
  1131       313,     0,   161,     0,   320,   352,   323,     0,     0,     0,
  1132       138,   138,   334,     0,     0,     0,     0,    79,     0,     0,
  1133       227,   233,   234,     0,     0,     0,     0,     0,   345,     0,
  1134         0,     0,     0,     0,   544,   345,     0,   345,   455,     0,
  1135         0,   335,     0,   262,     0,    37,   345,     0,   345,   350,
  1136       336,   277,     0,     0,   113,   337,   338,   339,   283,    47,
  1137        48,     9,   340,     0,     0,     0,    51,     0,   244,   341,
  1138       479,     0,     0,   114,     0,   491,     0,     0,   244,     0,
  1139       112,   292,     0,   138,     0,     0,   342,     0,   112,     0,
  1140       115,     0,   112,   138,     0,   147,   116,   151,   343,     0,
  1141         0,     0,     0,     0,   344,     0,     0,    11,    64,     0,
  1142        10,    11,   151,     0,     0,     0,   422,     0,     0,     0,
  1143       161,     0,     0,     0,     0,     0,   422,     0,     0,     0,
  1144         0,     0,   362,    79,    79,     0,     0,   345,     0,     0,
  1145         0,   350,   543,     0,   550,   345,     0,     0,   370,   455,
  1146         0,     0,   345,     0,     0,   455,     0,     0,   563,   350,
  1147         0,     0,     0,     0,     0,     0,     0,     0,    79,   138,
  1148       138,     0,     0,   244,     0,     0,     0,     0,   398,     0,
  1149         0,   178,     0,     0,     0,   345,     0,     0,   544,   345,
  1150       409,   186,     0,   415,   416,   190,   191,   192,   193,   194,
  1151       195,   196,   197,   198,     0,     0,     0,     0,   138,     0,
  1152         0,     0,     0,   176,  -276,     0,     0,     0,     0,     0,
  1153         0,     0,   138,     0,     0,     0,     0,     0,     0,     0,
  1154       161,     0,     0,     0,     0,   170,     0,     0,     0,   345,
  1155         0,   345,   177,   178,     0,   179,   180,   181,   182,   183,
  1156         0,   184,   185,   186,   187,   188,   189,   190,   191,   192,
  1157       193,   194,   195,   196,   197,   198,   244,   409,     0,     0,
  1158         0,     0,    79,     0,  -276,     0,   567,   568,     0,   151,
  1159         0,     0,     0,     0,  -276,     0,     0,     0,     0,     0,
  1160         0,     0,     0,   496,   350,     0,   543,     0,     0,   161,
  1161       550,   455,     0,     0,     0,   350,   350,     0,     0,     0,
  1162         0,     0,     0,   227,   516,     0,     0,     0,     0,   422,
  1163         0,     0,     0,     0,     0,     0,   422,   589,   422,    -2,
  1164        34,     0,    35,     0,     0,    36,     0,    37,    38,    39,
  1165         0,     0,    40,     0,    41,    42,    43,    44,    45,    46,
  1166         0,    47,    48,     9,     0,     0,    49,    50,    51,    52,
  1167        53,    54,     0,     0,     0,    55,     0,     0,     0,     0,
  1168         0,     0,     0,     0,     0,     0,     0,     0,    56,    57,
  1169         0,    58,    59,     0,     0,    60,     0,     0,    61,     0,
  1170         0,   -24,     0,     0,     0,     0,   170,     0,    62,    63,
  1171        64,     0,    10,    11,     0,     0,     0,     0,     0,     0,
  1172         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1173         0,     0,     0,   648,   649,     0,   161,   586,     0,     0,
  1174         0,   325,     0,    35,     0,   422,    36,  -251,    37,    38,
  1175        39,     0,  -251,    40,     0,    41,    42,   113,    44,    45,
  1176        46,     0,    47,    48,     9,     0,     0,    49,    50,    51,
  1177        52,    53,    54,     0,     0,     0,    55,     0,     0,     0,
  1178         0,     0,     0,     0,     0,     0,     0,     0,     0,    56,
  1179        57,     0,    58,    59,     0,     0,    60,     0,     0,    61,
  1180         0,     0,  -251,     0,     0,     0,     0,   326,  -251,    62,
  1181        63,    64,     0,    10,    11,   325,     0,    35,     0,     0,
  1182        36,     0,    37,    38,    39,     0,     0,    40,     0,    41,
  1183        42,   113,    44,    45,    46,     0,    47,    48,     9,     0,
  1184         0,    49,    50,    51,    52,    53,    54,     0,     0,     0,
  1185        55,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1186         0,     0,     0,    56,    57,     0,    58,    59,     0,     0,
  1187        60,     0,    35,    61,     0,     0,  -251,    37,     0,     0,
  1188       169,   326,  -251,    62,    63,    64,   113,    10,    11,     0,
  1189         0,    47,    48,     9,     0,     0,     0,     0,    51,     0,
  1190         0,     0,     0,     0,     0,    55,     0,     0,     0,     0,
  1191         0,     0,     0,     0,     0,    35,     0,     0,    56,    57,
  1192        37,    58,    59,     0,     0,    60,     0,     0,    61,   113,
  1193         0,     0,     0,     0,    47,    48,     9,     0,    62,    63,
  1194        64,    51,    10,    11,     0,     0,     0,     0,   159,     0,
  1195         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1196         0,    56,    57,     0,    58,   160,     0,     0,    60,     0,
  1197        35,    61,   315,     0,     0,    37,     0,     0,     0,     0,
  1198         0,    62,    63,    64,   113,    10,    11,     0,     0,    47,
  1199        48,     9,     0,     0,     0,     0,    51,     0,     0,     0,
  1200         0,     0,     0,    55,     0,     0,     0,     0,     0,     0,
  1201         0,     0,     0,     0,     0,     0,    56,    57,     0,    58,
  1202        59,     0,     0,    60,     0,    35,    61,     0,     0,     0,
  1203        37,     0,     0,     0,   421,     0,    62,    63,    64,   113,
  1204        10,    11,     0,     0,    47,    48,     9,     0,     0,     0,
  1205         0,    51,     0,   430,     0,     0,     0,     0,   159,     0,
  1206         0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1207         0,    56,    57,     0,    58,   160,     0,     0,    60,     0,
  1208        35,    61,     0,     0,     0,    37,     0,     0,     0,     0,
  1209         0,    62,    63,    64,   113,    10,    11,     0,     0,    47,
  1210        48,     9,     0,   474,     0,     0,    51,     0,     0,     0,
  1211         0,     0,     0,    55,     0,     0,     0,     0,     0,     0,
  1212         0,     0,     0,     0,     0,     0,    56,    57,     0,    58,
  1213        59,     0,     0,    60,     0,    35,    61,     0,     0,     0,
  1214        37,     0,     0,     0,     0,     0,    62,    63,    64,   113,
  1215        10,    11,     0,     0,    47,    48,     9,     0,   475,     0,
  1216         0,    51,     0,     0,     0,     0,     0,     0,    55,     0,
  1217         0,     0,     0,     0,     0,     0,     0,     0,    35,     0,
  1218         0,    56,    57,    37,    58,    59,     0,     0,    60,     0,
  1219         0,    61,   113,     0,     0,     0,     0,    47,    48,     9,
  1220         0,    62,    63,    64,    51,    10,    11,     0,     0,     0,
  1221         0,    55,     0,     0,     0,     0,     0,     0,     0,     0,
  1222         0,     0,     0,     0,    56,    57,     0,    58,    59,     0,
  1223         0,    60,     0,    35,    61,     0,     0,     0,    37,     0,
  1224         0,     0,   588,     0,    62,    63,    64,   113,    10,    11,
  1225         0,     0,    47,    48,     9,     0,     0,     0,     0,    51,
  1226         0,     0,     0,     0,     0,     0,    55,     0,     0,     0,
  1227         0,     0,     0,     0,     0,     0,    35,     0,     0,    56,
  1228        57,    37,    58,    59,     0,     0,    60,     0,     0,    61,
  1229       113,     0,     0,     0,     0,    47,    48,     9,     0,    62,
  1230        63,    64,    51,    10,    11,     0,     0,     0,     0,   159,
  1231         0,     0,     0,     0,     0,     0,     0,     0,     0,    35,
  1232         0,     0,    56,    57,   284,    58,   160,     0,     0,    60,
  1233         0,     0,    61,   113,     0,     0,     0,     0,    47,    48,
  1234         9,     0,    62,    63,    64,    51,    10,    11,     0,     0,
  1235         0,     0,    55,     0,     0,     0,     0,     0,     0,     0,
  1236         0,     0,     0,     0,     0,    56,    57,    37,    58,    59,
  1237         0,     0,    60,     0,     0,    61,   113,     0,     0,     0,
  1238         0,    47,    48,     9,     0,    62,    63,    64,    51,    10,
  1239        11,     0,     0,    37,     0,   225,   242,     0,     0,     0,
  1240         0,    37,   113,     0,     0,     0,     0,    47,    48,     9,
  1241       113,     0,   115,     0,    51,    47,    48,     9,   226,     0,
  1242         0,   225,    51,     0,     0,     0,    37,     0,     0,   225,
  1243        64,     0,    10,    11,   397,   113,     0,     0,   115,     0,
  1244        47,    48,     9,     0,   226,     0,   115,    51,     0,     0,
  1245         0,     0,   226,     0,   407,     0,    64,     0,    10,    11,
  1246        37,     0,     0,     0,    64,     0,    10,    11,     0,   113,
  1247         0,   115,     0,     0,    47,    48,     9,   408,     0,     0,
  1248         0,    51,     0,     0,     0,   284,     0,     0,   225,    64,
  1249         0,    10,    11,   335,   113,     0,     0,     0,     0,    47,
  1250        48,     9,   336,     0,     0,   115,    51,   337,   338,   339,
  1251         0,   478,     0,   225,   340,     0,     0,     0,     0,   335,
  1252         0,   441,   461,    64,     0,    10,    11,     0,   336,     0,
  1253       115,     0,     0,   337,   338,   339,   226,     0,   342,     0,
  1254       340,     0,     0,     0,   442,     0,   335,   341,    64,     0,
  1255        10,    11,     0,     0,     0,   336,   344,     0,     0,    11,
  1256       337,   338,   542,     0,   342,     0,     0,   340,     0,     0,
  1257         0,     0,   335,     0,   341,     0,     0,     0,     0,     0,
  1258       335,   336,   344,     0,     0,    11,   337,   338,   339,   336,
  1259         0,   342,     0,   340,   337,   338,   339,     0,     0,     0,
  1260       341,   340,     0,     0,     0,     0,     0,     0,   341,   344,
  1261         0,    10,    11,     0,     0,     0,     0,   342,     0,     0,
  1262         0,     0,     0,   611,     0,   342,     0,     0,     0,     0,
  1263         0,     0,     0,     0,     0,   344,     0,     0,    11,     0,
  1264         0,     0,     0,   344,   177,   178,    11,   179,     0,   181,
  1265       182,   183,     0,     0,   185,   186,   187,   188,   189,   190,
  1266       191,   192,   193,   194,   195,   196,   197,   198,     0,     0,
  1267         0,     0,     0,     0,     0,     0,     0,   177,   178,     0,
  1268       179,     0,   181,   182,   183,     0,   435,   185,   186,   187,
  1269       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
  1270       198,     0,     0,     0,     0,     0,     0,   177,   178,     0,
  1271       179,     0,   181,   182,   183,     0,   432,   185,   186,   187,
  1272       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
  1273       198,   177,   178,     0,   179,     0,   181,   182,   183,     0,
  1274       525,   185,   186,   187,   188,   189,   190,   191,   192,   193,
  1275       194,   195,   196,   197,   198,   177,   178,     0,   179,     0,
  1276       181,   182,   183,     0,   659,   185,   186,   187,   188,   189,
  1277       190,   191,   192,   193,   194,   195,   196,   197,   198,   177,
  1278       178,     0,   179,     0,   181,   182,   183,     0,   660,   185,
  1279       186,   187,   188,   189,   190,   191,   192,   193,   194,   195,
  1280       196,   197,   198,   177,   178,     0,     0,     0,   181,   182,
  1281       183,     0,     0,   185,   186,   187,   188,   189,   190,   191,
  1282       192,   193,   194,   195,   196,   197,   198,   177,   178,     0,
  1283         0,     0,   181,   182,   183,     0,     0,   185,   186,   187,
  1284       188,     0,   190,   191,   192,   193,   194,   195,   196,   197,
  1285       198
  1286  };
  1287  
  1288  #define yypact_value_is_default(yystate) \
  1289    ((yystate) == (-474))
  1290  
  1291  #define yytable_value_is_error(yytable_value) \
  1292    YYID (0)
  1293  
  1294  static const yytype_int16 yycheck[] =
  1295  {
  1296        37,    37,    61,   143,    67,    37,    37,   202,   324,   251,
  1297       378,   205,    61,    28,   487,   127,   127,   136,   259,   224,
  1298       144,   133,   322,   148,    61,   454,   446,   268,    31,    61,
  1299         3,   143,   317,   264,   265,   276,   212,     5,   323,   280,
  1300        67,    36,   218,   219,    39,   250,    24,    59,     0,   290,
  1301        45,     1,     5,    25,     3,     1,    20,    37,    35,     3,
  1302        25,    24,    74,    11,     3,    55,    56,    57,    58,    59,
  1303        60,     7,    62,    63,    62,    24,    12,   114,   115,   116,
  1304        24,    62,   114,   115,   116,    35,    62,    68,     7,    35,
  1305        67,   128,    68,    12,     5,    73,   128,    65,    66,    72,
  1306       137,   574,     3,    67,   107,   137,    21,    75,   145,    59,
  1307       173,   160,    65,   145,    63,   152,    60,    67,    51,    63,
  1308       152,    67,    75,   160,    73,    74,    62,    75,   160,    73,
  1309        74,    24,    68,    63,   114,   115,   116,   256,   175,   439,
  1310       425,   136,   427,   175,    62,   390,   173,   142,   128,    68,
  1311        83,   200,     3,   398,    65,    49,    89,   137,   389,     3,
  1312       391,    62,    63,   200,    75,   145,   342,    68,   200,   159,
  1313       160,   644,   152,    24,   350,    24,    24,   606,   383,   599,
  1314        24,     7,    66,   598,    62,    60,    12,   224,    72,   226,
  1315       610,   611,   224,     7,   226,   175,   438,    24,    12,    50,
  1316        75,   517,     3,    62,    53,   242,   221,   244,   524,    68,
  1317       242,    59,   244,   250,     3,    59,    71,   462,   250,    63,
  1318       414,    62,    73,    74,    67,    73,    74,   421,     3,    73,
  1319        74,   473,    59,   127,    66,   272,    62,   652,   433,   654,
  1320       272,    66,    68,    59,   224,    24,   226,   284,   284,    24,
  1321       287,   288,   284,   284,    68,   287,   288,   369,   369,   318,
  1322       505,    24,   242,    59,   244,   441,   385,   379,   379,   318,
  1323       250,   447,   448,   478,   450,    50,   400,   402,    59,   520,
  1324        59,   318,    24,   459,    59,   461,   318,    40,    35,    68,
  1325        53,    44,   272,    24,    73,    74,    59,   665,    73,    74,
  1326        62,    74,    62,    64,   284,    68,    68,   287,   288,    59,
  1327        73,    74,    59,    24,   208,   209,   561,   633,    24,    40,
  1328        67,    59,    63,    44,   361,    35,   375,    67,    24,   361,
  1329        75,    73,    74,   578,   579,   577,   373,     9,   375,   375,
  1330        60,   373,    53,   375,   375,    17,   383,    72,    59,    21,
  1331       387,   383,    59,    59,   417,   387,    35,    72,   603,    31,
  1332        32,    59,    73,    74,    60,    63,   571,    73,    74,   428,
  1333       407,   408,     3,    71,   550,   407,   408,    73,    74,   428,
  1334        59,   361,   558,    24,    35,    35,    60,   281,    67,    35,
  1335       385,   428,    64,   373,   588,   375,   428,   291,   393,   594,
  1336         8,    60,   397,   383,    62,    35,    35,   387,    59,    59,
  1337        75,    94,    95,    59,    97,    98,    67,    67,    59,    62,
  1338        60,    67,   471,    24,    59,   601,   602,   407,   408,    59,
  1339         5,    65,    73,    74,   471,   471,    24,    67,   487,   471,
  1340       471,   478,    62,    62,    24,    20,   478,    22,   497,    72,
  1341       487,   487,    24,    28,    24,   487,   487,   569,   569,     3,
  1342       497,    36,     3,    62,    39,   497,    62,     8,    43,    62,
  1343        45,    59,    67,   367,   368,    65,    17,    66,    53,    54,
  1344        60,    22,    23,    24,   521,    73,    74,    59,    29,   521,
  1345        60,   471,    67,    73,    74,    34,    24,    95,   478,    97,
  1346        98,    73,    74,    73,    74,    44,    59,   487,    67,    48,
  1347        71,    67,   406,     8,    53,    54,    55,    56,    59,    65,
  1348        62,   584,    62,    60,   664,   574,   420,    62,    62,   212,
  1349        71,    59,    73,    74,   571,   218,   219,   574,   574,   571,
  1350        60,   521,   574,   574,    60,    73,    74,    60,    63,    68,
  1351        60,    68,   664,   128,    35,    60,    60,    60,    60,    68,
  1352        60,   136,    60,    75,    75,   624,    60,   142,     3,   144,
  1353        36,    68,    62,   148,    60,   624,    72,    62,    60,    59,
  1354        59,    49,    75,    66,    60,    60,    60,   624,     8,    62,
  1355        60,   571,   624,    61,   574,   644,    64,    17,   173,    60,
  1356        60,    59,    22,    23,    24,    59,    68,   644,   644,    29,
  1357        62,    49,   644,   644,    62,    72,    36,    68,    62,    59,
  1358         8,    60,    68,    60,    60,    68,   201,    14,    62,    17,
  1359        72,    60,   207,    53,    22,    23,    24,    60,   213,    59,
  1360        68,    29,    60,    60,    22,    65,   221,    31,    36,   224,
  1361       584,    71,   335,    73,    74,    75,   645,   510,   526,   342,
  1362       235,   526,   244,    39,   644,    53,   282,   350,   244,   160,
  1363       393,    59,   385,   373,    22,   250,   251,    65,   214,   497,
  1364       335,   335,   464,    71,    34,    73,    74,    75,    38,    39,
  1365        40,   442,   605,    43,    44,    45,    46,   601,    48,    49,
  1366        50,    51,    52,    53,    54,    55,    56,   282,   176,   177,
  1367       178,   179,   460,   181,   182,   183,    -1,   185,   186,   187,
  1368       188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
  1369       198,    -1,   200,    -1,   202,   213,   204,    -1,    -1,    -1,
  1370       208,   209,   210,    -1,    -1,    -1,    -1,   322,    -1,    -1,
  1371       114,   115,   116,    -1,    -1,    -1,    -1,    -1,   441,    -1,
  1372        -1,    -1,    -1,    -1,   447,   448,    -1,   450,   343,    -1,
  1373        -1,     8,    -1,   137,    -1,     8,   459,    -1,   461,   354,
  1374        17,   145,    -1,    -1,    17,    22,    23,    24,   152,    22,
  1375        23,    24,    29,    -1,    -1,    -1,    29,    -1,   373,    36,
  1376       375,    -1,    -1,    36,    -1,   380,    -1,    -1,   383,    -1,
  1377       385,   175,    -1,   281,    -1,    -1,    53,    -1,   393,    -1,
  1378        53,    -1,   397,   291,    -1,   400,    59,   402,    65,    -1,
  1379        -1,    -1,    -1,    -1,    71,    -1,    -1,    74,    71,    -1,
  1380        73,    74,   417,    -1,    -1,    -1,   314,    -1,    -1,    -1,
  1381       318,    -1,    -1,    -1,    -1,    -1,   324,    -1,    -1,    -1,
  1382        -1,    -1,   226,   438,   439,    -1,    -1,   550,    -1,    -1,
  1383        -1,   446,   447,    -1,   449,   558,    -1,    -1,   242,   454,
  1384        -1,    -1,   565,    -1,    -1,   460,    -1,    -1,   463,   464,
  1385        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   473,   367,
  1386       368,    -1,    -1,   478,    -1,    -1,    -1,    -1,   272,    -1,
  1387        -1,    34,    -1,    -1,    -1,   598,    -1,    -1,   601,   602,
  1388       284,    44,    -1,   287,   288,    48,    49,    50,    51,    52,
  1389        53,    54,    55,    56,    -1,    -1,    -1,    -1,   406,    -1,
  1390        -1,    -1,    -1,     4,     5,    -1,    -1,    -1,    -1,    -1,
  1391        -1,    -1,   420,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  1392       428,    -1,    -1,    -1,    -1,   433,    -1,    -1,    -1,   652,
  1393        -1,   654,    33,    34,    -1,    36,    37,    38,    39,    40,
  1394        -1,    42,    43,    44,    45,    46,    47,    48,    49,    50,
  1395        51,    52,    53,    54,    55,    56,   571,   361,    -1,    -1,
  1396        -1,    -1,   577,    -1,    65,    -1,   474,   475,    -1,   584,
  1397        -1,    -1,    -1,    -1,    75,    -1,    -1,    -1,    -1,    -1,
  1398        -1,    -1,    -1,   387,   599,    -1,   601,    -1,    -1,   497,
  1399       605,   606,    -1,    -1,    -1,   610,   611,    -1,    -1,    -1,
  1400        -1,    -1,    -1,   407,   408,    -1,    -1,    -1,    -1,   517,
  1401        -1,    -1,    -1,    -1,    -1,    -1,   524,   525,   526,     0,
  1402         1,    -1,     3,    -1,    -1,     6,    -1,     8,     9,    10,
  1403        -1,    -1,    13,    -1,    15,    16,    17,    18,    19,    20,
  1404        -1,    22,    23,    24,    -1,    -1,    27,    28,    29,    30,
  1405        31,    32,    -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,
  1406        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    49,    50,
  1407        -1,    52,    53,    -1,    -1,    56,    -1,    -1,    59,    -1,
  1408        -1,    62,    -1,    -1,    -1,    -1,   594,    -1,    69,    70,
  1409        71,    -1,    73,    74,    -1,    -1,    -1,    -1,    -1,    -1,
  1410        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  1411        -1,    -1,    -1,   621,   622,    -1,   624,   521,    -1,    -1,
  1412        -1,     1,    -1,     3,    -1,   633,     6,     7,     8,     9,
  1413        10,    -1,    12,    13,    -1,    15,    16,    17,    18,    19,
  1414        20,    -1,    22,    23,    24,    -1,    -1,    27,    28,    29,
  1415        30,    31,    32,    -1,    -1,    -1,    36,    -1,    -1,    -1,
  1416        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    49,
  1417        50,    -1,    52,    53,    -1,    -1,    56,    -1,    -1,    59,
  1418        -1,    -1,    62,    -1,    -1,    -1,    -1,    67,    68,    69,
  1419        70,    71,    -1,    73,    74,     1,    -1,     3,    -1,    -1,
  1420         6,    -1,     8,     9,    10,    -1,    -1,    13,    -1,    15,
  1421        16,    17,    18,    19,    20,    -1,    22,    23,    24,    -1,
  1422        -1,    27,    28,    29,    30,    31,    32,    -1,    -1,    -1,
  1423        36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  1424        -1,    -1,    -1,    49,    50,    -1,    52,    53,    -1,    -1,
  1425        56,    -1,     3,    59,    -1,    -1,    62,     8,    -1,    -1,
  1426        11,    67,    68,    69,    70,    71,    17,    73,    74,    -1,
  1427        -1,    22,    23,    24,    -1,    -1,    -1,    -1,    29,    -1,
  1428        -1,    -1,    -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,
  1429        -1,    -1,    -1,    -1,    -1,     3,    -1,    -1,    49,    50,
  1430         8,    52,    53,    -1,    -1,    56,    -1,    -1,    59,    17,
  1431        -1,    -1,    -1,    -1,    22,    23,    24,    -1,    69,    70,
  1432        71,    29,    73,    74,    -1,    -1,    -1,    -1,    36,    -1,
  1433        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  1434        -1,    49,    50,    -1,    52,    53,    -1,    -1,    56,    -1,
  1435         3,    59,    60,    -1,    -1,     8,    -1,    -1,    -1,    -1,
  1436        -1,    69,    70,    71,    17,    73,    74,    -1,    -1,    22,
  1437        23,    24,    -1,    -1,    -1,    -1,    29,    -1,    -1,    -1,
  1438        -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,
  1439        -1,    -1,    -1,    -1,    -1,    -1,    49,    50,    -1,    52,
  1440        53,    -1,    -1,    56,    -1,     3,    59,    -1,    -1,    -1,
  1441         8,    -1,    -1,    -1,    67,    -1,    69,    70,    71,    17,
  1442        73,    74,    -1,    -1,    22,    23,    24,    -1,    -1,    -1,
  1443        -1,    29,    -1,    31,    -1,    -1,    -1,    -1,    36,    -1,
  1444        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  1445        -1,    49,    50,    -1,    52,    53,    -1,    -1,    56,    -1,
  1446         3,    59,    -1,    -1,    -1,     8,    -1,    -1,    -1,    -1,
  1447        -1,    69,    70,    71,    17,    73,    74,    -1,    -1,    22,
  1448        23,    24,    -1,    26,    -1,    -1,    29,    -1,    -1,    -1,
  1449        -1,    -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,
  1450        -1,    -1,    -1,    -1,    -1,    -1,    49,    50,    -1,    52,
  1451        53,    -1,    -1,    56,    -1,     3,    59,    -1,    -1,    -1,
  1452         8,    -1,    -1,    -1,    -1,    -1,    69,    70,    71,    17,
  1453        73,    74,    -1,    -1,    22,    23,    24,    -1,    26,    -1,
  1454        -1,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,    -1,
  1455        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,    -1,
  1456        -1,    49,    50,     8,    52,    53,    -1,    -1,    56,    -1,
  1457        -1,    59,    17,    -1,    -1,    -1,    -1,    22,    23,    24,
  1458        -1,    69,    70,    71,    29,    73,    74,    -1,    -1,    -1,
  1459        -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  1460        -1,    -1,    -1,    -1,    49,    50,    -1,    52,    53,    -1,
  1461        -1,    56,    -1,     3,    59,    -1,    -1,    -1,     8,    -1,
  1462        -1,    -1,    67,    -1,    69,    70,    71,    17,    73,    74,
  1463        -1,    -1,    22,    23,    24,    -1,    -1,    -1,    -1,    29,
  1464        -1,    -1,    -1,    -1,    -1,    -1,    36,    -1,    -1,    -1,
  1465        -1,    -1,    -1,    -1,    -1,    -1,     3,    -1,    -1,    49,
  1466        50,     8,    52,    53,    -1,    -1,    56,    -1,    -1,    59,
  1467        17,    -1,    -1,    -1,    -1,    22,    23,    24,    -1,    69,
  1468        70,    71,    29,    73,    74,    -1,    -1,    -1,    -1,    36,
  1469        -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
  1470        -1,    -1,    49,    50,     8,    52,    53,    -1,    -1,    56,
  1471        -1,    -1,    59,    17,    -1,    -1,    -1,    -1,    22,    23,
  1472        24,    -1,    69,    70,    71,    29,    73,    74,    -1,    -1,
  1473        -1,    -1,    36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
  1474        -1,    -1,    -1,    -1,    -1,    49,    50,     8,    52,    53,
  1475        -1,    -1,    56,    -1,    -1,    59,    17,    -1,    -1,    -1,
  1476        -1,    22,    23,    24,    -1,    69,    70,    71,    29,    73,
  1477        74,    -1,    -1,     8,    -1,    36,    11,    -1,    -1,    -1,
  1478        -1,     8,    17,    -1,    -1,    -1,    -1,    22,    23,    24,
  1479        17,    -1,    53,    -1,    29,    22,    23,    24,    59,    -1,
  1480        -1,    36,    29,    -1,    -1,    -1,     8,    -1,    -1,    36,
  1481        71,    -1,    73,    74,    75,    17,    -1,    -1,    53,    -1,
  1482        22,    23,    24,    -1,    59,    -1,    53,    29,    -1,    -1,
  1483        -1,    -1,    59,    -1,    36,    -1,    71,    -1,    73,    74,
  1484         8,    -1,    -1,    -1,    71,    -1,    73,    74,    -1,    17,
  1485        -1,    53,    -1,    -1,    22,    23,    24,    59,    -1,    -1,
  1486        -1,    29,    -1,    -1,    -1,     8,    -1,    -1,    36,    71,
  1487        -1,    73,    74,     8,    17,    -1,    -1,    -1,    -1,    22,
  1488        23,    24,    17,    -1,    -1,    53,    29,    22,    23,    24,
  1489        -1,    59,    -1,    36,    29,    -1,    -1,    -1,    -1,     8,
  1490        -1,    36,    11,    71,    -1,    73,    74,    -1,    17,    -1,
  1491        53,    -1,    -1,    22,    23,    24,    59,    -1,    53,    -1,
  1492        29,    -1,    -1,    -1,    59,    -1,     8,    36,    71,    -1,
  1493        73,    74,    -1,    -1,    -1,    17,    71,    -1,    -1,    74,
  1494        22,    23,    24,    -1,    53,    -1,    -1,    29,    -1,    -1,
  1495        -1,    -1,     8,    -1,    36,    -1,    -1,    -1,    -1,    -1,
  1496         8,    17,    71,    -1,    -1,    74,    22,    23,    24,    17,
  1497        -1,    53,    -1,    29,    22,    23,    24,    -1,    -1,    -1,
  1498        36,    29,    -1,    -1,    -1,    -1,    -1,    -1,    36,    71,
  1499        -1,    73,    74,    -1,    -1,    -1,    -1,    53,    -1,    -1,
  1500        -1,    -1,    -1,    59,    -1,    53,    -1,    -1,    -1,    -1,
  1501        -1,    -1,    -1,    -1,    -1,    71,    -1,    -1,    74,    -1,
  1502        -1,    -1,    -1,    71,    33,    34,    74,    36,    -1,    38,
  1503        39,    40,    -1,    -1,    43,    44,    45,    46,    47,    48,
  1504        49,    50,    51,    52,    53,    54,    55,    56,    -1,    -1,
  1505        -1,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    -1,
  1506        36,    -1,    38,    39,    40,    -1,    75,    43,    44,    45,
  1507        46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
  1508        56,    -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    -1,
  1509        36,    -1,    38,    39,    40,    -1,    72,    43,    44,    45,
  1510        46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
  1511        56,    33,    34,    -1,    36,    -1,    38,    39,    40,    -1,
  1512        66,    43,    44,    45,    46,    47,    48,    49,    50,    51,
  1513        52,    53,    54,    55,    56,    33,    34,    -1,    36,    -1,
  1514        38,    39,    40,    -1,    66,    43,    44,    45,    46,    47,
  1515        48,    49,    50,    51,    52,    53,    54,    55,    56,    33,
  1516        34,    -1,    36,    -1,    38,    39,    40,    -1,    66,    43,
  1517        44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
  1518        54,    55,    56,    33,    34,    -1,    -1,    -1,    38,    39,
  1519        40,    -1,    -1,    43,    44,    45,    46,    47,    48,    49,
  1520        50,    51,    52,    53,    54,    55,    56,    33,    34,    -1,
  1521        -1,    -1,    38,    39,    40,    -1,    -1,    43,    44,    45,
  1522        46,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
  1523        56
  1524  };
  1525  
  1526  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
  1527     symbol of state STATE-NUM.  */
  1528  static const yytype_uint8 yystos[] =
  1529  {
  1530         0,    77,    79,    80,     0,    25,    78,    25,    86,    24,
  1531        73,    74,   141,   142,    81,    24,    88,    89,     3,    62,
  1532        21,    82,   166,    24,    87,   214,    63,     3,    59,    63,
  1533        83,    85,   141,    62,     1,     3,     6,     8,     9,    10,
  1534        13,    15,    16,    17,    18,    19,    20,    22,    23,    27,
  1535        28,    29,    30,    31,    32,    36,    49,    50,    52,    53,
  1536        56,    59,    69,    70,    71,    90,    91,    92,    98,   110,
  1537       113,   121,   124,   126,   127,   128,   129,   134,   138,   141,
  1538       143,   144,   149,   150,   153,   156,   157,   158,   161,   164,
  1539       165,   181,   186,    62,     9,    17,    21,    31,    32,    64,
  1540       199,    24,    73,    60,    83,    84,     3,    86,    88,     3,
  1541       138,   140,   141,    17,    36,    53,    59,   141,   143,   148,
  1542       152,   153,   154,   161,   140,   128,   134,   111,    59,   141,
  1543       159,   128,   138,   114,    35,    67,   137,    71,   126,   186,
  1544       193,   125,   137,   122,    59,    96,    97,   141,    59,    93,
  1545       139,   141,   185,   127,   127,   127,   127,   127,   127,    36,
  1546        53,   126,   135,   147,   153,   155,   161,   127,   127,    11,
  1547       126,   192,    62,    59,    94,   185,     4,    33,    34,    36,
  1548        37,    38,    39,    40,    42,    43,    44,    45,    46,    47,
  1549        48,    49,    50,    51,    52,    53,    54,    55,    56,    67,
  1550        59,    63,    71,    66,    59,   137,     1,   137,     5,    65,
  1551        75,   142,   200,    59,   160,   200,    24,   200,   201,   200,
  1552        64,    62,   190,    88,    59,    36,    59,   146,   152,   153,
  1553       154,   155,   161,   146,   146,    63,    98,   107,   108,   109,
  1554       186,   194,    11,   136,   141,   145,   146,   177,   178,   179,
  1555        59,    67,   162,   112,   194,    24,    59,    68,   138,   171,
  1556       173,   175,   146,    35,    53,    59,    68,   138,   170,   172,
  1557       173,   174,   184,   112,    60,    97,   169,   146,    60,    93,
  1558       167,    65,    75,   146,     8,   147,    60,    72,    72,    60,
  1559        94,    65,   146,   126,   126,   126,   126,   126,   126,   126,
  1560       126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
  1561       126,   126,   126,   126,   130,    60,   135,   187,    59,   141,
  1562       126,   192,   182,   126,   130,     1,    67,    91,   100,   180,
  1563       181,   183,   186,   186,   126,     8,    17,    22,    23,    24,
  1564        29,    36,    53,    65,    71,   142,   202,   204,   205,   206,
  1565       141,   207,   215,   162,    59,     3,   202,   202,    83,    60,
  1566       179,     8,   146,    60,   141,    35,   105,     5,    65,    62,
  1567       146,   136,   145,    75,   191,    60,   179,   183,   115,    62,
  1568        63,    24,   173,    59,   176,    62,   190,    72,   104,    59,
  1569       174,    53,   174,    62,   190,     3,   198,    75,   146,   123,
  1570        62,   190,    62,   190,   186,   139,    65,    36,    59,   146,
  1571       152,   153,   154,   161,    67,   146,   146,    62,   190,   186,
  1572        65,    67,   126,   131,   132,   188,   189,    11,    75,   191,
  1573        31,   135,    72,    66,   180,    75,   191,   189,   101,    62,
  1574        68,    36,    59,   203,   204,   206,    59,    67,    71,    67,
  1575         8,   202,     3,    50,    59,   141,   212,   213,     3,    72,
  1576        65,    11,   202,    60,    75,    62,   195,   215,    62,    62,
  1577        62,    60,    60,   106,    26,    26,   194,   177,    59,   141,
  1578       151,   152,   153,   154,   155,   161,   163,    60,    68,   105,
  1579       194,   141,    60,   179,   175,    68,   146,     7,    12,    68,
  1580        99,   102,   174,   198,   174,    60,   172,    68,   138,   198,
  1581        35,    97,    60,    93,    60,   186,   146,   130,    94,    95,
  1582       168,   185,    60,   186,   130,    66,    75,   191,    68,   191,
  1583       135,    60,    60,    60,   192,    60,    68,   183,   180,   202,
  1584       205,   195,    24,   141,   142,   197,   202,   209,   217,   202,
  1585       141,   196,   208,   216,   202,     3,   212,    62,    72,   202,
  1586       213,   202,   198,   141,   207,    60,   183,   126,   126,    62,
  1587       179,    59,   163,   116,    60,   187,    66,   103,    60,    60,
  1588       198,   104,    60,   189,    62,   190,   146,   189,    67,   126,
  1589       133,   131,   132,    60,    66,    72,    68,    60,    60,    59,
  1590        68,    62,    72,   202,    68,    62,    49,   202,    62,   198,
  1591        59,    59,   202,   210,   211,    68,   194,    60,   179,   119,
  1592       163,     5,    65,    66,    75,   183,   198,   198,    68,    68,
  1593        95,    60,    68,   130,   192,   210,   195,   209,   202,   198,
  1594       208,   212,   195,   195,    60,    14,   117,   120,   126,   126,
  1595       189,    72,    60,    60,    60,    60,   163,    20,   100,    66,
  1596        66,    68,   210,   210,   118,   112,   105
  1597  };
  1598  
  1599  #define yyerrok		(yyerrstatus = 0)
  1600  #define yyclearin	(yychar = YYEMPTY)
  1601  #define YYEMPTY		(-2)
  1602  #define YYEOF		0
  1603  
  1604  #define YYACCEPT	goto yyacceptlab
  1605  #define YYABORT		goto yyabortlab
  1606  #define YYERROR		goto yyerrorlab
  1607  
  1608  
  1609  /* Like YYERROR except do call yyerror.  This remains here temporarily
  1610     to ease the transition to the new meaning of YYERROR, for GCC.
  1611     Once GCC version 2 has supplanted version 1, this can go.  However,
  1612     YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
  1613     in Bison 2.4.2's NEWS entry, where a plan to phase it out is
  1614     discussed.  */
  1615  
  1616  #define YYFAIL		goto yyerrlab
  1617  #if defined YYFAIL
  1618    /* This is here to suppress warnings from the GCC cpp's
  1619       -Wunused-macros.  Normally we don't worry about that warning, but
  1620       some users do, and we want to make it easy for users to remove
  1621       YYFAIL uses, which will produce warnings from Bison 2.5.  */
  1622  #endif
  1623  
  1624  #define YYRECOVERING()  (!!yyerrstatus)
  1625  
  1626  #define YYBACKUP(Token, Value)					\
  1627  do								\
  1628    if (yychar == YYEMPTY && yylen == 1)				\
  1629      {								\
  1630        yychar = (Token);						\
  1631        yylval = (Value);						\
  1632        YYPOPSTACK (1);						\
  1633        goto yybackup;						\
  1634      }								\
  1635    else								\
  1636      {								\
  1637        yyerror (YY_("syntax error: cannot back up")); \
  1638        YYERROR;							\
  1639      }								\
  1640  while (YYID (0))
  1641  
  1642  
  1643  #define YYTERROR	1
  1644  #define YYERRCODE	256
  1645  
  1646  
  1647  /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
  1648     If N is 0, then set CURRENT to the empty location which ends
  1649     the previous symbol: RHS[0] (always defined).  */
  1650  
  1651  #define YYRHSLOC(Rhs, K) ((Rhs)[K])
  1652  #ifndef YYLLOC_DEFAULT
  1653  # define YYLLOC_DEFAULT(Current, Rhs, N)				\
  1654      do									\
  1655        if (YYID (N))                                                    \
  1656  	{								\
  1657  	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
  1658  	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
  1659  	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
  1660  	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
  1661  	}								\
  1662        else								\
  1663  	{								\
  1664  	  (Current).first_line   = (Current).last_line   =		\
  1665  	    YYRHSLOC (Rhs, 0).last_line;				\
  1666  	  (Current).first_column = (Current).last_column =		\
  1667  	    YYRHSLOC (Rhs, 0).last_column;				\
  1668  	}								\
  1669      while (YYID (0))
  1670  #endif
  1671  
  1672  
  1673  /* This macro is provided for backward compatibility. */
  1674  
  1675  #ifndef YY_LOCATION_PRINT
  1676  # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
  1677  #endif
  1678  
  1679  
  1680  /* YYLEX -- calling `yylex' with the right arguments.  */
  1681  
  1682  #ifdef YYLEX_PARAM
  1683  # define YYLEX yylex (YYLEX_PARAM)
  1684  #else
  1685  # define YYLEX yylex ()
  1686  #endif
  1687  
  1688  /* Enable debugging if requested.  */
  1689  #if YYDEBUG
  1690  
  1691  # ifndef YYFPRINTF
  1692  #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
  1693  #  define YYFPRINTF fprintf
  1694  # endif
  1695  
  1696  # define YYDPRINTF(Args)			\
  1697  do {						\
  1698    if (yydebug)					\
  1699      YYFPRINTF Args;				\
  1700  } while (YYID (0))
  1701  
  1702  # define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
  1703  do {									  \
  1704    if (yydebug)								  \
  1705      {									  \
  1706        YYFPRINTF (stderr, "%s ", Title);					  \
  1707        yy_symbol_print (stderr,						  \
  1708  		  Type, Value); \
  1709        YYFPRINTF (stderr, "\n");						  \
  1710      }									  \
  1711  } while (YYID (0))
  1712  
  1713  
  1714  /*--------------------------------.
  1715  | Print this symbol on YYOUTPUT.  |
  1716  `--------------------------------*/
  1717  
  1718  /*ARGSUSED*/
  1719  #if (defined __STDC__ || defined __C99__FUNC__ \
  1720       || defined __cplusplus || defined _MSC_VER)
  1721  static void
  1722  yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
  1723  #else
  1724  static void
  1725  yy_symbol_value_print (yyoutput, yytype, yyvaluep)
  1726      FILE *yyoutput;
  1727      int yytype;
  1728      YYSTYPE const * const yyvaluep;
  1729  #endif
  1730  {
  1731    if (!yyvaluep)
  1732      return;
  1733  # ifdef YYPRINT
  1734    if (yytype < YYNTOKENS)
  1735      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
  1736  # else
  1737    YYUSE (yyoutput);
  1738  # endif
  1739    switch (yytype)
  1740      {
  1741        default:
  1742  	break;
  1743      }
  1744  }
  1745  
  1746  
  1747  /*--------------------------------.
  1748  | Print this symbol on YYOUTPUT.  |
  1749  `--------------------------------*/
  1750  
  1751  #if (defined __STDC__ || defined __C99__FUNC__ \
  1752       || defined __cplusplus || defined _MSC_VER)
  1753  static void
  1754  yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
  1755  #else
  1756  static void
  1757  yy_symbol_print (yyoutput, yytype, yyvaluep)
  1758      FILE *yyoutput;
  1759      int yytype;
  1760      YYSTYPE const * const yyvaluep;
  1761  #endif
  1762  {
  1763    if (yytype < YYNTOKENS)
  1764      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
  1765    else
  1766      YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
  1767  
  1768    yy_symbol_value_print (yyoutput, yytype, yyvaluep);
  1769    YYFPRINTF (yyoutput, ")");
  1770  }
  1771  
  1772  /*------------------------------------------------------------------.
  1773  | yy_stack_print -- Print the state stack from its BOTTOM up to its |
  1774  | TOP (included).                                                   |
  1775  `------------------------------------------------------------------*/
  1776  
  1777  #if (defined __STDC__ || defined __C99__FUNC__ \
  1778       || defined __cplusplus || defined _MSC_VER)
  1779  static void
  1780  yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
  1781  #else
  1782  static void
  1783  yy_stack_print (yybottom, yytop)
  1784      yytype_int16 *yybottom;
  1785      yytype_int16 *yytop;
  1786  #endif
  1787  {
  1788    YYFPRINTF (stderr, "Stack now");
  1789    for (; yybottom <= yytop; yybottom++)
  1790      {
  1791        int yybot = *yybottom;
  1792        YYFPRINTF (stderr, " %d", yybot);
  1793      }
  1794    YYFPRINTF (stderr, "\n");
  1795  }
  1796  
  1797  # define YY_STACK_PRINT(Bottom, Top)				\
  1798  do {								\
  1799    if (yydebug)							\
  1800      yy_stack_print ((Bottom), (Top));				\
  1801  } while (YYID (0))
  1802  
  1803  
  1804  /*------------------------------------------------.
  1805  | Report that the YYRULE is going to be reduced.  |
  1806  `------------------------------------------------*/
  1807  
  1808  #if (defined __STDC__ || defined __C99__FUNC__ \
  1809       || defined __cplusplus || defined _MSC_VER)
  1810  static void
  1811  yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
  1812  #else
  1813  static void
  1814  yy_reduce_print (yyvsp, yyrule)
  1815      YYSTYPE *yyvsp;
  1816      int yyrule;
  1817  #endif
  1818  {
  1819    int yynrhs = yyr2[yyrule];
  1820    int yyi;
  1821    unsigned long int yylno = yyrline[yyrule];
  1822    YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
  1823  	     yyrule - 1, yylno);
  1824    /* The symbols being reduced.  */
  1825    for (yyi = 0; yyi < yynrhs; yyi++)
  1826      {
  1827        YYFPRINTF (stderr, "   $%d = ", yyi + 1);
  1828        yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
  1829  		       &(yyvsp[(yyi + 1) - (yynrhs)])
  1830  		       		       );
  1831        YYFPRINTF (stderr, "\n");
  1832      }
  1833  }
  1834  
  1835  # define YY_REDUCE_PRINT(Rule)		\
  1836  do {					\
  1837    if (yydebug)				\
  1838      yy_reduce_print (yyvsp, Rule); \
  1839  } while (YYID (0))
  1840  
  1841  /* Nonzero means print parse trace.  It is left uninitialized so that
  1842     multiple parsers can coexist.  */
  1843  int yydebug;
  1844  #else /* !YYDEBUG */
  1845  # define YYDPRINTF(Args)
  1846  # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
  1847  # define YY_STACK_PRINT(Bottom, Top)
  1848  # define YY_REDUCE_PRINT(Rule)
  1849  #endif /* !YYDEBUG */
  1850  
  1851  
  1852  /* YYINITDEPTH -- initial size of the parser's stacks.  */
  1853  #ifndef	YYINITDEPTH
  1854  # define YYINITDEPTH 200
  1855  #endif
  1856  
  1857  /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
  1858     if the built-in stack extension method is used).
  1859  
  1860     Do not make this value too large; the results are undefined if
  1861     YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
  1862     evaluated with infinite-precision integer arithmetic.  */
  1863  
  1864  #ifndef YYMAXDEPTH
  1865  # define YYMAXDEPTH 10000
  1866  #endif
  1867  
  1868  
  1869  #if YYERROR_VERBOSE
  1870  
  1871  # ifndef yystrlen
  1872  #  if defined __GLIBC__ && defined _STRING_H
  1873  #   define yystrlen strlen
  1874  #  else
  1875  /* Return the length of YYSTR.  */
  1876  #if (defined __STDC__ || defined __C99__FUNC__ \
  1877       || defined __cplusplus || defined _MSC_VER)
  1878  static YYSIZE_T
  1879  yystrlen (const char *yystr)
  1880  #else
  1881  static YYSIZE_T
  1882  yystrlen (yystr)
  1883      const char *yystr;
  1884  #endif
  1885  {
  1886    YYSIZE_T yylen;
  1887    for (yylen = 0; yystr[yylen]; yylen++)
  1888      continue;
  1889    return yylen;
  1890  }
  1891  #  endif
  1892  # endif
  1893  
  1894  # ifndef yystpcpy
  1895  #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
  1896  #   define yystpcpy stpcpy
  1897  #  else
  1898  /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
  1899     YYDEST.  */
  1900  #if (defined __STDC__ || defined __C99__FUNC__ \
  1901       || defined __cplusplus || defined _MSC_VER)
  1902  static char *
  1903  yystpcpy (char *yydest, const char *yysrc)
  1904  #else
  1905  static char *
  1906  yystpcpy (yydest, yysrc)
  1907      char *yydest;
  1908      const char *yysrc;
  1909  #endif
  1910  {
  1911    char *yyd = yydest;
  1912    const char *yys = yysrc;
  1913  
  1914    while ((*yyd++ = *yys++) != '\0')
  1915      continue;
  1916  
  1917    return yyd - 1;
  1918  }
  1919  #  endif
  1920  # endif
  1921  
  1922  # ifndef yytnamerr
  1923  /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
  1924     quotes and backslashes, so that it's suitable for yyerror.  The
  1925     heuristic is that double-quoting is unnecessary unless the string
  1926     contains an apostrophe, a comma, or backslash (other than
  1927     backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
  1928     null, do not copy; instead, return the length of what the result
  1929     would have been.  */
  1930  static YYSIZE_T
  1931  yytnamerr (char *yyres, const char *yystr)
  1932  {
  1933    if (*yystr == '"')
  1934      {
  1935        YYSIZE_T yyn = 0;
  1936        char const *yyp = yystr;
  1937  
  1938        for (;;)
  1939  	switch (*++yyp)
  1940  	  {
  1941  	  case '\'':
  1942  	  case ',':
  1943  	    goto do_not_strip_quotes;
  1944  
  1945  	  case '\\':
  1946  	    if (*++yyp != '\\')
  1947  	      goto do_not_strip_quotes;
  1948  	    /* Fall through.  */
  1949  	  default:
  1950  	    if (yyres)
  1951  	      yyres[yyn] = *yyp;
  1952  	    yyn++;
  1953  	    break;
  1954  
  1955  	  case '"':
  1956  	    if (yyres)
  1957  	      yyres[yyn] = '\0';
  1958  	    return yyn;
  1959  	  }
  1960      do_not_strip_quotes: ;
  1961      }
  1962  
  1963    if (! yyres)
  1964      return yystrlen (yystr);
  1965  
  1966    return yystpcpy (yyres, yystr) - yyres;
  1967  }
  1968  # endif
  1969  
  1970  /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
  1971     about the unexpected token YYTOKEN for the state stack whose top is
  1972     YYSSP.
  1973  
  1974     Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
  1975     not large enough to hold the message.  In that case, also set
  1976     *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
  1977     required number of bytes is too large to store.  */
  1978  static int
  1979  yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
  1980                  yytype_int16 *yyssp, int yytoken)
  1981  {
  1982    YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
  1983    YYSIZE_T yysize = yysize0;
  1984    YYSIZE_T yysize1;
  1985    enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  1986    /* Internationalized format string. */
  1987    const char *yyformat = 0;
  1988    /* Arguments of yyformat. */
  1989    char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  1990    /* Number of reported tokens (one for the "unexpected", one per
  1991       "expected"). */
  1992    int yycount = 0;
  1993  
  1994    /* There are many possibilities here to consider:
  1995       - Assume YYFAIL is not used.  It's too flawed to consider.  See
  1996         <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
  1997         for details.  YYERROR is fine as it does not invoke this
  1998         function.
  1999       - If this state is a consistent state with a default action, then
  2000         the only way this function was invoked is if the default action
  2001         is an error action.  In that case, don't check for expected
  2002         tokens because there are none.
  2003       - The only way there can be no lookahead present (in yychar) is if
  2004         this state is a consistent state with a default action.  Thus,
  2005         detecting the absence of a lookahead is sufficient to determine
  2006         that there is no unexpected or expected token to report.  In that
  2007         case, just report a simple "syntax error".
  2008       - Don't assume there isn't a lookahead just because this state is a
  2009         consistent state with a default action.  There might have been a
  2010         previous inconsistent state, consistent state with a non-default
  2011         action, or user semantic action that manipulated yychar.
  2012       - Of course, the expected token list depends on states to have
  2013         correct lookahead information, and it depends on the parser not
  2014         to perform extra reductions after fetching a lookahead from the
  2015         scanner and before detecting a syntax error.  Thus, state merging
  2016         (from LALR or IELR) and default reductions corrupt the expected
  2017         token list.  However, the list is correct for canonical LR with
  2018         one exception: it will still contain any token that will not be
  2019         accepted due to an error action in a later state.
  2020    */
  2021    if (yytoken != YYEMPTY)
  2022      {
  2023        int yyn = yypact[*yyssp];
  2024        yyarg[yycount++] = yytname[yytoken];
  2025        if (!yypact_value_is_default (yyn))
  2026          {
  2027            /* Start YYX at -YYN if negative to avoid negative indexes in
  2028               YYCHECK.  In other words, skip the first -YYN actions for
  2029               this state because they are default actions.  */
  2030            int yyxbegin = yyn < 0 ? -yyn : 0;
  2031            /* Stay within bounds of both yycheck and yytname.  */
  2032            int yychecklim = YYLAST - yyn + 1;
  2033            int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
  2034            int yyx;
  2035  
  2036            for (yyx = yyxbegin; yyx < yyxend; ++yyx)
  2037              if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
  2038                  && !yytable_value_is_error (yytable[yyx + yyn]))
  2039                {
  2040                  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
  2041                    {
  2042                      yycount = 1;
  2043                      yysize = yysize0;
  2044                      break;
  2045                    }
  2046                  yyarg[yycount++] = yytname[yyx];
  2047                  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
  2048                  if (! (yysize <= yysize1
  2049                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
  2050                    return 2;
  2051                  yysize = yysize1;
  2052                }
  2053          }
  2054      }
  2055  
  2056    switch (yycount)
  2057      {
  2058  # define YYCASE_(N, S)                      \
  2059        case N:                               \
  2060          yyformat = S;                       \
  2061        break
  2062        YYCASE_(0, YY_("syntax error"));
  2063        YYCASE_(1, YY_("syntax error, unexpected %s"));
  2064        YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
  2065        YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
  2066        YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
  2067        YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
  2068  # undef YYCASE_
  2069      }
  2070  
  2071    yysize1 = yysize + yystrlen (yyformat);
  2072    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
  2073      return 2;
  2074    yysize = yysize1;
  2075  
  2076    if (*yymsg_alloc < yysize)
  2077      {
  2078        *yymsg_alloc = 2 * yysize;
  2079        if (! (yysize <= *yymsg_alloc
  2080               && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
  2081          *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
  2082        return 1;
  2083      }
  2084  
  2085    /* Avoid sprintf, as that infringes on the user's name space.
  2086       Don't have undefined behavior even if the translation
  2087       produced a string with the wrong number of "%s"s.  */
  2088    {
  2089      char *yyp = *yymsg;
  2090      int yyi = 0;
  2091      while ((*yyp = *yyformat) != '\0')
  2092        if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
  2093          {
  2094            yyp += yytnamerr (yyp, yyarg[yyi++]);
  2095            yyformat += 2;
  2096          }
  2097        else
  2098          {
  2099            yyp++;
  2100            yyformat++;
  2101          }
  2102    }
  2103    return 0;
  2104  }
  2105  #endif /* YYERROR_VERBOSE */
  2106  
  2107  /*-----------------------------------------------.
  2108  | Release the memory associated to this symbol.  |
  2109  `-----------------------------------------------*/
  2110  
  2111  /*ARGSUSED*/
  2112  #if (defined __STDC__ || defined __C99__FUNC__ \
  2113       || defined __cplusplus || defined _MSC_VER)
  2114  static void
  2115  yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
  2116  #else
  2117  static void
  2118  yydestruct (yymsg, yytype, yyvaluep)
  2119      const char *yymsg;
  2120      int yytype;
  2121      YYSTYPE *yyvaluep;
  2122  #endif
  2123  {
  2124    YYUSE (yyvaluep);
  2125  
  2126    if (!yymsg)
  2127      yymsg = "Deleting";
  2128    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
  2129  
  2130    switch (yytype)
  2131      {
  2132  
  2133        default:
  2134  	break;
  2135      }
  2136  }
  2137  
  2138  
  2139  /* Prevent warnings from -Wmissing-prototypes.  */
  2140  #ifdef YYPARSE_PARAM
  2141  #if defined __STDC__ || defined __cplusplus
  2142  int yyparse (void *YYPARSE_PARAM);
  2143  #else
  2144  int yyparse ();
  2145  #endif
  2146  #else /* ! YYPARSE_PARAM */
  2147  #if defined __STDC__ || defined __cplusplus
  2148  int yyparse (void);
  2149  #else
  2150  int yyparse ();
  2151  #endif
  2152  #endif /* ! YYPARSE_PARAM */
  2153  
  2154  
  2155  /* The lookahead symbol.  */
  2156  int yychar, yystate;
  2157  
  2158  /* The semantic value of the lookahead symbol.  */
  2159  YYSTYPE yylval;
  2160  
  2161  /* Number of syntax errors so far.  */
  2162  int yynerrs;
  2163  
  2164  
  2165  /*----------.
  2166  | yyparse.  |
  2167  `----------*/
  2168  
  2169  #ifdef YYPARSE_PARAM
  2170  #if (defined __STDC__ || defined __C99__FUNC__ \
  2171       || defined __cplusplus || defined _MSC_VER)
  2172  int
  2173  yyparse (void *YYPARSE_PARAM)
  2174  #else
  2175  int
  2176  yyparse (YYPARSE_PARAM)
  2177      void *YYPARSE_PARAM;
  2178  #endif
  2179  #else /* ! YYPARSE_PARAM */
  2180  #if (defined __STDC__ || defined __C99__FUNC__ \
  2181       || defined __cplusplus || defined _MSC_VER)
  2182  int
  2183  yyparse (void)
  2184  #else
  2185  int
  2186  yyparse ()
  2187  
  2188  #endif
  2189  #endif
  2190  {
  2191      /* Number of tokens to shift before error messages enabled.  */
  2192      int yyerrstatus;
  2193  
  2194      /* The stacks and their tools:
  2195         `yyss': related to states.
  2196         `yyvs': related to semantic values.
  2197  
  2198         Refer to the stacks thru separate pointers, to allow yyoverflow
  2199         to reallocate them elsewhere.  */
  2200  
  2201      /* The state stack.  */
  2202      yytype_int16 yyssa[YYINITDEPTH];
  2203      yytype_int16 *yyss;
  2204      yytype_int16 *yyssp;
  2205  
  2206      /* The semantic value stack.  */
  2207      YYSTYPE yyvsa[YYINITDEPTH];
  2208      YYSTYPE *yyvs;
  2209      YYSTYPE *yyvsp;
  2210  
  2211      YYSIZE_T yystacksize;
  2212  
  2213    int yyn;
  2214    int yyresult;
  2215    /* Lookahead token as an internal (translated) token number.  */
  2216    int yytoken;
  2217    /* The variables used to return semantic value and location from the
  2218       action routines.  */
  2219    YYSTYPE yyval;
  2220  
  2221  #if YYERROR_VERBOSE
  2222    /* Buffer for error messages, and its allocated size.  */
  2223    char yymsgbuf[128];
  2224    char *yymsg = yymsgbuf;
  2225    YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
  2226  #endif
  2227  
  2228  #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
  2229  
  2230    /* The number of symbols on the RHS of the reduced rule.
  2231       Keep to zero when no symbol should be popped.  */
  2232    int yylen = 0;
  2233  
  2234    yytoken = 0;
  2235    yyss = yyssa;
  2236    yyvs = yyvsa;
  2237    yystacksize = YYINITDEPTH;
  2238  
  2239    YYDPRINTF ((stderr, "Starting parse\n"));
  2240  
  2241    yystate = 0;
  2242    yyerrstatus = 0;
  2243    yynerrs = 0;
  2244    yychar = YYEMPTY; /* Cause a token to be read.  */
  2245  
  2246    /* Initialize stack pointers.
  2247       Waste one element of value and location stack
  2248       so that they stay on the same level as the state stack.
  2249       The wasted elements are never initialized.  */
  2250    yyssp = yyss;
  2251    yyvsp = yyvs;
  2252  
  2253    goto yysetstate;
  2254  
  2255  /*------------------------------------------------------------.
  2256  | yynewstate -- Push a new state, which is found in yystate.  |
  2257  `------------------------------------------------------------*/
  2258   yynewstate:
  2259    /* In all cases, when you get here, the value and location stacks
  2260       have just been pushed.  So pushing a state here evens the stacks.  */
  2261    yyssp++;
  2262  
  2263   yysetstate:
  2264    *yyssp = yystate;
  2265  
  2266    if (yyss + yystacksize - 1 <= yyssp)
  2267      {
  2268        /* Get the current used size of the three stacks, in elements.  */
  2269        YYSIZE_T yysize = yyssp - yyss + 1;
  2270  
  2271  #ifdef yyoverflow
  2272        {
  2273  	/* Give user a chance to reallocate the stack.  Use copies of
  2274  	   these so that the &'s don't force the real ones into
  2275  	   memory.  */
  2276  	YYSTYPE *yyvs1 = yyvs;
  2277  	yytype_int16 *yyss1 = yyss;
  2278  
  2279  	/* Each stack pointer address is followed by the size of the
  2280  	   data in use in that stack, in bytes.  This used to be a
  2281  	   conditional around just the two extra args, but that might
  2282  	   be undefined if yyoverflow is a macro.  */
  2283  	yyoverflow (YY_("memory exhausted"),
  2284  		    &yyss1, yysize * sizeof (*yyssp),
  2285  		    &yyvs1, yysize * sizeof (*yyvsp),
  2286  		    &yystacksize);
  2287  
  2288  	yyss = yyss1;
  2289  	yyvs = yyvs1;
  2290        }
  2291  #else /* no yyoverflow */
  2292  # ifndef YYSTACK_RELOCATE
  2293        goto yyexhaustedlab;
  2294  # else
  2295        /* Extend the stack our own way.  */
  2296        if (YYMAXDEPTH <= yystacksize)
  2297  	goto yyexhaustedlab;
  2298        yystacksize *= 2;
  2299        if (YYMAXDEPTH < yystacksize)
  2300  	yystacksize = YYMAXDEPTH;
  2301  
  2302        {
  2303  	yytype_int16 *yyss1 = yyss;
  2304  	union yyalloc *yyptr =
  2305  	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
  2306  	if (! yyptr)
  2307  	  goto yyexhaustedlab;
  2308  	YYSTACK_RELOCATE (yyss_alloc, yyss);
  2309  	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
  2310  #  undef YYSTACK_RELOCATE
  2311  	if (yyss1 != yyssa)
  2312  	  YYSTACK_FREE (yyss1);
  2313        }
  2314  # endif
  2315  #endif /* no yyoverflow */
  2316  
  2317        yyssp = yyss + yysize - 1;
  2318        yyvsp = yyvs + yysize - 1;
  2319  
  2320        YYDPRINTF ((stderr, "Stack size increased to %lu\n",
  2321  		  (unsigned long int) yystacksize));
  2322  
  2323        if (yyss + yystacksize - 1 <= yyssp)
  2324  	YYABORT;
  2325      }
  2326  
  2327    YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  2328  
  2329    if (yystate == YYFINAL)
  2330      YYACCEPT;
  2331  
  2332    goto yybackup;
  2333  
  2334  /*-----------.
  2335  | yybackup.  |
  2336  `-----------*/
  2337  yybackup:
  2338  
  2339    /* Do appropriate processing given the current state.  Read a
  2340       lookahead token if we need one and don't already have one.  */
  2341  
  2342    /* First try to decide what to do without reference to lookahead token.  */
  2343    yyn = yypact[yystate];
  2344    if (yypact_value_is_default (yyn))
  2345      goto yydefault;
  2346  
  2347    /* Not known => get a lookahead token if don't already have one.  */
  2348  
  2349    /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  2350    if (yychar == YYEMPTY)
  2351      {
  2352        YYDPRINTF ((stderr, "Reading a token: "));
  2353        yychar = YYLEX;
  2354      }
  2355  
  2356    if (yychar <= YYEOF)
  2357      {
  2358        yychar = yytoken = YYEOF;
  2359        YYDPRINTF ((stderr, "Now at end of input.\n"));
  2360      }
  2361    else
  2362      {
  2363        yytoken = YYTRANSLATE (yychar);
  2364        YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
  2365      }
  2366  
  2367    /* If the proper action on seeing token YYTOKEN is to reduce or to
  2368       detect an error, take that action.  */
  2369    yyn += yytoken;
  2370    if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
  2371      goto yydefault;
  2372    yyn = yytable[yyn];
  2373    if (yyn <= 0)
  2374      {
  2375        if (yytable_value_is_error (yyn))
  2376          goto yyerrlab;
  2377        yyn = -yyn;
  2378        goto yyreduce;
  2379      }
  2380  
  2381    /* Count tokens shifted since error; after three, turn off error
  2382       status.  */
  2383    if (yyerrstatus)
  2384      yyerrstatus--;
  2385  
  2386    /* Shift the lookahead token.  */
  2387    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
  2388  
  2389    /* Discard the shifted token.  */
  2390    yychar = YYEMPTY;
  2391  
  2392    yystate = yyn;
  2393    *++yyvsp = yylval;
  2394  
  2395    goto yynewstate;
  2396  
  2397  
  2398  /*-----------------------------------------------------------.
  2399  | yydefault -- do the default action for the current state.  |
  2400  `-----------------------------------------------------------*/
  2401  yydefault:
  2402    yyn = yydefact[yystate];
  2403    if (yyn == 0)
  2404      goto yyerrlab;
  2405    goto yyreduce;
  2406  
  2407  
  2408  /*-----------------------------.
  2409  | yyreduce -- Do a reduction.  |
  2410  `-----------------------------*/
  2411  yyreduce:
  2412    /* yyn is the number of a rule to reduce with.  */
  2413    yylen = yyr2[yyn];
  2414  
  2415    /* If YYLEN is nonzero, implement the default value of the action:
  2416       `$$ = $1'.
  2417  
  2418       Otherwise, the following line sets YYVAL to garbage.
  2419       This behavior is undocumented and Bison
  2420       users should not rely upon it.  Assigning to YYVAL
  2421       unconditionally makes the parser a bit smaller, and it avoids a
  2422       GCC warning that YYVAL may be used uninitialized.  */
  2423    yyval = yyvsp[1-yylen];
  2424  
  2425  
  2426    YY_REDUCE_PRINT (yyn);
  2427    switch (yyn)
  2428      {
  2429          case 2:
  2430  
  2431  /* Line 1806 of yacc.c  */
  2432  #line 128 "go.y"
  2433      {
  2434  		xtop = concat(xtop, (yyvsp[(4) - (4)].list));
  2435  	}
  2436      break;
  2437  
  2438    case 3:
  2439  
  2440  /* Line 1806 of yacc.c  */
  2441  #line 134 "go.y"
  2442      {
  2443  		prevlineno = lineno;
  2444  		yyerror("package statement must be first");
  2445  		errorexit();
  2446  	}
  2447      break;
  2448  
  2449    case 4:
  2450  
  2451  /* Line 1806 of yacc.c  */
  2452  #line 140 "go.y"
  2453      {
  2454  		mkpackage((yyvsp[(2) - (3)].sym)->name);
  2455  	}
  2456      break;
  2457  
  2458    case 5:
  2459  
  2460  /* Line 1806 of yacc.c  */
  2461  #line 150 "go.y"
  2462      {
  2463  		importpkg = runtimepkg;
  2464  
  2465  		if(debug['A'])
  2466  			cannedimports("runtime.builtin", "package runtime\n\n$$\n\n");
  2467  		else
  2468  			cannedimports("runtime.builtin", runtimeimport);
  2469  		curio.importsafe = 1;
  2470  	}
  2471      break;
  2472  
  2473    case 6:
  2474  
  2475  /* Line 1806 of yacc.c  */
  2476  #line 161 "go.y"
  2477      {
  2478  		importpkg = nil;
  2479  	}
  2480      break;
  2481  
  2482    case 12:
  2483  
  2484  /* Line 1806 of yacc.c  */
  2485  #line 175 "go.y"
  2486      {
  2487  		Pkg *ipkg;
  2488  		Sym *my;
  2489  		Node *pack;
  2490  		
  2491  		ipkg = importpkg;
  2492  		my = importmyname;
  2493  		importpkg = nil;
  2494  		importmyname = S;
  2495  
  2496  		if(my == nil)
  2497  			my = lookup(ipkg->name);
  2498  
  2499  		pack = nod(OPACK, N, N);
  2500  		pack->sym = my;
  2501  		pack->pkg = ipkg;
  2502  		pack->lineno = (yyvsp[(1) - (3)].i);
  2503  
  2504  		if(my->name[0] == '.') {
  2505  			importdot(ipkg, pack);
  2506  			break;
  2507  		}
  2508  		if(strcmp(my->name, "init") == 0) {
  2509  			yyerror("cannot import package as init - init must be a func");
  2510  			break;
  2511  		}
  2512  		if(my->name[0] == '_' && my->name[1] == '\0')
  2513  			break;
  2514  		if(my->def) {
  2515  			lineno = (yyvsp[(1) - (3)].i);
  2516  			redeclare(my, "as imported package name");
  2517  		}
  2518  		my->def = pack;
  2519  		my->lastlineno = (yyvsp[(1) - (3)].i);
  2520  		my->block = 1;	// at top level
  2521  	}
  2522      break;
  2523  
  2524    case 13:
  2525  
  2526  /* Line 1806 of yacc.c  */
  2527  #line 212 "go.y"
  2528      {
  2529  		// When an invalid import path is passed to importfile,
  2530  		// it calls yyerror and then sets up a fake import with
  2531  		// no package statement. This allows us to test more
  2532  		// than one invalid import statement in a single file.
  2533  		if(nerrors == 0)
  2534  			fatal("phase error in import");
  2535  	}
  2536      break;
  2537  
  2538    case 16:
  2539  
  2540  /* Line 1806 of yacc.c  */
  2541  #line 227 "go.y"
  2542      {
  2543  		// import with original name
  2544  		(yyval.i) = parserline();
  2545  		importmyname = S;
  2546  		importfile(&(yyvsp[(1) - (1)].val), (yyval.i));
  2547  	}
  2548      break;
  2549  
  2550    case 17:
  2551  
  2552  /* Line 1806 of yacc.c  */
  2553  #line 234 "go.y"
  2554      {
  2555  		// import with given name
  2556  		(yyval.i) = parserline();
  2557  		importmyname = (yyvsp[(1) - (2)].sym);
  2558  		importfile(&(yyvsp[(2) - (2)].val), (yyval.i));
  2559  	}
  2560      break;
  2561  
  2562    case 18:
  2563  
  2564  /* Line 1806 of yacc.c  */
  2565  #line 241 "go.y"
  2566      {
  2567  		// import into my name space
  2568  		(yyval.i) = parserline();
  2569  		importmyname = lookup(".");
  2570  		importfile(&(yyvsp[(2) - (2)].val), (yyval.i));
  2571  	}
  2572      break;
  2573  
  2574    case 19:
  2575  
  2576  /* Line 1806 of yacc.c  */
  2577  #line 250 "go.y"
  2578      {
  2579  		if(importpkg->name == nil) {
  2580  			importpkg->name = (yyvsp[(2) - (4)].sym)->name;
  2581  			pkglookup((yyvsp[(2) - (4)].sym)->name, nil)->npkg++;
  2582  		} else if(strcmp(importpkg->name, (yyvsp[(2) - (4)].sym)->name) != 0)
  2583  			yyerror("conflicting names %s and %s for package \"%Z\"", importpkg->name, (yyvsp[(2) - (4)].sym)->name, importpkg->path);
  2584  		importpkg->direct = 1;
  2585  		importpkg->safe = curio.importsafe;
  2586  
  2587  		if(safemode && !curio.importsafe)
  2588  			yyerror("cannot import unsafe package \"%Z\"", importpkg->path);
  2589  	}
  2590      break;
  2591  
  2592    case 21:
  2593  
  2594  /* Line 1806 of yacc.c  */
  2595  #line 265 "go.y"
  2596      {
  2597  		if(strcmp((yyvsp[(1) - (1)].sym)->name, "safe") == 0)
  2598  			curio.importsafe = 1;
  2599  	}
  2600      break;
  2601  
  2602    case 22:
  2603  
  2604  /* Line 1806 of yacc.c  */
  2605  #line 271 "go.y"
  2606      {
  2607  		defercheckwidth();
  2608  	}
  2609      break;
  2610  
  2611    case 23:
  2612  
  2613  /* Line 1806 of yacc.c  */
  2614  #line 275 "go.y"
  2615      {
  2616  		resumecheckwidth();
  2617  		unimportfile();
  2618  	}
  2619      break;
  2620  
  2621    case 24:
  2622  
  2623  /* Line 1806 of yacc.c  */
  2624  #line 284 "go.y"
  2625      {
  2626  		yyerror("empty top-level declaration");
  2627  		(yyval.list) = nil;
  2628  	}
  2629      break;
  2630  
  2631    case 26:
  2632  
  2633  /* Line 1806 of yacc.c  */
  2634  #line 290 "go.y"
  2635      {
  2636  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  2637  	}
  2638      break;
  2639  
  2640    case 27:
  2641  
  2642  /* Line 1806 of yacc.c  */
  2643  #line 294 "go.y"
  2644      {
  2645  		yyerror("non-declaration statement outside function body");
  2646  		(yyval.list) = nil;
  2647  	}
  2648      break;
  2649  
  2650    case 28:
  2651  
  2652  /* Line 1806 of yacc.c  */
  2653  #line 299 "go.y"
  2654      {
  2655  		(yyval.list) = nil;
  2656  	}
  2657      break;
  2658  
  2659    case 29:
  2660  
  2661  /* Line 1806 of yacc.c  */
  2662  #line 305 "go.y"
  2663      {
  2664  		(yyval.list) = (yyvsp[(2) - (2)].list);
  2665  	}
  2666      break;
  2667  
  2668    case 30:
  2669  
  2670  /* Line 1806 of yacc.c  */
  2671  #line 309 "go.y"
  2672      {
  2673  		(yyval.list) = (yyvsp[(3) - (5)].list);
  2674  	}
  2675      break;
  2676  
  2677    case 31:
  2678  
  2679  /* Line 1806 of yacc.c  */
  2680  #line 313 "go.y"
  2681      {
  2682  		(yyval.list) = nil;
  2683  	}
  2684      break;
  2685  
  2686    case 32:
  2687  
  2688  /* Line 1806 of yacc.c  */
  2689  #line 317 "go.y"
  2690      {
  2691  		(yyval.list) = (yyvsp[(2) - (2)].list);
  2692  		iota = -100000;
  2693  		lastconst = nil;
  2694  	}
  2695      break;
  2696  
  2697    case 33:
  2698  
  2699  /* Line 1806 of yacc.c  */
  2700  #line 323 "go.y"
  2701      {
  2702  		(yyval.list) = (yyvsp[(3) - (5)].list);
  2703  		iota = -100000;
  2704  		lastconst = nil;
  2705  	}
  2706      break;
  2707  
  2708    case 34:
  2709  
  2710  /* Line 1806 of yacc.c  */
  2711  #line 329 "go.y"
  2712      {
  2713  		(yyval.list) = concat((yyvsp[(3) - (7)].list), (yyvsp[(5) - (7)].list));
  2714  		iota = -100000;
  2715  		lastconst = nil;
  2716  	}
  2717      break;
  2718  
  2719    case 35:
  2720  
  2721  /* Line 1806 of yacc.c  */
  2722  #line 335 "go.y"
  2723      {
  2724  		(yyval.list) = nil;
  2725  		iota = -100000;
  2726  	}
  2727      break;
  2728  
  2729    case 36:
  2730  
  2731  /* Line 1806 of yacc.c  */
  2732  #line 340 "go.y"
  2733      {
  2734  		(yyval.list) = list1((yyvsp[(2) - (2)].node));
  2735  	}
  2736      break;
  2737  
  2738    case 37:
  2739  
  2740  /* Line 1806 of yacc.c  */
  2741  #line 344 "go.y"
  2742      {
  2743  		(yyval.list) = (yyvsp[(3) - (5)].list);
  2744  	}
  2745      break;
  2746  
  2747    case 38:
  2748  
  2749  /* Line 1806 of yacc.c  */
  2750  #line 348 "go.y"
  2751      {
  2752  		(yyval.list) = nil;
  2753  	}
  2754      break;
  2755  
  2756    case 39:
  2757  
  2758  /* Line 1806 of yacc.c  */
  2759  #line 354 "go.y"
  2760      {
  2761  		iota = 0;
  2762  	}
  2763      break;
  2764  
  2765    case 40:
  2766  
  2767  /* Line 1806 of yacc.c  */
  2768  #line 360 "go.y"
  2769      {
  2770  		(yyval.list) = variter((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node), nil);
  2771  	}
  2772      break;
  2773  
  2774    case 41:
  2775  
  2776  /* Line 1806 of yacc.c  */
  2777  #line 364 "go.y"
  2778      {
  2779  		(yyval.list) = variter((yyvsp[(1) - (4)].list), (yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].list));
  2780  	}
  2781      break;
  2782  
  2783    case 42:
  2784  
  2785  /* Line 1806 of yacc.c  */
  2786  #line 368 "go.y"
  2787      {
  2788  		(yyval.list) = variter((yyvsp[(1) - (3)].list), nil, (yyvsp[(3) - (3)].list));
  2789  	}
  2790      break;
  2791  
  2792    case 43:
  2793  
  2794  /* Line 1806 of yacc.c  */
  2795  #line 374 "go.y"
  2796      {
  2797  		(yyval.list) = constiter((yyvsp[(1) - (4)].list), (yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].list));
  2798  	}
  2799      break;
  2800  
  2801    case 44:
  2802  
  2803  /* Line 1806 of yacc.c  */
  2804  #line 378 "go.y"
  2805      {
  2806  		(yyval.list) = constiter((yyvsp[(1) - (3)].list), N, (yyvsp[(3) - (3)].list));
  2807  	}
  2808      break;
  2809  
  2810    case 46:
  2811  
  2812  /* Line 1806 of yacc.c  */
  2813  #line 385 "go.y"
  2814      {
  2815  		(yyval.list) = constiter((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node), nil);
  2816  	}
  2817      break;
  2818  
  2819    case 47:
  2820  
  2821  /* Line 1806 of yacc.c  */
  2822  #line 389 "go.y"
  2823      {
  2824  		(yyval.list) = constiter((yyvsp[(1) - (1)].list), N, nil);
  2825  	}
  2826      break;
  2827  
  2828    case 48:
  2829  
  2830  /* Line 1806 of yacc.c  */
  2831  #line 395 "go.y"
  2832      {
  2833  		// different from dclname because the name
  2834  		// becomes visible right here, not at the end
  2835  		// of the declaration.
  2836  		(yyval.node) = typedcl0((yyvsp[(1) - (1)].sym));
  2837  	}
  2838      break;
  2839  
  2840    case 49:
  2841  
  2842  /* Line 1806 of yacc.c  */
  2843  #line 404 "go.y"
  2844      {
  2845  		(yyval.node) = typedcl1((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node), 1);
  2846  	}
  2847      break;
  2848  
  2849    case 50:
  2850  
  2851  /* Line 1806 of yacc.c  */
  2852  #line 410 "go.y"
  2853      {
  2854  		(yyval.node) = (yyvsp[(1) - (1)].node);
  2855  
  2856  		// These nodes do not carry line numbers.
  2857  		// Since a bare name used as an expression is an error,
  2858  		// introduce a wrapper node to give the correct line.
  2859  		switch((yyval.node)->op) {
  2860  		case ONAME:
  2861  		case ONONAME:
  2862  		case OTYPE:
  2863  		case OPACK:
  2864  		case OLITERAL:
  2865  			(yyval.node) = nod(OPAREN, (yyval.node), N);
  2866  			(yyval.node)->implicit = 1;
  2867  			break;
  2868  		}
  2869  	}
  2870      break;
  2871  
  2872    case 51:
  2873  
  2874  /* Line 1806 of yacc.c  */
  2875  #line 428 "go.y"
  2876      {
  2877  		(yyval.node) = nod(OASOP, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  2878  		(yyval.node)->etype = (yyvsp[(2) - (3)].i);			// rathole to pass opcode
  2879  	}
  2880      break;
  2881  
  2882    case 52:
  2883  
  2884  /* Line 1806 of yacc.c  */
  2885  #line 433 "go.y"
  2886      {
  2887  		if((yyvsp[(1) - (3)].list)->next == nil && (yyvsp[(3) - (3)].list)->next == nil) {
  2888  			// simple
  2889  			(yyval.node) = nod(OAS, (yyvsp[(1) - (3)].list)->n, (yyvsp[(3) - (3)].list)->n);
  2890  			break;
  2891  		}
  2892  		// multiple
  2893  		(yyval.node) = nod(OAS2, N, N);
  2894  		(yyval.node)->list = (yyvsp[(1) - (3)].list);
  2895  		(yyval.node)->rlist = (yyvsp[(3) - (3)].list);
  2896  	}
  2897      break;
  2898  
  2899    case 53:
  2900  
  2901  /* Line 1806 of yacc.c  */
  2902  #line 445 "go.y"
  2903      {
  2904  		if((yyvsp[(3) - (3)].list)->n->op == OTYPESW) {
  2905  			(yyval.node) = nod(OTYPESW, N, (yyvsp[(3) - (3)].list)->n->right);
  2906  			if((yyvsp[(3) - (3)].list)->next != nil)
  2907  				yyerror("expr.(type) must be alone in list");
  2908  			if((yyvsp[(1) - (3)].list)->next != nil)
  2909  				yyerror("argument count mismatch: %d = %d", count((yyvsp[(1) - (3)].list)), 1);
  2910  			else if(((yyvsp[(1) - (3)].list)->n->op != ONAME && (yyvsp[(1) - (3)].list)->n->op != OTYPE && (yyvsp[(1) - (3)].list)->n->op != ONONAME) || isblank((yyvsp[(1) - (3)].list)->n))
  2911  				yyerror("invalid variable name %N in type switch", (yyvsp[(1) - (3)].list)->n);
  2912  			else
  2913  				(yyval.node)->left = dclname((yyvsp[(1) - (3)].list)->n->sym);  // it's a colas, so must not re-use an oldname.
  2914  			break;
  2915  		}
  2916  		(yyval.node) = colas((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list), (yyvsp[(2) - (3)].i));
  2917  	}
  2918      break;
  2919  
  2920    case 54:
  2921  
  2922  /* Line 1806 of yacc.c  */
  2923  #line 461 "go.y"
  2924      {
  2925  		(yyval.node) = nod(OASOP, (yyvsp[(1) - (2)].node), nodintconst(1));
  2926  		(yyval.node)->etype = OADD;
  2927  	}
  2928      break;
  2929  
  2930    case 55:
  2931  
  2932  /* Line 1806 of yacc.c  */
  2933  #line 466 "go.y"
  2934      {
  2935  		(yyval.node) = nod(OASOP, (yyvsp[(1) - (2)].node), nodintconst(1));
  2936  		(yyval.node)->etype = OSUB;
  2937  	}
  2938      break;
  2939  
  2940    case 56:
  2941  
  2942  /* Line 1806 of yacc.c  */
  2943  #line 473 "go.y"
  2944      {
  2945  		Node *n, *nn;
  2946  
  2947  		// will be converted to OCASE
  2948  		// right will point to next case
  2949  		// done in casebody()
  2950  		markdcl();
  2951  		(yyval.node) = nod(OXCASE, N, N);
  2952  		(yyval.node)->list = (yyvsp[(2) - (3)].list);
  2953  		if(typesw != N && typesw->right != N && (n=typesw->right->left) != N) {
  2954  			// type switch - declare variable
  2955  			nn = newname(n->sym);
  2956  			declare(nn, dclcontext);
  2957  			(yyval.node)->nname = nn;
  2958  
  2959  			// keep track of the instances for reporting unused
  2960  			nn->defn = typesw->right;
  2961  		}
  2962  	}
  2963      break;
  2964  
  2965    case 57:
  2966  
  2967  /* Line 1806 of yacc.c  */
  2968  #line 493 "go.y"
  2969      {
  2970  		Node *n;
  2971  
  2972  		// will be converted to OCASE
  2973  		// right will point to next case
  2974  		// done in casebody()
  2975  		markdcl();
  2976  		(yyval.node) = nod(OXCASE, N, N);
  2977  		if((yyvsp[(2) - (5)].list)->next == nil)
  2978  			n = nod(OAS, (yyvsp[(2) - (5)].list)->n, (yyvsp[(4) - (5)].node));
  2979  		else {
  2980  			n = nod(OAS2, N, N);
  2981  			n->list = (yyvsp[(2) - (5)].list);
  2982  			n->rlist = list1((yyvsp[(4) - (5)].node));
  2983  		}
  2984  		(yyval.node)->list = list1(n);
  2985  	}
  2986      break;
  2987  
  2988    case 58:
  2989  
  2990  /* Line 1806 of yacc.c  */
  2991  #line 511 "go.y"
  2992      {
  2993  		// will be converted to OCASE
  2994  		// right will point to next case
  2995  		// done in casebody()
  2996  		markdcl();
  2997  		(yyval.node) = nod(OXCASE, N, N);
  2998  		(yyval.node)->list = list1(colas((yyvsp[(2) - (5)].list), list1((yyvsp[(4) - (5)].node)), (yyvsp[(3) - (5)].i)));
  2999  	}
  3000      break;
  3001  
  3002    case 59:
  3003  
  3004  /* Line 1806 of yacc.c  */
  3005  #line 520 "go.y"
  3006      {
  3007  		Node *n, *nn;
  3008  
  3009  		markdcl();
  3010  		(yyval.node) = nod(OXCASE, N, N);
  3011  		if(typesw != N && typesw->right != N && (n=typesw->right->left) != N) {
  3012  			// type switch - declare variable
  3013  			nn = newname(n->sym);
  3014  			declare(nn, dclcontext);
  3015  			(yyval.node)->nname = nn;
  3016  
  3017  			// keep track of the instances for reporting unused
  3018  			nn->defn = typesw->right;
  3019  		}
  3020  	}
  3021      break;
  3022  
  3023    case 60:
  3024  
  3025  /* Line 1806 of yacc.c  */
  3026  #line 538 "go.y"
  3027      {
  3028  		markdcl();
  3029  	}
  3030      break;
  3031  
  3032    case 61:
  3033  
  3034  /* Line 1806 of yacc.c  */
  3035  #line 542 "go.y"
  3036      {
  3037  		if((yyvsp[(3) - (4)].list) == nil)
  3038  			(yyval.node) = nod(OEMPTY, N, N);
  3039  		else
  3040  			(yyval.node) = liststmt((yyvsp[(3) - (4)].list));
  3041  		popdcl();
  3042  	}
  3043      break;
  3044  
  3045    case 62:
  3046  
  3047  /* Line 1806 of yacc.c  */
  3048  #line 552 "go.y"
  3049      {
  3050  		// If the last token read by the lexer was consumed
  3051  		// as part of the case, clear it (parser has cleared yychar).
  3052  		// If the last token read by the lexer was the lookahead
  3053  		// leave it alone (parser has it cached in yychar).
  3054  		// This is so that the stmt_list action doesn't look at
  3055  		// the case tokens if the stmt_list is empty.
  3056  		yylast = yychar;
  3057  	}
  3058      break;
  3059  
  3060    case 63:
  3061  
  3062  /* Line 1806 of yacc.c  */
  3063  #line 562 "go.y"
  3064      {
  3065  		int last;
  3066  
  3067  		// This is the only place in the language where a statement
  3068  		// list is not allowed to drop the final semicolon, because
  3069  		// it's the only place where a statement list is not followed 
  3070  		// by a closing brace.  Handle the error for pedantry.
  3071  
  3072  		// Find the final token of the statement list.
  3073  		// yylast is lookahead; yyprev is last of stmt_list
  3074  		last = yyprev;
  3075  
  3076  		if(last > 0 && last != ';' && yychar != '}')
  3077  			yyerror("missing statement after label");
  3078  		(yyval.node) = (yyvsp[(1) - (3)].node);
  3079  		(yyval.node)->nbody = (yyvsp[(3) - (3)].list);
  3080  		popdcl();
  3081  	}
  3082      break;
  3083  
  3084    case 64:
  3085  
  3086  /* Line 1806 of yacc.c  */
  3087  #line 582 "go.y"
  3088      {
  3089  		(yyval.list) = nil;
  3090  	}
  3091      break;
  3092  
  3093    case 65:
  3094  
  3095  /* Line 1806 of yacc.c  */
  3096  #line 586 "go.y"
  3097      {
  3098  		(yyval.list) = list((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node));
  3099  	}
  3100      break;
  3101  
  3102    case 66:
  3103  
  3104  /* Line 1806 of yacc.c  */
  3105  #line 592 "go.y"
  3106      {
  3107  		markdcl();
  3108  	}
  3109      break;
  3110  
  3111    case 67:
  3112  
  3113  /* Line 1806 of yacc.c  */
  3114  #line 596 "go.y"
  3115      {
  3116  		(yyval.list) = (yyvsp[(3) - (4)].list);
  3117  		popdcl();
  3118  	}
  3119      break;
  3120  
  3121    case 68:
  3122  
  3123  /* Line 1806 of yacc.c  */
  3124  #line 603 "go.y"
  3125      {
  3126  		(yyval.node) = nod(ORANGE, N, (yyvsp[(4) - (4)].node));
  3127  		(yyval.node)->list = (yyvsp[(1) - (4)].list);
  3128  		(yyval.node)->etype = 0;	// := flag
  3129  	}
  3130      break;
  3131  
  3132    case 69:
  3133  
  3134  /* Line 1806 of yacc.c  */
  3135  #line 609 "go.y"
  3136      {
  3137  		(yyval.node) = nod(ORANGE, N, (yyvsp[(4) - (4)].node));
  3138  		(yyval.node)->list = (yyvsp[(1) - (4)].list);
  3139  		(yyval.node)->colas = 1;
  3140  		colasdefn((yyvsp[(1) - (4)].list), (yyval.node));
  3141  	}
  3142      break;
  3143  
  3144    case 70:
  3145  
  3146  /* Line 1806 of yacc.c  */
  3147  #line 618 "go.y"
  3148      {
  3149  		// init ; test ; incr
  3150  		if((yyvsp[(5) - (5)].node) != N && (yyvsp[(5) - (5)].node)->colas != 0)
  3151  			yyerror("cannot declare in the for-increment");
  3152  		(yyval.node) = nod(OFOR, N, N);
  3153  		if((yyvsp[(1) - (5)].node) != N)
  3154  			(yyval.node)->ninit = list1((yyvsp[(1) - (5)].node));
  3155  		(yyval.node)->ntest = (yyvsp[(3) - (5)].node);
  3156  		(yyval.node)->nincr = (yyvsp[(5) - (5)].node);
  3157  	}
  3158      break;
  3159  
  3160    case 71:
  3161  
  3162  /* Line 1806 of yacc.c  */
  3163  #line 629 "go.y"
  3164      {
  3165  		// normal test
  3166  		(yyval.node) = nod(OFOR, N, N);
  3167  		(yyval.node)->ntest = (yyvsp[(1) - (1)].node);
  3168  	}
  3169      break;
  3170  
  3171    case 73:
  3172  
  3173  /* Line 1806 of yacc.c  */
  3174  #line 638 "go.y"
  3175      {
  3176  		(yyval.node) = (yyvsp[(1) - (2)].node);
  3177  		(yyval.node)->nbody = concat((yyval.node)->nbody, (yyvsp[(2) - (2)].list));
  3178  	}
  3179      break;
  3180  
  3181    case 74:
  3182  
  3183  /* Line 1806 of yacc.c  */
  3184  #line 645 "go.y"
  3185      {
  3186  		markdcl();
  3187  	}
  3188      break;
  3189  
  3190    case 75:
  3191  
  3192  /* Line 1806 of yacc.c  */
  3193  #line 649 "go.y"
  3194      {
  3195  		(yyval.node) = (yyvsp[(3) - (3)].node);
  3196  		popdcl();
  3197  	}
  3198      break;
  3199  
  3200    case 76:
  3201  
  3202  /* Line 1806 of yacc.c  */
  3203  #line 656 "go.y"
  3204      {
  3205  		// test
  3206  		(yyval.node) = nod(OIF, N, N);
  3207  		(yyval.node)->ntest = (yyvsp[(1) - (1)].node);
  3208  	}
  3209      break;
  3210  
  3211    case 77:
  3212  
  3213  /* Line 1806 of yacc.c  */
  3214  #line 662 "go.y"
  3215      {
  3216  		// init ; test
  3217  		(yyval.node) = nod(OIF, N, N);
  3218  		if((yyvsp[(1) - (3)].node) != N)
  3219  			(yyval.node)->ninit = list1((yyvsp[(1) - (3)].node));
  3220  		(yyval.node)->ntest = (yyvsp[(3) - (3)].node);
  3221  	}
  3222      break;
  3223  
  3224    case 78:
  3225  
  3226  /* Line 1806 of yacc.c  */
  3227  #line 673 "go.y"
  3228      {
  3229  		markdcl();
  3230  	}
  3231      break;
  3232  
  3233    case 79:
  3234  
  3235  /* Line 1806 of yacc.c  */
  3236  #line 677 "go.y"
  3237      {
  3238  		if((yyvsp[(3) - (3)].node)->ntest == N)
  3239  			yyerror("missing condition in if statement");
  3240  	}
  3241      break;
  3242  
  3243    case 80:
  3244  
  3245  /* Line 1806 of yacc.c  */
  3246  #line 682 "go.y"
  3247      {
  3248  		(yyvsp[(3) - (5)].node)->nbody = (yyvsp[(5) - (5)].list);
  3249  	}
  3250      break;
  3251  
  3252    case 81:
  3253  
  3254  /* Line 1806 of yacc.c  */
  3255  #line 686 "go.y"
  3256      {
  3257  		Node *n;
  3258  		NodeList *nn;
  3259  
  3260  		(yyval.node) = (yyvsp[(3) - (8)].node);
  3261  		n = (yyvsp[(3) - (8)].node);
  3262  		popdcl();
  3263  		for(nn = concat((yyvsp[(7) - (8)].list), (yyvsp[(8) - (8)].list)); nn; nn = nn->next) {
  3264  			if(nn->n->op == OIF)
  3265  				popdcl();
  3266  			n->nelse = list1(nn->n);
  3267  			n = nn->n;
  3268  		}
  3269  	}
  3270      break;
  3271  
  3272    case 82:
  3273  
  3274  /* Line 1806 of yacc.c  */
  3275  #line 703 "go.y"
  3276      {
  3277  		markdcl();
  3278  	}
  3279      break;
  3280  
  3281    case 83:
  3282  
  3283  /* Line 1806 of yacc.c  */
  3284  #line 707 "go.y"
  3285      {
  3286  		if((yyvsp[(4) - (5)].node)->ntest == N)
  3287  			yyerror("missing condition in if statement");
  3288  		(yyvsp[(4) - (5)].node)->nbody = (yyvsp[(5) - (5)].list);
  3289  		(yyval.list) = list1((yyvsp[(4) - (5)].node));
  3290  	}
  3291      break;
  3292  
  3293    case 84:
  3294  
  3295  /* Line 1806 of yacc.c  */
  3296  #line 715 "go.y"
  3297      {
  3298  		(yyval.list) = nil;
  3299  	}
  3300      break;
  3301  
  3302    case 85:
  3303  
  3304  /* Line 1806 of yacc.c  */
  3305  #line 719 "go.y"
  3306      {
  3307  		(yyval.list) = concat((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].list));
  3308  	}
  3309      break;
  3310  
  3311    case 86:
  3312  
  3313  /* Line 1806 of yacc.c  */
  3314  #line 724 "go.y"
  3315      {
  3316  		(yyval.list) = nil;
  3317  	}
  3318      break;
  3319  
  3320    case 87:
  3321  
  3322  /* Line 1806 of yacc.c  */
  3323  #line 728 "go.y"
  3324      {
  3325  		NodeList *node;
  3326  		
  3327  		node = mal(sizeof *node);
  3328  		node->n = (yyvsp[(2) - (2)].node);
  3329  		node->end = node;
  3330  		(yyval.list) = node;
  3331  	}
  3332      break;
  3333  
  3334    case 88:
  3335  
  3336  /* Line 1806 of yacc.c  */
  3337  #line 739 "go.y"
  3338      {
  3339  		markdcl();
  3340  	}
  3341      break;
  3342  
  3343    case 89:
  3344  
  3345  /* Line 1806 of yacc.c  */
  3346  #line 743 "go.y"
  3347      {
  3348  		Node *n;
  3349  		n = (yyvsp[(3) - (3)].node)->ntest;
  3350  		if(n != N && n->op != OTYPESW)
  3351  			n = N;
  3352  		typesw = nod(OXXX, typesw, n);
  3353  	}
  3354      break;
  3355  
  3356    case 90:
  3357  
  3358  /* Line 1806 of yacc.c  */
  3359  #line 751 "go.y"
  3360      {
  3361  		(yyval.node) = (yyvsp[(3) - (7)].node);
  3362  		(yyval.node)->op = OSWITCH;
  3363  		(yyval.node)->list = (yyvsp[(6) - (7)].list);
  3364  		typesw = typesw->left;
  3365  		popdcl();
  3366  	}
  3367      break;
  3368  
  3369    case 91:
  3370  
  3371  /* Line 1806 of yacc.c  */
  3372  #line 761 "go.y"
  3373      {
  3374  		typesw = nod(OXXX, typesw, N);
  3375  	}
  3376      break;
  3377  
  3378    case 92:
  3379  
  3380  /* Line 1806 of yacc.c  */
  3381  #line 765 "go.y"
  3382      {
  3383  		(yyval.node) = nod(OSELECT, N, N);
  3384  		(yyval.node)->lineno = typesw->lineno;
  3385  		(yyval.node)->list = (yyvsp[(4) - (5)].list);
  3386  		typesw = typesw->left;
  3387  	}
  3388      break;
  3389  
  3390    case 94:
  3391  
  3392  /* Line 1806 of yacc.c  */
  3393  #line 778 "go.y"
  3394      {
  3395  		(yyval.node) = nod(OOROR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3396  	}
  3397      break;
  3398  
  3399    case 95:
  3400  
  3401  /* Line 1806 of yacc.c  */
  3402  #line 782 "go.y"
  3403      {
  3404  		(yyval.node) = nod(OANDAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3405  	}
  3406      break;
  3407  
  3408    case 96:
  3409  
  3410  /* Line 1806 of yacc.c  */
  3411  #line 786 "go.y"
  3412      {
  3413  		(yyval.node) = nod(OEQ, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3414  	}
  3415      break;
  3416  
  3417    case 97:
  3418  
  3419  /* Line 1806 of yacc.c  */
  3420  #line 790 "go.y"
  3421      {
  3422  		(yyval.node) = nod(ONE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3423  	}
  3424      break;
  3425  
  3426    case 98:
  3427  
  3428  /* Line 1806 of yacc.c  */
  3429  #line 794 "go.y"
  3430      {
  3431  		(yyval.node) = nod(OLT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3432  	}
  3433      break;
  3434  
  3435    case 99:
  3436  
  3437  /* Line 1806 of yacc.c  */
  3438  #line 798 "go.y"
  3439      {
  3440  		(yyval.node) = nod(OLE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3441  	}
  3442      break;
  3443  
  3444    case 100:
  3445  
  3446  /* Line 1806 of yacc.c  */
  3447  #line 802 "go.y"
  3448      {
  3449  		(yyval.node) = nod(OGE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3450  	}
  3451      break;
  3452  
  3453    case 101:
  3454  
  3455  /* Line 1806 of yacc.c  */
  3456  #line 806 "go.y"
  3457      {
  3458  		(yyval.node) = nod(OGT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3459  	}
  3460      break;
  3461  
  3462    case 102:
  3463  
  3464  /* Line 1806 of yacc.c  */
  3465  #line 810 "go.y"
  3466      {
  3467  		(yyval.node) = nod(OADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3468  	}
  3469      break;
  3470  
  3471    case 103:
  3472  
  3473  /* Line 1806 of yacc.c  */
  3474  #line 814 "go.y"
  3475      {
  3476  		(yyval.node) = nod(OSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3477  	}
  3478      break;
  3479  
  3480    case 104:
  3481  
  3482  /* Line 1806 of yacc.c  */
  3483  #line 818 "go.y"
  3484      {
  3485  		(yyval.node) = nod(OOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3486  	}
  3487      break;
  3488  
  3489    case 105:
  3490  
  3491  /* Line 1806 of yacc.c  */
  3492  #line 822 "go.y"
  3493      {
  3494  		(yyval.node) = nod(OXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3495  	}
  3496      break;
  3497  
  3498    case 106:
  3499  
  3500  /* Line 1806 of yacc.c  */
  3501  #line 826 "go.y"
  3502      {
  3503  		(yyval.node) = nod(OMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3504  	}
  3505      break;
  3506  
  3507    case 107:
  3508  
  3509  /* Line 1806 of yacc.c  */
  3510  #line 830 "go.y"
  3511      {
  3512  		(yyval.node) = nod(ODIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3513  	}
  3514      break;
  3515  
  3516    case 108:
  3517  
  3518  /* Line 1806 of yacc.c  */
  3519  #line 834 "go.y"
  3520      {
  3521  		(yyval.node) = nod(OMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3522  	}
  3523      break;
  3524  
  3525    case 109:
  3526  
  3527  /* Line 1806 of yacc.c  */
  3528  #line 838 "go.y"
  3529      {
  3530  		(yyval.node) = nod(OAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3531  	}
  3532      break;
  3533  
  3534    case 110:
  3535  
  3536  /* Line 1806 of yacc.c  */
  3537  #line 842 "go.y"
  3538      {
  3539  		(yyval.node) = nod(OANDNOT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3540  	}
  3541      break;
  3542  
  3543    case 111:
  3544  
  3545  /* Line 1806 of yacc.c  */
  3546  #line 846 "go.y"
  3547      {
  3548  		(yyval.node) = nod(OLSH, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3549  	}
  3550      break;
  3551  
  3552    case 112:
  3553  
  3554  /* Line 1806 of yacc.c  */
  3555  #line 850 "go.y"
  3556      {
  3557  		(yyval.node) = nod(ORSH, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3558  	}
  3559      break;
  3560  
  3561    case 113:
  3562  
  3563  /* Line 1806 of yacc.c  */
  3564  #line 855 "go.y"
  3565      {
  3566  		(yyval.node) = nod(OSEND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3567  	}
  3568      break;
  3569  
  3570    case 115:
  3571  
  3572  /* Line 1806 of yacc.c  */
  3573  #line 862 "go.y"
  3574      {
  3575  		(yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N);
  3576  	}
  3577      break;
  3578  
  3579    case 116:
  3580  
  3581  /* Line 1806 of yacc.c  */
  3582  #line 866 "go.y"
  3583      {
  3584  		if((yyvsp[(2) - (2)].node)->op == OCOMPLIT) {
  3585  			// Special case for &T{...}: turn into (*T){...}.
  3586  			(yyval.node) = (yyvsp[(2) - (2)].node);
  3587  			(yyval.node)->right = nod(OIND, (yyval.node)->right, N);
  3588  			(yyval.node)->right->implicit = 1;
  3589  		} else {
  3590  			(yyval.node) = nod(OADDR, (yyvsp[(2) - (2)].node), N);
  3591  		}
  3592  	}
  3593      break;
  3594  
  3595    case 117:
  3596  
  3597  /* Line 1806 of yacc.c  */
  3598  #line 877 "go.y"
  3599      {
  3600  		(yyval.node) = nod(OPLUS, (yyvsp[(2) - (2)].node), N);
  3601  	}
  3602      break;
  3603  
  3604    case 118:
  3605  
  3606  /* Line 1806 of yacc.c  */
  3607  #line 881 "go.y"
  3608      {
  3609  		(yyval.node) = nod(OMINUS, (yyvsp[(2) - (2)].node), N);
  3610  	}
  3611      break;
  3612  
  3613    case 119:
  3614  
  3615  /* Line 1806 of yacc.c  */
  3616  #line 885 "go.y"
  3617      {
  3618  		(yyval.node) = nod(ONOT, (yyvsp[(2) - (2)].node), N);
  3619  	}
  3620      break;
  3621  
  3622    case 120:
  3623  
  3624  /* Line 1806 of yacc.c  */
  3625  #line 889 "go.y"
  3626      {
  3627  		yyerror("the bitwise complement operator is ^");
  3628  		(yyval.node) = nod(OCOM, (yyvsp[(2) - (2)].node), N);
  3629  	}
  3630      break;
  3631  
  3632    case 121:
  3633  
  3634  /* Line 1806 of yacc.c  */
  3635  #line 894 "go.y"
  3636      {
  3637  		(yyval.node) = nod(OCOM, (yyvsp[(2) - (2)].node), N);
  3638  	}
  3639      break;
  3640  
  3641    case 122:
  3642  
  3643  /* Line 1806 of yacc.c  */
  3644  #line 898 "go.y"
  3645      {
  3646  		(yyval.node) = nod(ORECV, (yyvsp[(2) - (2)].node), N);
  3647  	}
  3648      break;
  3649  
  3650    case 123:
  3651  
  3652  /* Line 1806 of yacc.c  */
  3653  #line 908 "go.y"
  3654      {
  3655  		(yyval.node) = nod(OCALL, (yyvsp[(1) - (3)].node), N);
  3656  	}
  3657      break;
  3658  
  3659    case 124:
  3660  
  3661  /* Line 1806 of yacc.c  */
  3662  #line 912 "go.y"
  3663      {
  3664  		(yyval.node) = nod(OCALL, (yyvsp[(1) - (5)].node), N);
  3665  		(yyval.node)->list = (yyvsp[(3) - (5)].list);
  3666  	}
  3667      break;
  3668  
  3669    case 125:
  3670  
  3671  /* Line 1806 of yacc.c  */
  3672  #line 917 "go.y"
  3673      {
  3674  		(yyval.node) = nod(OCALL, (yyvsp[(1) - (6)].node), N);
  3675  		(yyval.node)->list = (yyvsp[(3) - (6)].list);
  3676  		(yyval.node)->isddd = 1;
  3677  	}
  3678      break;
  3679  
  3680    case 126:
  3681  
  3682  /* Line 1806 of yacc.c  */
  3683  #line 925 "go.y"
  3684      {
  3685  		(yyval.node) = nodlit((yyvsp[(1) - (1)].val));
  3686  	}
  3687      break;
  3688  
  3689    case 128:
  3690  
  3691  /* Line 1806 of yacc.c  */
  3692  #line 930 "go.y"
  3693      {
  3694  		if((yyvsp[(1) - (3)].node)->op == OPACK) {
  3695  			Sym *s;
  3696  			s = restrictlookup((yyvsp[(3) - (3)].sym)->name, (yyvsp[(1) - (3)].node)->pkg);
  3697  			(yyvsp[(1) - (3)].node)->used = 1;
  3698  			(yyval.node) = oldname(s);
  3699  			break;
  3700  		}
  3701  		(yyval.node) = nod(OXDOT, (yyvsp[(1) - (3)].node), newname((yyvsp[(3) - (3)].sym)));
  3702  	}
  3703      break;
  3704  
  3705    case 129:
  3706  
  3707  /* Line 1806 of yacc.c  */
  3708  #line 941 "go.y"
  3709      {
  3710  		(yyval.node) = nod(ODOTTYPE, (yyvsp[(1) - (5)].node), (yyvsp[(4) - (5)].node));
  3711  	}
  3712      break;
  3713  
  3714    case 130:
  3715  
  3716  /* Line 1806 of yacc.c  */
  3717  #line 945 "go.y"
  3718      {
  3719  		(yyval.node) = nod(OTYPESW, N, (yyvsp[(1) - (5)].node));
  3720  	}
  3721      break;
  3722  
  3723    case 131:
  3724  
  3725  /* Line 1806 of yacc.c  */
  3726  #line 949 "go.y"
  3727      {
  3728  		(yyval.node) = nod(OINDEX, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
  3729  	}
  3730      break;
  3731  
  3732    case 132:
  3733  
  3734  /* Line 1806 of yacc.c  */
  3735  #line 953 "go.y"
  3736      {
  3737  		(yyval.node) = nod(OSLICE, (yyvsp[(1) - (6)].node), nod(OKEY, (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node)));
  3738  	}
  3739      break;
  3740  
  3741    case 133:
  3742  
  3743  /* Line 1806 of yacc.c  */
  3744  #line 957 "go.y"
  3745      {
  3746  		if((yyvsp[(5) - (8)].node) == N)
  3747  			yyerror("middle index required in 3-index slice");
  3748  		if((yyvsp[(7) - (8)].node) == N)
  3749  			yyerror("final index required in 3-index slice");
  3750  		(yyval.node) = nod(OSLICE3, (yyvsp[(1) - (8)].node), nod(OKEY, (yyvsp[(3) - (8)].node), nod(OKEY, (yyvsp[(5) - (8)].node), (yyvsp[(7) - (8)].node))));
  3751  	}
  3752      break;
  3753  
  3754    case 135:
  3755  
  3756  /* Line 1806 of yacc.c  */
  3757  #line 966 "go.y"
  3758      {
  3759  		// conversion
  3760  		(yyval.node) = nod(OCALL, (yyvsp[(1) - (5)].node), N);
  3761  		(yyval.node)->list = list1((yyvsp[(3) - (5)].node));
  3762  	}
  3763      break;
  3764  
  3765    case 136:
  3766  
  3767  /* Line 1806 of yacc.c  */
  3768  #line 972 "go.y"
  3769      {
  3770  		(yyval.node) = (yyvsp[(3) - (5)].node);
  3771  		(yyval.node)->right = (yyvsp[(1) - (5)].node);
  3772  		(yyval.node)->list = (yyvsp[(4) - (5)].list);
  3773  		fixlbrace((yyvsp[(2) - (5)].i));
  3774  	}
  3775      break;
  3776  
  3777    case 137:
  3778  
  3779  /* Line 1806 of yacc.c  */
  3780  #line 979 "go.y"
  3781      {
  3782  		(yyval.node) = (yyvsp[(3) - (5)].node);
  3783  		(yyval.node)->right = (yyvsp[(1) - (5)].node);
  3784  		(yyval.node)->list = (yyvsp[(4) - (5)].list);
  3785  	}
  3786      break;
  3787  
  3788    case 138:
  3789  
  3790  /* Line 1806 of yacc.c  */
  3791  #line 985 "go.y"
  3792      {
  3793  		yyerror("cannot parenthesize type in composite literal");
  3794  		(yyval.node) = (yyvsp[(5) - (7)].node);
  3795  		(yyval.node)->right = (yyvsp[(2) - (7)].node);
  3796  		(yyval.node)->list = (yyvsp[(6) - (7)].list);
  3797  	}
  3798      break;
  3799  
  3800    case 140:
  3801  
  3802  /* Line 1806 of yacc.c  */
  3803  #line 994 "go.y"
  3804      {
  3805  		// composite expression.
  3806  		// make node early so we get the right line number.
  3807  		(yyval.node) = nod(OCOMPLIT, N, N);
  3808  	}
  3809      break;
  3810  
  3811    case 141:
  3812  
  3813  /* Line 1806 of yacc.c  */
  3814  #line 1002 "go.y"
  3815      {
  3816  		(yyval.node) = nod(OKEY, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
  3817  	}
  3818      break;
  3819  
  3820    case 142:
  3821  
  3822  /* Line 1806 of yacc.c  */
  3823  #line 1008 "go.y"
  3824      {
  3825  		// These nodes do not carry line numbers.
  3826  		// Since a composite literal commonly spans several lines,
  3827  		// the line number on errors may be misleading.
  3828  		// Introduce a wrapper node to give the correct line.
  3829  		(yyval.node) = (yyvsp[(1) - (1)].node);
  3830  		switch((yyval.node)->op) {
  3831  		case ONAME:
  3832  		case ONONAME:
  3833  		case OTYPE:
  3834  		case OPACK:
  3835  		case OLITERAL:
  3836  			(yyval.node) = nod(OPAREN, (yyval.node), N);
  3837  			(yyval.node)->implicit = 1;
  3838  		}
  3839  	}
  3840      break;
  3841  
  3842    case 143:
  3843  
  3844  /* Line 1806 of yacc.c  */
  3845  #line 1025 "go.y"
  3846      {
  3847  		(yyval.node) = (yyvsp[(2) - (4)].node);
  3848  		(yyval.node)->list = (yyvsp[(3) - (4)].list);
  3849  	}
  3850      break;
  3851  
  3852    case 145:
  3853  
  3854  /* Line 1806 of yacc.c  */
  3855  #line 1033 "go.y"
  3856      {
  3857  		(yyval.node) = (yyvsp[(2) - (4)].node);
  3858  		(yyval.node)->list = (yyvsp[(3) - (4)].list);
  3859  	}
  3860      break;
  3861  
  3862    case 147:
  3863  
  3864  /* Line 1806 of yacc.c  */
  3865  #line 1041 "go.y"
  3866      {
  3867  		(yyval.node) = (yyvsp[(2) - (3)].node);
  3868  		
  3869  		// Need to know on lhs of := whether there are ( ).
  3870  		// Don't bother with the OPAREN in other cases:
  3871  		// it's just a waste of memory and time.
  3872  		switch((yyval.node)->op) {
  3873  		case ONAME:
  3874  		case ONONAME:
  3875  		case OPACK:
  3876  		case OTYPE:
  3877  		case OLITERAL:
  3878  		case OTYPESW:
  3879  			(yyval.node) = nod(OPAREN, (yyval.node), N);
  3880  		}
  3881  	}
  3882      break;
  3883  
  3884    case 151:
  3885  
  3886  /* Line 1806 of yacc.c  */
  3887  #line 1067 "go.y"
  3888      {
  3889  		(yyval.i) = LBODY;
  3890  	}
  3891      break;
  3892  
  3893    case 152:
  3894  
  3895  /* Line 1806 of yacc.c  */
  3896  #line 1071 "go.y"
  3897      {
  3898  		(yyval.i) = '{';
  3899  	}
  3900      break;
  3901  
  3902    case 153:
  3903  
  3904  /* Line 1806 of yacc.c  */
  3905  #line 1082 "go.y"
  3906      {
  3907  		if((yyvsp[(1) - (1)].sym) == S)
  3908  			(yyval.node) = N;
  3909  		else
  3910  			(yyval.node) = newname((yyvsp[(1) - (1)].sym));
  3911  	}
  3912      break;
  3913  
  3914    case 154:
  3915  
  3916  /* Line 1806 of yacc.c  */
  3917  #line 1091 "go.y"
  3918      {
  3919  		(yyval.node) = dclname((yyvsp[(1) - (1)].sym));
  3920  	}
  3921      break;
  3922  
  3923    case 155:
  3924  
  3925  /* Line 1806 of yacc.c  */
  3926  #line 1096 "go.y"
  3927      {
  3928  		(yyval.node) = N;
  3929  	}
  3930      break;
  3931  
  3932    case 157:
  3933  
  3934  /* Line 1806 of yacc.c  */
  3935  #line 1103 "go.y"
  3936      {
  3937  		(yyval.sym) = (yyvsp[(1) - (1)].sym);
  3938  		// during imports, unqualified non-exported identifiers are from builtinpkg
  3939  		if(importpkg != nil && !exportname((yyvsp[(1) - (1)].sym)->name))
  3940  			(yyval.sym) = pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg);
  3941  	}
  3942      break;
  3943  
  3944    case 159:
  3945  
  3946  /* Line 1806 of yacc.c  */
  3947  #line 1111 "go.y"
  3948      {
  3949  		(yyval.sym) = S;
  3950  	}
  3951      break;
  3952  
  3953    case 160:
  3954  
  3955  /* Line 1806 of yacc.c  */
  3956  #line 1117 "go.y"
  3957      {
  3958  		Pkg *p;
  3959  
  3960  		if((yyvsp[(2) - (4)].val).u.sval->len == 0)
  3961  			p = importpkg;
  3962  		else {
  3963  			if(isbadimport((yyvsp[(2) - (4)].val).u.sval))
  3964  				errorexit();
  3965  			p = mkpkg((yyvsp[(2) - (4)].val).u.sval);
  3966  		}
  3967  		(yyval.sym) = pkglookup((yyvsp[(4) - (4)].sym)->name, p);
  3968  	}
  3969      break;
  3970  
  3971    case 161:
  3972  
  3973  /* Line 1806 of yacc.c  */
  3974  #line 1130 "go.y"
  3975      {
  3976  		Pkg *p;
  3977  
  3978  		if((yyvsp[(2) - (4)].val).u.sval->len == 0)
  3979  			p = importpkg;
  3980  		else {
  3981  			if(isbadimport((yyvsp[(2) - (4)].val).u.sval))
  3982  				errorexit();
  3983  			p = mkpkg((yyvsp[(2) - (4)].val).u.sval);
  3984  		}
  3985  		(yyval.sym) = pkglookup("?", p);
  3986  	}
  3987      break;
  3988  
  3989    case 162:
  3990  
  3991  /* Line 1806 of yacc.c  */
  3992  #line 1145 "go.y"
  3993      {
  3994  		(yyval.node) = oldname((yyvsp[(1) - (1)].sym));
  3995  		if((yyval.node)->pack != N)
  3996  			(yyval.node)->pack->used = 1;
  3997  	}
  3998      break;
  3999  
  4000    case 164:
  4001  
  4002  /* Line 1806 of yacc.c  */
  4003  #line 1165 "go.y"
  4004      {
  4005  		yyerror("final argument in variadic function missing type");
  4006  		(yyval.node) = nod(ODDD, typenod(typ(TINTER)), N);
  4007  	}
  4008      break;
  4009  
  4010    case 165:
  4011  
  4012  /* Line 1806 of yacc.c  */
  4013  #line 1170 "go.y"
  4014      {
  4015  		(yyval.node) = nod(ODDD, (yyvsp[(2) - (2)].node), N);
  4016  	}
  4017      break;
  4018  
  4019    case 171:
  4020  
  4021  /* Line 1806 of yacc.c  */
  4022  #line 1181 "go.y"
  4023      {
  4024  		(yyval.node) = nod(OTPAREN, (yyvsp[(2) - (3)].node), N);
  4025  	}
  4026      break;
  4027  
  4028    case 175:
  4029  
  4030  /* Line 1806 of yacc.c  */
  4031  #line 1190 "go.y"
  4032      {
  4033  		(yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N);
  4034  	}
  4035      break;
  4036  
  4037    case 180:
  4038  
  4039  /* Line 1806 of yacc.c  */
  4040  #line 1200 "go.y"
  4041      {
  4042  		(yyval.node) = nod(OTPAREN, (yyvsp[(2) - (3)].node), N);
  4043  	}
  4044      break;
  4045  
  4046    case 190:
  4047  
  4048  /* Line 1806 of yacc.c  */
  4049  #line 1221 "go.y"
  4050      {
  4051  		if((yyvsp[(1) - (3)].node)->op == OPACK) {
  4052  			Sym *s;
  4053  			s = restrictlookup((yyvsp[(3) - (3)].sym)->name, (yyvsp[(1) - (3)].node)->pkg);
  4054  			(yyvsp[(1) - (3)].node)->used = 1;
  4055  			(yyval.node) = oldname(s);
  4056  			break;
  4057  		}
  4058  		(yyval.node) = nod(OXDOT, (yyvsp[(1) - (3)].node), newname((yyvsp[(3) - (3)].sym)));
  4059  	}
  4060      break;
  4061  
  4062    case 191:
  4063  
  4064  /* Line 1806 of yacc.c  */
  4065  #line 1234 "go.y"
  4066      {
  4067  		(yyval.node) = nod(OTARRAY, (yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
  4068  	}
  4069      break;
  4070  
  4071    case 192:
  4072  
  4073  /* Line 1806 of yacc.c  */
  4074  #line 1238 "go.y"
  4075      {
  4076  		// array literal of nelem
  4077  		(yyval.node) = nod(OTARRAY, nod(ODDD, N, N), (yyvsp[(4) - (4)].node));
  4078  	}
  4079      break;
  4080  
  4081    case 193:
  4082  
  4083  /* Line 1806 of yacc.c  */
  4084  #line 1243 "go.y"
  4085      {
  4086  		(yyval.node) = nod(OTCHAN, (yyvsp[(2) - (2)].node), N);
  4087  		(yyval.node)->etype = Cboth;
  4088  	}
  4089      break;
  4090  
  4091    case 194:
  4092  
  4093  /* Line 1806 of yacc.c  */
  4094  #line 1248 "go.y"
  4095      {
  4096  		(yyval.node) = nod(OTCHAN, (yyvsp[(3) - (3)].node), N);
  4097  		(yyval.node)->etype = Csend;
  4098  	}
  4099      break;
  4100  
  4101    case 195:
  4102  
  4103  /* Line 1806 of yacc.c  */
  4104  #line 1253 "go.y"
  4105      {
  4106  		(yyval.node) = nod(OTMAP, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
  4107  	}
  4108      break;
  4109  
  4110    case 198:
  4111  
  4112  /* Line 1806 of yacc.c  */
  4113  #line 1261 "go.y"
  4114      {
  4115  		(yyval.node) = nod(OIND, (yyvsp[(2) - (2)].node), N);
  4116  	}
  4117      break;
  4118  
  4119    case 199:
  4120  
  4121  /* Line 1806 of yacc.c  */
  4122  #line 1267 "go.y"
  4123      {
  4124  		(yyval.node) = nod(OTCHAN, (yyvsp[(3) - (3)].node), N);
  4125  		(yyval.node)->etype = Crecv;
  4126  	}
  4127      break;
  4128  
  4129    case 200:
  4130  
  4131  /* Line 1806 of yacc.c  */
  4132  #line 1274 "go.y"
  4133      {
  4134  		(yyval.node) = nod(OTSTRUCT, N, N);
  4135  		(yyval.node)->list = (yyvsp[(3) - (5)].list);
  4136  		fixlbrace((yyvsp[(2) - (5)].i));
  4137  	}
  4138      break;
  4139  
  4140    case 201:
  4141  
  4142  /* Line 1806 of yacc.c  */
  4143  #line 1280 "go.y"
  4144      {
  4145  		(yyval.node) = nod(OTSTRUCT, N, N);
  4146  		fixlbrace((yyvsp[(2) - (3)].i));
  4147  	}
  4148      break;
  4149  
  4150    case 202:
  4151  
  4152  /* Line 1806 of yacc.c  */
  4153  #line 1287 "go.y"
  4154      {
  4155  		(yyval.node) = nod(OTINTER, N, N);
  4156  		(yyval.node)->list = (yyvsp[(3) - (5)].list);
  4157  		fixlbrace((yyvsp[(2) - (5)].i));
  4158  	}
  4159      break;
  4160  
  4161    case 203:
  4162  
  4163  /* Line 1806 of yacc.c  */
  4164  #line 1293 "go.y"
  4165      {
  4166  		(yyval.node) = nod(OTINTER, N, N);
  4167  		fixlbrace((yyvsp[(2) - (3)].i));
  4168  	}
  4169      break;
  4170  
  4171    case 204:
  4172  
  4173  /* Line 1806 of yacc.c  */
  4174  #line 1304 "go.y"
  4175      {
  4176  		(yyval.node) = (yyvsp[(2) - (3)].node);
  4177  		if((yyval.node) == N)
  4178  			break;
  4179  		if(noescape && (yyvsp[(3) - (3)].list) != nil)
  4180  			yyerror("can only use //go:noescape with external func implementations");
  4181  		(yyval.node)->nbody = (yyvsp[(3) - (3)].list);
  4182  		(yyval.node)->endlineno = lineno;
  4183  		(yyval.node)->noescape = noescape;
  4184  		funcbody((yyval.node));
  4185  	}
  4186      break;
  4187  
  4188    case 205:
  4189  
  4190  /* Line 1806 of yacc.c  */
  4191  #line 1318 "go.y"
  4192      {
  4193  		Node *t;
  4194  
  4195  		(yyval.node) = N;
  4196  		(yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list), 1);
  4197  
  4198  		if(strcmp((yyvsp[(1) - (5)].sym)->name, "init") == 0) {
  4199  			(yyvsp[(1) - (5)].sym) = renameinit();
  4200  			if((yyvsp[(3) - (5)].list) != nil || (yyvsp[(5) - (5)].list) != nil)
  4201  				yyerror("func init must have no arguments and no return values");
  4202  		}
  4203  		if(strcmp(localpkg->name, "main") == 0 && strcmp((yyvsp[(1) - (5)].sym)->name, "main") == 0) {
  4204  			if((yyvsp[(3) - (5)].list) != nil || (yyvsp[(5) - (5)].list) != nil)
  4205  				yyerror("func main must have no arguments and no return values");
  4206  		}
  4207  
  4208  		t = nod(OTFUNC, N, N);
  4209  		t->list = (yyvsp[(3) - (5)].list);
  4210  		t->rlist = (yyvsp[(5) - (5)].list);
  4211  
  4212  		(yyval.node) = nod(ODCLFUNC, N, N);
  4213  		(yyval.node)->nname = newname((yyvsp[(1) - (5)].sym));
  4214  		(yyval.node)->nname->defn = (yyval.node);
  4215  		(yyval.node)->nname->ntype = t;		// TODO: check if nname already has an ntype
  4216  		declare((yyval.node)->nname, PFUNC);
  4217  
  4218  		funchdr((yyval.node));
  4219  	}
  4220      break;
  4221  
  4222    case 206:
  4223  
  4224  /* Line 1806 of yacc.c  */
  4225  #line 1347 "go.y"
  4226      {
  4227  		Node *rcvr, *t;
  4228  
  4229  		(yyval.node) = N;
  4230  		(yyvsp[(2) - (8)].list) = checkarglist((yyvsp[(2) - (8)].list), 0);
  4231  		(yyvsp[(6) - (8)].list) = checkarglist((yyvsp[(6) - (8)].list), 1);
  4232  
  4233  		if((yyvsp[(2) - (8)].list) == nil) {
  4234  			yyerror("method has no receiver");
  4235  			break;
  4236  		}
  4237  		if((yyvsp[(2) - (8)].list)->next != nil) {
  4238  			yyerror("method has multiple receivers");
  4239  			break;
  4240  		}
  4241  		rcvr = (yyvsp[(2) - (8)].list)->n;
  4242  		if(rcvr->op != ODCLFIELD) {
  4243  			yyerror("bad receiver in method");
  4244  			break;
  4245  		}
  4246  		if(rcvr->right->op == OTPAREN || (rcvr->right->op == OIND && rcvr->right->left->op == OTPAREN))
  4247  			yyerror("cannot parenthesize receiver type");
  4248  
  4249  		t = nod(OTFUNC, rcvr, N);
  4250  		t->list = (yyvsp[(6) - (8)].list);
  4251  		t->rlist = (yyvsp[(8) - (8)].list);
  4252  
  4253  		(yyval.node) = nod(ODCLFUNC, N, N);
  4254  		(yyval.node)->shortname = newname((yyvsp[(4) - (8)].sym));
  4255  		(yyval.node)->nname = methodname1((yyval.node)->shortname, rcvr->right);
  4256  		(yyval.node)->nname->defn = (yyval.node);
  4257  		(yyval.node)->nname->ntype = t;
  4258  		(yyval.node)->nname->nointerface = nointerface;
  4259  		declare((yyval.node)->nname, PFUNC);
  4260  
  4261  		funchdr((yyval.node));
  4262  	}
  4263      break;
  4264  
  4265    case 207:
  4266  
  4267  /* Line 1806 of yacc.c  */
  4268  #line 1387 "go.y"
  4269      {
  4270  		Sym *s;
  4271  		Type *t;
  4272  
  4273  		(yyval.node) = N;
  4274  
  4275  		s = (yyvsp[(1) - (5)].sym);
  4276  		t = functype(N, (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list));
  4277  
  4278  		importsym(s, ONAME);
  4279  		if(s->def != N && s->def->op == ONAME) {
  4280  			if(eqtype(t, s->def->type)) {
  4281  				dclcontext = PDISCARD;  // since we skip funchdr below
  4282  				break;
  4283  			}
  4284  			yyerror("inconsistent definition for func %S during import\n\t%T\n\t%T", s, s->def->type, t);
  4285  		}
  4286  
  4287  		(yyval.node) = newname(s);
  4288  		(yyval.node)->type = t;
  4289  		declare((yyval.node), PFUNC);
  4290  
  4291  		funchdr((yyval.node));
  4292  	}
  4293      break;
  4294  
  4295    case 208:
  4296  
  4297  /* Line 1806 of yacc.c  */
  4298  #line 1412 "go.y"
  4299      {
  4300  		(yyval.node) = methodname1(newname((yyvsp[(4) - (8)].sym)), (yyvsp[(2) - (8)].list)->n->right); 
  4301  		(yyval.node)->type = functype((yyvsp[(2) - (8)].list)->n, (yyvsp[(6) - (8)].list), (yyvsp[(8) - (8)].list));
  4302  
  4303  		checkwidth((yyval.node)->type);
  4304  		addmethod((yyvsp[(4) - (8)].sym), (yyval.node)->type, 0, nointerface);
  4305  		nointerface = 0;
  4306  		funchdr((yyval.node));
  4307  		
  4308  		// inl.c's inlnode in on a dotmeth node expects to find the inlineable body as
  4309  		// (dotmeth's type)->nname->inl, and dotmeth's type has been pulled
  4310  		// out by typecheck's lookdot as this $$->ttype.  So by providing
  4311  		// this back link here we avoid special casing there.
  4312  		(yyval.node)->type->nname = (yyval.node);
  4313  	}
  4314      break;
  4315  
  4316    case 209:
  4317  
  4318  /* Line 1806 of yacc.c  */
  4319  #line 1430 "go.y"
  4320      {
  4321  		(yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list), 1);
  4322  		(yyval.node) = nod(OTFUNC, N, N);
  4323  		(yyval.node)->list = (yyvsp[(3) - (5)].list);
  4324  		(yyval.node)->rlist = (yyvsp[(5) - (5)].list);
  4325  	}
  4326      break;
  4327  
  4328    case 210:
  4329  
  4330  /* Line 1806 of yacc.c  */
  4331  #line 1438 "go.y"
  4332      {
  4333  		(yyval.list) = nil;
  4334  	}
  4335      break;
  4336  
  4337    case 211:
  4338  
  4339  /* Line 1806 of yacc.c  */
  4340  #line 1442 "go.y"
  4341      {
  4342  		(yyval.list) = (yyvsp[(2) - (3)].list);
  4343  		if((yyval.list) == nil)
  4344  			(yyval.list) = list1(nod(OEMPTY, N, N));
  4345  	}
  4346      break;
  4347  
  4348    case 212:
  4349  
  4350  /* Line 1806 of yacc.c  */
  4351  #line 1450 "go.y"
  4352      {
  4353  		(yyval.list) = nil;
  4354  	}
  4355      break;
  4356  
  4357    case 213:
  4358  
  4359  /* Line 1806 of yacc.c  */
  4360  #line 1454 "go.y"
  4361      {
  4362  		(yyval.list) = list1(nod(ODCLFIELD, N, (yyvsp[(1) - (1)].node)));
  4363  	}
  4364      break;
  4365  
  4366    case 214:
  4367  
  4368  /* Line 1806 of yacc.c  */
  4369  #line 1458 "go.y"
  4370      {
  4371  		(yyvsp[(2) - (3)].list) = checkarglist((yyvsp[(2) - (3)].list), 0);
  4372  		(yyval.list) = (yyvsp[(2) - (3)].list);
  4373  	}
  4374      break;
  4375  
  4376    case 215:
  4377  
  4378  /* Line 1806 of yacc.c  */
  4379  #line 1465 "go.y"
  4380      {
  4381  		closurehdr((yyvsp[(1) - (1)].node));
  4382  	}
  4383      break;
  4384  
  4385    case 216:
  4386  
  4387  /* Line 1806 of yacc.c  */
  4388  #line 1471 "go.y"
  4389      {
  4390  		(yyval.node) = closurebody((yyvsp[(3) - (4)].list));
  4391  		fixlbrace((yyvsp[(2) - (4)].i));
  4392  	}
  4393      break;
  4394  
  4395    case 217:
  4396  
  4397  /* Line 1806 of yacc.c  */
  4398  #line 1476 "go.y"
  4399      {
  4400  		(yyval.node) = closurebody(nil);
  4401  	}
  4402      break;
  4403  
  4404    case 218:
  4405  
  4406  /* Line 1806 of yacc.c  */
  4407  #line 1487 "go.y"
  4408      {
  4409  		(yyval.list) = nil;
  4410  	}
  4411      break;
  4412  
  4413    case 219:
  4414  
  4415  /* Line 1806 of yacc.c  */
  4416  #line 1491 "go.y"
  4417      {
  4418  		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(2) - (3)].list));
  4419  		if(nsyntaxerrors == 0)
  4420  			testdclstack();
  4421  		nointerface = 0;
  4422  		noescape = 0;
  4423  	}
  4424      break;
  4425  
  4426    case 221:
  4427  
  4428  /* Line 1806 of yacc.c  */
  4429  #line 1502 "go.y"
  4430      {
  4431  		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list));
  4432  	}
  4433      break;
  4434  
  4435    case 223:
  4436  
  4437  /* Line 1806 of yacc.c  */
  4438  #line 1509 "go.y"
  4439      {
  4440  		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list));
  4441  	}
  4442      break;
  4443  
  4444    case 224:
  4445  
  4446  /* Line 1806 of yacc.c  */
  4447  #line 1515 "go.y"
  4448      {
  4449  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4450  	}
  4451      break;
  4452  
  4453    case 225:
  4454  
  4455  /* Line 1806 of yacc.c  */
  4456  #line 1519 "go.y"
  4457      {
  4458  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4459  	}
  4460      break;
  4461  
  4462    case 227:
  4463  
  4464  /* Line 1806 of yacc.c  */
  4465  #line 1526 "go.y"
  4466      {
  4467  		(yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list));
  4468  	}
  4469      break;
  4470  
  4471    case 228:
  4472  
  4473  /* Line 1806 of yacc.c  */
  4474  #line 1532 "go.y"
  4475      {
  4476  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4477  	}
  4478      break;
  4479  
  4480    case 229:
  4481  
  4482  /* Line 1806 of yacc.c  */
  4483  #line 1536 "go.y"
  4484      {
  4485  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4486  	}
  4487      break;
  4488  
  4489    case 230:
  4490  
  4491  /* Line 1806 of yacc.c  */
  4492  #line 1542 "go.y"
  4493      {
  4494  		NodeList *l;
  4495  
  4496  		Node *n;
  4497  		l = (yyvsp[(1) - (3)].list);
  4498  		if(l == nil) {
  4499  			// ? symbol, during import (list1(N) == nil)
  4500  			n = (yyvsp[(2) - (3)].node);
  4501  			if(n->op == OIND)
  4502  				n = n->left;
  4503  			n = embedded(n->sym, importpkg);
  4504  			n->right = (yyvsp[(2) - (3)].node);
  4505  			n->val = (yyvsp[(3) - (3)].val);
  4506  			(yyval.list) = list1(n);
  4507  			break;
  4508  		}
  4509  
  4510  		for(l=(yyvsp[(1) - (3)].list); l; l=l->next) {
  4511  			l->n = nod(ODCLFIELD, l->n, (yyvsp[(2) - (3)].node));
  4512  			l->n->val = (yyvsp[(3) - (3)].val);
  4513  		}
  4514  	}
  4515      break;
  4516  
  4517    case 231:
  4518  
  4519  /* Line 1806 of yacc.c  */
  4520  #line 1565 "go.y"
  4521      {
  4522  		(yyvsp[(1) - (2)].node)->val = (yyvsp[(2) - (2)].val);
  4523  		(yyval.list) = list1((yyvsp[(1) - (2)].node));
  4524  	}
  4525      break;
  4526  
  4527    case 232:
  4528  
  4529  /* Line 1806 of yacc.c  */
  4530  #line 1570 "go.y"
  4531      {
  4532  		(yyvsp[(2) - (4)].node)->val = (yyvsp[(4) - (4)].val);
  4533  		(yyval.list) = list1((yyvsp[(2) - (4)].node));
  4534  		yyerror("cannot parenthesize embedded type");
  4535  	}
  4536      break;
  4537  
  4538    case 233:
  4539  
  4540  /* Line 1806 of yacc.c  */
  4541  #line 1576 "go.y"
  4542      {
  4543  		(yyvsp[(2) - (3)].node)->right = nod(OIND, (yyvsp[(2) - (3)].node)->right, N);
  4544  		(yyvsp[(2) - (3)].node)->val = (yyvsp[(3) - (3)].val);
  4545  		(yyval.list) = list1((yyvsp[(2) - (3)].node));
  4546  	}
  4547      break;
  4548  
  4549    case 234:
  4550  
  4551  /* Line 1806 of yacc.c  */
  4552  #line 1582 "go.y"
  4553      {
  4554  		(yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N);
  4555  		(yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val);
  4556  		(yyval.list) = list1((yyvsp[(3) - (5)].node));
  4557  		yyerror("cannot parenthesize embedded type");
  4558  	}
  4559      break;
  4560  
  4561    case 235:
  4562  
  4563  /* Line 1806 of yacc.c  */
  4564  #line 1589 "go.y"
  4565      {
  4566  		(yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].node)->right, N);
  4567  		(yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val);
  4568  		(yyval.list) = list1((yyvsp[(3) - (5)].node));
  4569  		yyerror("cannot parenthesize embedded type");
  4570  	}
  4571      break;
  4572  
  4573    case 236:
  4574  
  4575  /* Line 1806 of yacc.c  */
  4576  #line 1598 "go.y"
  4577      {
  4578  		Node *n;
  4579  
  4580  		(yyval.sym) = (yyvsp[(1) - (1)].sym);
  4581  		n = oldname((yyvsp[(1) - (1)].sym));
  4582  		if(n->pack != N)
  4583  			n->pack->used = 1;
  4584  	}
  4585      break;
  4586  
  4587    case 237:
  4588  
  4589  /* Line 1806 of yacc.c  */
  4590  #line 1607 "go.y"
  4591      {
  4592  		Pkg *pkg;
  4593  
  4594  		if((yyvsp[(1) - (3)].sym)->def == N || (yyvsp[(1) - (3)].sym)->def->op != OPACK) {
  4595  			yyerror("%S is not a package", (yyvsp[(1) - (3)].sym));
  4596  			pkg = localpkg;
  4597  		} else {
  4598  			(yyvsp[(1) - (3)].sym)->def->used = 1;
  4599  			pkg = (yyvsp[(1) - (3)].sym)->def->pkg;
  4600  		}
  4601  		(yyval.sym) = restrictlookup((yyvsp[(3) - (3)].sym)->name, pkg);
  4602  	}
  4603      break;
  4604  
  4605    case 238:
  4606  
  4607  /* Line 1806 of yacc.c  */
  4608  #line 1622 "go.y"
  4609      {
  4610  		(yyval.node) = embedded((yyvsp[(1) - (1)].sym), localpkg);
  4611  	}
  4612      break;
  4613  
  4614    case 239:
  4615  
  4616  /* Line 1806 of yacc.c  */
  4617  #line 1628 "go.y"
  4618      {
  4619  		(yyval.node) = nod(ODCLFIELD, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
  4620  		ifacedcl((yyval.node));
  4621  	}
  4622      break;
  4623  
  4624    case 240:
  4625  
  4626  /* Line 1806 of yacc.c  */
  4627  #line 1633 "go.y"
  4628      {
  4629  		(yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(1) - (1)].sym)));
  4630  	}
  4631      break;
  4632  
  4633    case 241:
  4634  
  4635  /* Line 1806 of yacc.c  */
  4636  #line 1637 "go.y"
  4637      {
  4638  		(yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(2) - (3)].sym)));
  4639  		yyerror("cannot parenthesize embedded type");
  4640  	}
  4641      break;
  4642  
  4643    case 242:
  4644  
  4645  /* Line 1806 of yacc.c  */
  4646  #line 1644 "go.y"
  4647      {
  4648  		// without func keyword
  4649  		(yyvsp[(2) - (4)].list) = checkarglist((yyvsp[(2) - (4)].list), 1);
  4650  		(yyval.node) = nod(OTFUNC, fakethis(), N);
  4651  		(yyval.node)->list = (yyvsp[(2) - (4)].list);
  4652  		(yyval.node)->rlist = (yyvsp[(4) - (4)].list);
  4653  	}
  4654      break;
  4655  
  4656    case 244:
  4657  
  4658  /* Line 1806 of yacc.c  */
  4659  #line 1658 "go.y"
  4660      {
  4661  		(yyval.node) = nod(ONONAME, N, N);
  4662  		(yyval.node)->sym = (yyvsp[(1) - (2)].sym);
  4663  		(yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node));
  4664  	}
  4665      break;
  4666  
  4667    case 245:
  4668  
  4669  /* Line 1806 of yacc.c  */
  4670  #line 1664 "go.y"
  4671      {
  4672  		(yyval.node) = nod(ONONAME, N, N);
  4673  		(yyval.node)->sym = (yyvsp[(1) - (2)].sym);
  4674  		(yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node));
  4675  	}
  4676      break;
  4677  
  4678    case 247:
  4679  
  4680  /* Line 1806 of yacc.c  */
  4681  #line 1673 "go.y"
  4682      {
  4683  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4684  	}
  4685      break;
  4686  
  4687    case 248:
  4688  
  4689  /* Line 1806 of yacc.c  */
  4690  #line 1677 "go.y"
  4691      {
  4692  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4693  	}
  4694      break;
  4695  
  4696    case 249:
  4697  
  4698  /* Line 1806 of yacc.c  */
  4699  #line 1682 "go.y"
  4700      {
  4701  		(yyval.list) = nil;
  4702  	}
  4703      break;
  4704  
  4705    case 250:
  4706  
  4707  /* Line 1806 of yacc.c  */
  4708  #line 1686 "go.y"
  4709      {
  4710  		(yyval.list) = (yyvsp[(1) - (2)].list);
  4711  	}
  4712      break;
  4713  
  4714    case 251:
  4715  
  4716  /* Line 1806 of yacc.c  */
  4717  #line 1694 "go.y"
  4718      {
  4719  		(yyval.node) = N;
  4720  	}
  4721      break;
  4722  
  4723    case 253:
  4724  
  4725  /* Line 1806 of yacc.c  */
  4726  #line 1699 "go.y"
  4727      {
  4728  		(yyval.node) = liststmt((yyvsp[(1) - (1)].list));
  4729  	}
  4730      break;
  4731  
  4732    case 255:
  4733  
  4734  /* Line 1806 of yacc.c  */
  4735  #line 1704 "go.y"
  4736      {
  4737  		(yyval.node) = N;
  4738  	}
  4739      break;
  4740  
  4741    case 261:
  4742  
  4743  /* Line 1806 of yacc.c  */
  4744  #line 1715 "go.y"
  4745      {
  4746  		(yyvsp[(1) - (2)].node) = nod(OLABEL, (yyvsp[(1) - (2)].node), N);
  4747  		(yyvsp[(1) - (2)].node)->sym = dclstack;  // context, for goto restrictions
  4748  	}
  4749      break;
  4750  
  4751    case 262:
  4752  
  4753  /* Line 1806 of yacc.c  */
  4754  #line 1720 "go.y"
  4755      {
  4756  		NodeList *l;
  4757  
  4758  		(yyvsp[(1) - (4)].node)->defn = (yyvsp[(4) - (4)].node);
  4759  		l = list1((yyvsp[(1) - (4)].node));
  4760  		if((yyvsp[(4) - (4)].node))
  4761  			l = list(l, (yyvsp[(4) - (4)].node));
  4762  		(yyval.node) = liststmt(l);
  4763  	}
  4764      break;
  4765  
  4766    case 263:
  4767  
  4768  /* Line 1806 of yacc.c  */
  4769  #line 1730 "go.y"
  4770      {
  4771  		// will be converted to OFALL
  4772  		(yyval.node) = nod(OXFALL, N, N);
  4773  	}
  4774      break;
  4775  
  4776    case 264:
  4777  
  4778  /* Line 1806 of yacc.c  */
  4779  #line 1735 "go.y"
  4780      {
  4781  		(yyval.node) = nod(OBREAK, (yyvsp[(2) - (2)].node), N);
  4782  	}
  4783      break;
  4784  
  4785    case 265:
  4786  
  4787  /* Line 1806 of yacc.c  */
  4788  #line 1739 "go.y"
  4789      {
  4790  		(yyval.node) = nod(OCONTINUE, (yyvsp[(2) - (2)].node), N);
  4791  	}
  4792      break;
  4793  
  4794    case 266:
  4795  
  4796  /* Line 1806 of yacc.c  */
  4797  #line 1743 "go.y"
  4798      {
  4799  		(yyval.node) = nod(OPROC, (yyvsp[(2) - (2)].node), N);
  4800  	}
  4801      break;
  4802  
  4803    case 267:
  4804  
  4805  /* Line 1806 of yacc.c  */
  4806  #line 1747 "go.y"
  4807      {
  4808  		(yyval.node) = nod(ODEFER, (yyvsp[(2) - (2)].node), N);
  4809  	}
  4810      break;
  4811  
  4812    case 268:
  4813  
  4814  /* Line 1806 of yacc.c  */
  4815  #line 1751 "go.y"
  4816      {
  4817  		(yyval.node) = nod(OGOTO, (yyvsp[(2) - (2)].node), N);
  4818  		(yyval.node)->sym = dclstack;  // context, for goto restrictions
  4819  	}
  4820      break;
  4821  
  4822    case 269:
  4823  
  4824  /* Line 1806 of yacc.c  */
  4825  #line 1756 "go.y"
  4826      {
  4827  		(yyval.node) = nod(ORETURN, N, N);
  4828  		(yyval.node)->list = (yyvsp[(2) - (2)].list);
  4829  		if((yyval.node)->list == nil && curfn != N) {
  4830  			NodeList *l;
  4831  
  4832  			for(l=curfn->dcl; l; l=l->next) {
  4833  				if(l->n->class == PPARAM)
  4834  					continue;
  4835  				if(l->n->class != PPARAMOUT)
  4836  					break;
  4837  				if(l->n->sym->def != l->n)
  4838  					yyerror("%s is shadowed during return", l->n->sym->name);
  4839  			}
  4840  		}
  4841  	}
  4842      break;
  4843  
  4844    case 270:
  4845  
  4846  /* Line 1806 of yacc.c  */
  4847  #line 1775 "go.y"
  4848      {
  4849  		(yyval.list) = nil;
  4850  		if((yyvsp[(1) - (1)].node) != N)
  4851  			(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4852  	}
  4853      break;
  4854  
  4855    case 271:
  4856  
  4857  /* Line 1806 of yacc.c  */
  4858  #line 1781 "go.y"
  4859      {
  4860  		(yyval.list) = (yyvsp[(1) - (3)].list);
  4861  		if((yyvsp[(3) - (3)].node) != N)
  4862  			(yyval.list) = list((yyval.list), (yyvsp[(3) - (3)].node));
  4863  	}
  4864      break;
  4865  
  4866    case 272:
  4867  
  4868  /* Line 1806 of yacc.c  */
  4869  #line 1789 "go.y"
  4870      {
  4871  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4872  	}
  4873      break;
  4874  
  4875    case 273:
  4876  
  4877  /* Line 1806 of yacc.c  */
  4878  #line 1793 "go.y"
  4879      {
  4880  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4881  	}
  4882      break;
  4883  
  4884    case 274:
  4885  
  4886  /* Line 1806 of yacc.c  */
  4887  #line 1799 "go.y"
  4888      {
  4889  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4890  	}
  4891      break;
  4892  
  4893    case 275:
  4894  
  4895  /* Line 1806 of yacc.c  */
  4896  #line 1803 "go.y"
  4897      {
  4898  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4899  	}
  4900      break;
  4901  
  4902    case 276:
  4903  
  4904  /* Line 1806 of yacc.c  */
  4905  #line 1809 "go.y"
  4906      {
  4907  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4908  	}
  4909      break;
  4910  
  4911    case 277:
  4912  
  4913  /* Line 1806 of yacc.c  */
  4914  #line 1813 "go.y"
  4915      {
  4916  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4917  	}
  4918      break;
  4919  
  4920    case 278:
  4921  
  4922  /* Line 1806 of yacc.c  */
  4923  #line 1819 "go.y"
  4924      {
  4925  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4926  	}
  4927      break;
  4928  
  4929    case 279:
  4930  
  4931  /* Line 1806 of yacc.c  */
  4932  #line 1823 "go.y"
  4933      {
  4934  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4935  	}
  4936      break;
  4937  
  4938    case 280:
  4939  
  4940  /* Line 1806 of yacc.c  */
  4941  #line 1832 "go.y"
  4942      {
  4943  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4944  	}
  4945      break;
  4946  
  4947    case 281:
  4948  
  4949  /* Line 1806 of yacc.c  */
  4950  #line 1836 "go.y"
  4951      {
  4952  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  4953  	}
  4954      break;
  4955  
  4956    case 282:
  4957  
  4958  /* Line 1806 of yacc.c  */
  4959  #line 1840 "go.y"
  4960      {
  4961  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4962  	}
  4963      break;
  4964  
  4965    case 283:
  4966  
  4967  /* Line 1806 of yacc.c  */
  4968  #line 1844 "go.y"
  4969      {
  4970  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  4971  	}
  4972      break;
  4973  
  4974    case 284:
  4975  
  4976  /* Line 1806 of yacc.c  */
  4977  #line 1849 "go.y"
  4978      {
  4979  		(yyval.list) = nil;
  4980  	}
  4981      break;
  4982  
  4983    case 285:
  4984  
  4985  /* Line 1806 of yacc.c  */
  4986  #line 1853 "go.y"
  4987      {
  4988  		(yyval.list) = (yyvsp[(1) - (2)].list);
  4989  	}
  4990      break;
  4991  
  4992    case 290:
  4993  
  4994  /* Line 1806 of yacc.c  */
  4995  #line 1867 "go.y"
  4996      {
  4997  		(yyval.node) = N;
  4998  	}
  4999      break;
  5000  
  5001    case 292:
  5002  
  5003  /* Line 1806 of yacc.c  */
  5004  #line 1873 "go.y"
  5005      {
  5006  		(yyval.list) = nil;
  5007  	}
  5008      break;
  5009  
  5010    case 294:
  5011  
  5012  /* Line 1806 of yacc.c  */
  5013  #line 1879 "go.y"
  5014      {
  5015  		(yyval.node) = N;
  5016  	}
  5017      break;
  5018  
  5019    case 296:
  5020  
  5021  /* Line 1806 of yacc.c  */
  5022  #line 1885 "go.y"
  5023      {
  5024  		(yyval.list) = nil;
  5025  	}
  5026      break;
  5027  
  5028    case 298:
  5029  
  5030  /* Line 1806 of yacc.c  */
  5031  #line 1891 "go.y"
  5032      {
  5033  		(yyval.list) = nil;
  5034  	}
  5035      break;
  5036  
  5037    case 300:
  5038  
  5039  /* Line 1806 of yacc.c  */
  5040  #line 1897 "go.y"
  5041      {
  5042  		(yyval.list) = nil;
  5043  	}
  5044      break;
  5045  
  5046    case 302:
  5047  
  5048  /* Line 1806 of yacc.c  */
  5049  #line 1903 "go.y"
  5050      {
  5051  		(yyval.val).ctype = CTxxx;
  5052  	}
  5053      break;
  5054  
  5055    case 304:
  5056  
  5057  /* Line 1806 of yacc.c  */
  5058  #line 1913 "go.y"
  5059      {
  5060  		importimport((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].val).u.sval);
  5061  	}
  5062      break;
  5063  
  5064    case 305:
  5065  
  5066  /* Line 1806 of yacc.c  */
  5067  #line 1917 "go.y"
  5068      {
  5069  		importvar((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].type));
  5070  	}
  5071      break;
  5072  
  5073    case 306:
  5074  
  5075  /* Line 1806 of yacc.c  */
  5076  #line 1921 "go.y"
  5077      {
  5078  		importconst((yyvsp[(2) - (5)].sym), types[TIDEAL], (yyvsp[(4) - (5)].node));
  5079  	}
  5080      break;
  5081  
  5082    case 307:
  5083  
  5084  /* Line 1806 of yacc.c  */
  5085  #line 1925 "go.y"
  5086      {
  5087  		importconst((yyvsp[(2) - (6)].sym), (yyvsp[(3) - (6)].type), (yyvsp[(5) - (6)].node));
  5088  	}
  5089      break;
  5090  
  5091    case 308:
  5092  
  5093  /* Line 1806 of yacc.c  */
  5094  #line 1929 "go.y"
  5095      {
  5096  		importtype((yyvsp[(2) - (4)].type), (yyvsp[(3) - (4)].type));
  5097  	}
  5098      break;
  5099  
  5100    case 309:
  5101  
  5102  /* Line 1806 of yacc.c  */
  5103  #line 1933 "go.y"
  5104      {
  5105  		if((yyvsp[(2) - (4)].node) == N) {
  5106  			dclcontext = PEXTERN;  // since we skip the funcbody below
  5107  			break;
  5108  		}
  5109  
  5110  		(yyvsp[(2) - (4)].node)->inl = (yyvsp[(3) - (4)].list);
  5111  
  5112  		funcbody((yyvsp[(2) - (4)].node));
  5113  		importlist = list(importlist, (yyvsp[(2) - (4)].node));
  5114  
  5115  		if(debug['E']) {
  5116  			print("import [%Z] func %lN \n", importpkg->path, (yyvsp[(2) - (4)].node));
  5117  			if(debug['m'] > 2 && (yyvsp[(2) - (4)].node)->inl)
  5118  				print("inl body:%+H\n", (yyvsp[(2) - (4)].node)->inl);
  5119  		}
  5120  	}
  5121      break;
  5122  
  5123    case 310:
  5124  
  5125  /* Line 1806 of yacc.c  */
  5126  #line 1953 "go.y"
  5127      {
  5128  		(yyval.sym) = (yyvsp[(1) - (1)].sym);
  5129  		structpkg = (yyval.sym)->pkg;
  5130  	}
  5131      break;
  5132  
  5133    case 311:
  5134  
  5135  /* Line 1806 of yacc.c  */
  5136  #line 1960 "go.y"
  5137      {
  5138  		(yyval.type) = pkgtype((yyvsp[(1) - (1)].sym));
  5139  		importsym((yyvsp[(1) - (1)].sym), OTYPE);
  5140  	}
  5141      break;
  5142  
  5143    case 317:
  5144  
  5145  /* Line 1806 of yacc.c  */
  5146  #line 1980 "go.y"
  5147      {
  5148  		(yyval.type) = pkgtype((yyvsp[(1) - (1)].sym));
  5149  	}
  5150      break;
  5151  
  5152    case 318:
  5153  
  5154  /* Line 1806 of yacc.c  */
  5155  #line 1984 "go.y"
  5156      {
  5157  		// predefined name like uint8
  5158  		(yyvsp[(1) - (1)].sym) = pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg);
  5159  		if((yyvsp[(1) - (1)].sym)->def == N || (yyvsp[(1) - (1)].sym)->def->op != OTYPE) {
  5160  			yyerror("%s is not a type", (yyvsp[(1) - (1)].sym)->name);
  5161  			(yyval.type) = T;
  5162  		} else
  5163  			(yyval.type) = (yyvsp[(1) - (1)].sym)->def->type;
  5164  	}
  5165      break;
  5166  
  5167    case 319:
  5168  
  5169  /* Line 1806 of yacc.c  */
  5170  #line 1994 "go.y"
  5171      {
  5172  		(yyval.type) = aindex(N, (yyvsp[(3) - (3)].type));
  5173  	}
  5174      break;
  5175  
  5176    case 320:
  5177  
  5178  /* Line 1806 of yacc.c  */
  5179  #line 1998 "go.y"
  5180      {
  5181  		(yyval.type) = aindex(nodlit((yyvsp[(2) - (4)].val)), (yyvsp[(4) - (4)].type));
  5182  	}
  5183      break;
  5184  
  5185    case 321:
  5186  
  5187  /* Line 1806 of yacc.c  */
  5188  #line 2002 "go.y"
  5189      {
  5190  		(yyval.type) = maptype((yyvsp[(3) - (5)].type), (yyvsp[(5) - (5)].type));
  5191  	}
  5192      break;
  5193  
  5194    case 322:
  5195  
  5196  /* Line 1806 of yacc.c  */
  5197  #line 2006 "go.y"
  5198      {
  5199  		(yyval.type) = tostruct((yyvsp[(3) - (4)].list));
  5200  	}
  5201      break;
  5202  
  5203    case 323:
  5204  
  5205  /* Line 1806 of yacc.c  */
  5206  #line 2010 "go.y"
  5207      {
  5208  		(yyval.type) = tointerface((yyvsp[(3) - (4)].list));
  5209  	}
  5210      break;
  5211  
  5212    case 324:
  5213  
  5214  /* Line 1806 of yacc.c  */
  5215  #line 2014 "go.y"
  5216      {
  5217  		(yyval.type) = ptrto((yyvsp[(2) - (2)].type));
  5218  	}
  5219      break;
  5220  
  5221    case 325:
  5222  
  5223  /* Line 1806 of yacc.c  */
  5224  #line 2018 "go.y"
  5225      {
  5226  		(yyval.type) = typ(TCHAN);
  5227  		(yyval.type)->type = (yyvsp[(2) - (2)].type);
  5228  		(yyval.type)->chan = Cboth;
  5229  	}
  5230      break;
  5231  
  5232    case 326:
  5233  
  5234  /* Line 1806 of yacc.c  */
  5235  #line 2024 "go.y"
  5236      {
  5237  		(yyval.type) = typ(TCHAN);
  5238  		(yyval.type)->type = (yyvsp[(3) - (4)].type);
  5239  		(yyval.type)->chan = Cboth;
  5240  	}
  5241      break;
  5242  
  5243    case 327:
  5244  
  5245  /* Line 1806 of yacc.c  */
  5246  #line 2030 "go.y"
  5247      {
  5248  		(yyval.type) = typ(TCHAN);
  5249  		(yyval.type)->type = (yyvsp[(3) - (3)].type);
  5250  		(yyval.type)->chan = Csend;
  5251  	}
  5252      break;
  5253  
  5254    case 328:
  5255  
  5256  /* Line 1806 of yacc.c  */
  5257  #line 2038 "go.y"
  5258      {
  5259  		(yyval.type) = typ(TCHAN);
  5260  		(yyval.type)->type = (yyvsp[(3) - (3)].type);
  5261  		(yyval.type)->chan = Crecv;
  5262  	}
  5263      break;
  5264  
  5265    case 329:
  5266  
  5267  /* Line 1806 of yacc.c  */
  5268  #line 2046 "go.y"
  5269      {
  5270  		(yyval.type) = functype(nil, (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list));
  5271  	}
  5272      break;
  5273  
  5274    case 330:
  5275  
  5276  /* Line 1806 of yacc.c  */
  5277  #line 2052 "go.y"
  5278      {
  5279  		(yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(2) - (3)].type)));
  5280  		if((yyvsp[(1) - (3)].sym))
  5281  			(yyval.node)->left = newname((yyvsp[(1) - (3)].sym));
  5282  		(yyval.node)->val = (yyvsp[(3) - (3)].val);
  5283  	}
  5284      break;
  5285  
  5286    case 331:
  5287  
  5288  /* Line 1806 of yacc.c  */
  5289  #line 2059 "go.y"
  5290      {
  5291  		Type *t;
  5292  	
  5293  		t = typ(TARRAY);
  5294  		t->bound = -1;
  5295  		t->type = (yyvsp[(3) - (4)].type);
  5296  
  5297  		(yyval.node) = nod(ODCLFIELD, N, typenod(t));
  5298  		if((yyvsp[(1) - (4)].sym))
  5299  			(yyval.node)->left = newname((yyvsp[(1) - (4)].sym));
  5300  		(yyval.node)->isddd = 1;
  5301  		(yyval.node)->val = (yyvsp[(4) - (4)].val);
  5302  	}
  5303      break;
  5304  
  5305    case 332:
  5306  
  5307  /* Line 1806 of yacc.c  */
  5308  #line 2075 "go.y"
  5309      {
  5310  		Sym *s;
  5311  		Pkg *p;
  5312  
  5313  		if((yyvsp[(1) - (3)].sym) != S && strcmp((yyvsp[(1) - (3)].sym)->name, "?") != 0) {
  5314  			(yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (3)].sym)), typenod((yyvsp[(2) - (3)].type)));
  5315  			(yyval.node)->val = (yyvsp[(3) - (3)].val);
  5316  		} else {
  5317  			s = (yyvsp[(2) - (3)].type)->sym;
  5318  			if(s == S && isptr[(yyvsp[(2) - (3)].type)->etype])
  5319  				s = (yyvsp[(2) - (3)].type)->type->sym;
  5320  			p = importpkg;
  5321  			if((yyvsp[(1) - (3)].sym) != S)
  5322  				p = (yyvsp[(1) - (3)].sym)->pkg;
  5323  			(yyval.node) = embedded(s, p);
  5324  			(yyval.node)->right = typenod((yyvsp[(2) - (3)].type));
  5325  			(yyval.node)->val = (yyvsp[(3) - (3)].val);
  5326  		}
  5327  	}
  5328      break;
  5329  
  5330    case 333:
  5331  
  5332  /* Line 1806 of yacc.c  */
  5333  #line 2097 "go.y"
  5334      {
  5335  		(yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (5)].sym)), typenod(functype(fakethis(), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list))));
  5336  	}
  5337      break;
  5338  
  5339    case 334:
  5340  
  5341  /* Line 1806 of yacc.c  */
  5342  #line 2101 "go.y"
  5343      {
  5344  		(yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type)));
  5345  	}
  5346      break;
  5347  
  5348    case 335:
  5349  
  5350  /* Line 1806 of yacc.c  */
  5351  #line 2106 "go.y"
  5352      {
  5353  		(yyval.list) = nil;
  5354  	}
  5355      break;
  5356  
  5357    case 337:
  5358  
  5359  /* Line 1806 of yacc.c  */
  5360  #line 2113 "go.y"
  5361      {
  5362  		(yyval.list) = (yyvsp[(2) - (3)].list);
  5363  	}
  5364      break;
  5365  
  5366    case 338:
  5367  
  5368  /* Line 1806 of yacc.c  */
  5369  #line 2117 "go.y"
  5370      {
  5371  		(yyval.list) = list1(nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type))));
  5372  	}
  5373      break;
  5374  
  5375    case 339:
  5376  
  5377  /* Line 1806 of yacc.c  */
  5378  #line 2127 "go.y"
  5379      {
  5380  		(yyval.node) = nodlit((yyvsp[(1) - (1)].val));
  5381  	}
  5382      break;
  5383  
  5384    case 340:
  5385  
  5386  /* Line 1806 of yacc.c  */
  5387  #line 2131 "go.y"
  5388      {
  5389  		(yyval.node) = nodlit((yyvsp[(2) - (2)].val));
  5390  		switch((yyval.node)->val.ctype){
  5391  		case CTINT:
  5392  		case CTRUNE:
  5393  			mpnegfix((yyval.node)->val.u.xval);
  5394  			break;
  5395  		case CTFLT:
  5396  			mpnegflt((yyval.node)->val.u.fval);
  5397  			break;
  5398  		default:
  5399  			yyerror("bad negated constant");
  5400  		}
  5401  	}
  5402      break;
  5403  
  5404    case 341:
  5405  
  5406  /* Line 1806 of yacc.c  */
  5407  #line 2146 "go.y"
  5408      {
  5409  		(yyval.node) = oldname(pkglookup((yyvsp[(1) - (1)].sym)->name, builtinpkg));
  5410  		if((yyval.node)->op != OLITERAL)
  5411  			yyerror("bad constant %S", (yyval.node)->sym);
  5412  	}
  5413      break;
  5414  
  5415    case 343:
  5416  
  5417  /* Line 1806 of yacc.c  */
  5418  #line 2155 "go.y"
  5419      {
  5420  		if((yyvsp[(2) - (5)].node)->val.ctype == CTRUNE && (yyvsp[(4) - (5)].node)->val.ctype == CTINT) {
  5421  			(yyval.node) = (yyvsp[(2) - (5)].node);
  5422  			mpaddfixfix((yyvsp[(2) - (5)].node)->val.u.xval, (yyvsp[(4) - (5)].node)->val.u.xval, 0);
  5423  			break;
  5424  		}
  5425  		(yyvsp[(4) - (5)].node)->val.u.cval->real = (yyvsp[(4) - (5)].node)->val.u.cval->imag;
  5426  		mpmovecflt(&(yyvsp[(4) - (5)].node)->val.u.cval->imag, 0.0);
  5427  		(yyval.node) = nodcplxlit((yyvsp[(2) - (5)].node)->val, (yyvsp[(4) - (5)].node)->val);
  5428  	}
  5429      break;
  5430  
  5431    case 346:
  5432  
  5433  /* Line 1806 of yacc.c  */
  5434  #line 2171 "go.y"
  5435      {
  5436  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  5437  	}
  5438      break;
  5439  
  5440    case 347:
  5441  
  5442  /* Line 1806 of yacc.c  */
  5443  #line 2175 "go.y"
  5444      {
  5445  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  5446  	}
  5447      break;
  5448  
  5449    case 348:
  5450  
  5451  /* Line 1806 of yacc.c  */
  5452  #line 2181 "go.y"
  5453      {
  5454  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  5455  	}
  5456      break;
  5457  
  5458    case 349:
  5459  
  5460  /* Line 1806 of yacc.c  */
  5461  #line 2185 "go.y"
  5462      {
  5463  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  5464  	}
  5465      break;
  5466  
  5467    case 350:
  5468  
  5469  /* Line 1806 of yacc.c  */
  5470  #line 2191 "go.y"
  5471      {
  5472  		(yyval.list) = list1((yyvsp[(1) - (1)].node));
  5473  	}
  5474      break;
  5475  
  5476    case 351:
  5477  
  5478  /* Line 1806 of yacc.c  */
  5479  #line 2195 "go.y"
  5480      {
  5481  		(yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node));
  5482  	}
  5483      break;
  5484  
  5485  
  5486  
  5487  /* Line 1806 of yacc.c  */
  5488  #line 5490 "y.tab.c"
  5489        default: break;
  5490      }
  5491    /* User semantic actions sometimes alter yychar, and that requires
  5492       that yytoken be updated with the new translation.  We take the
  5493       approach of translating immediately before every use of yytoken.
  5494       One alternative is translating here after every semantic action,
  5495       but that translation would be missed if the semantic action invokes
  5496       YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
  5497       if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
  5498       incorrect destructor might then be invoked immediately.  In the
  5499       case of YYERROR or YYBACKUP, subsequent parser actions might lead
  5500       to an incorrect destructor call or verbose syntax error message
  5501       before the lookahead is translated.  */
  5502    YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
  5503  
  5504    YYPOPSTACK (yylen);
  5505    yylen = 0;
  5506    YY_STACK_PRINT (yyss, yyssp);
  5507  
  5508    *++yyvsp = yyval;
  5509  
  5510    /* Now `shift' the result of the reduction.  Determine what state
  5511       that goes to, based on the state we popped back to and the rule
  5512       number reduced by.  */
  5513  
  5514    yyn = yyr1[yyn];
  5515  
  5516    yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
  5517    if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  5518      yystate = yytable[yystate];
  5519    else
  5520      yystate = yydefgoto[yyn - YYNTOKENS];
  5521  
  5522    goto yynewstate;
  5523  
  5524  
  5525  /*------------------------------------.
  5526  | yyerrlab -- here on detecting error |
  5527  `------------------------------------*/
  5528  yyerrlab:
  5529    /* Make sure we have latest lookahead translation.  See comments at
  5530       user semantic actions for why this is necessary.  */
  5531    yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
  5532  
  5533    /* If not already recovering from an error, report this error.  */
  5534    if (!yyerrstatus)
  5535      {
  5536        ++yynerrs;
  5537  #if ! YYERROR_VERBOSE
  5538        yyerror (YY_("syntax error"));
  5539  #else
  5540  # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
  5541                                          yyssp, yytoken)
  5542        {
  5543          char *yymsgp = YY_("syntax error");
  5544          int yysyntax_error_status;
  5545          yysyntax_error_status = YYSYNTAX_ERROR;
  5546          if (yysyntax_error_status == 0)
  5547            yymsgp = yymsg;
  5548          else if (yysyntax_error_status == 1)
  5549            {
  5550              if (yymsg != yymsgbuf)
  5551                YYSTACK_FREE (yymsg);
  5552              yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
  5553              if (!yymsg)
  5554                {
  5555                  yymsg = yymsgbuf;
  5556                  yymsg_alloc = sizeof yymsgbuf;
  5557                  yysyntax_error_status = 2;
  5558                }
  5559              else
  5560                {
  5561                  yysyntax_error_status = YYSYNTAX_ERROR;
  5562                  yymsgp = yymsg;
  5563                }
  5564            }
  5565          yyerror (yymsgp);
  5566          if (yysyntax_error_status == 2)
  5567            goto yyexhaustedlab;
  5568        }
  5569  # undef YYSYNTAX_ERROR
  5570  #endif
  5571      }
  5572  
  5573  
  5574  
  5575    if (yyerrstatus == 3)
  5576      {
  5577        /* If just tried and failed to reuse lookahead token after an
  5578  	 error, discard it.  */
  5579  
  5580        if (yychar <= YYEOF)
  5581  	{
  5582  	  /* Return failure if at end of input.  */
  5583  	  if (yychar == YYEOF)
  5584  	    YYABORT;
  5585  	}
  5586        else
  5587  	{
  5588  	  yydestruct ("Error: discarding",
  5589  		      yytoken, &yylval);
  5590  	  yychar = YYEMPTY;
  5591  	}
  5592      }
  5593  
  5594    /* Else will try to reuse lookahead token after shifting the error
  5595       token.  */
  5596    goto yyerrlab1;
  5597  
  5598  
  5599  /*---------------------------------------------------.
  5600  | yyerrorlab -- error raised explicitly by YYERROR.  |
  5601  `---------------------------------------------------*/
  5602  yyerrorlab:
  5603  
  5604    /* Pacify compilers like GCC when the user code never invokes
  5605       YYERROR and the label yyerrorlab therefore never appears in user
  5606       code.  */
  5607    if (/*CONSTCOND*/ 0)
  5608       goto yyerrorlab;
  5609  
  5610    /* Do not reclaim the symbols of the rule which action triggered
  5611       this YYERROR.  */
  5612    YYPOPSTACK (yylen);
  5613    yylen = 0;
  5614    YY_STACK_PRINT (yyss, yyssp);
  5615    yystate = *yyssp;
  5616    goto yyerrlab1;
  5617  
  5618  
  5619  /*-------------------------------------------------------------.
  5620  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
  5621  `-------------------------------------------------------------*/
  5622  yyerrlab1:
  5623    yyerrstatus = 3;	/* Each real token shifted decrements this.  */
  5624  
  5625    for (;;)
  5626      {
  5627        yyn = yypact[yystate];
  5628        if (!yypact_value_is_default (yyn))
  5629  	{
  5630  	  yyn += YYTERROR;
  5631  	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
  5632  	    {
  5633  	      yyn = yytable[yyn];
  5634  	      if (0 < yyn)
  5635  		break;
  5636  	    }
  5637  	}
  5638  
  5639        /* Pop the current state because it cannot handle the error token.  */
  5640        if (yyssp == yyss)
  5641  	YYABORT;
  5642  
  5643  
  5644        yydestruct ("Error: popping",
  5645  		  yystos[yystate], yyvsp);
  5646        YYPOPSTACK (1);
  5647        yystate = *yyssp;
  5648        YY_STACK_PRINT (yyss, yyssp);
  5649      }
  5650  
  5651    *++yyvsp = yylval;
  5652  
  5653  
  5654    /* Shift the error token.  */
  5655    YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
  5656  
  5657    yystate = yyn;
  5658    goto yynewstate;
  5659  
  5660  
  5661  /*-------------------------------------.
  5662  | yyacceptlab -- YYACCEPT comes here.  |
  5663  `-------------------------------------*/
  5664  yyacceptlab:
  5665    yyresult = 0;
  5666    goto yyreturn;
  5667  
  5668  /*-----------------------------------.
  5669  | yyabortlab -- YYABORT comes here.  |
  5670  `-----------------------------------*/
  5671  yyabortlab:
  5672    yyresult = 1;
  5673    goto yyreturn;
  5674  
  5675  #if !defined(yyoverflow) || YYERROR_VERBOSE
  5676  /*-------------------------------------------------.
  5677  | yyexhaustedlab -- memory exhaustion comes here.  |
  5678  `-------------------------------------------------*/
  5679  yyexhaustedlab:
  5680    yyerror (YY_("memory exhausted"));
  5681    yyresult = 2;
  5682    /* Fall through.  */
  5683  #endif
  5684  
  5685  yyreturn:
  5686    if (yychar != YYEMPTY)
  5687      {
  5688        /* Make sure we have latest lookahead translation.  See comments at
  5689           user semantic actions for why this is necessary.  */
  5690        yytoken = YYTRANSLATE (yychar);
  5691        yydestruct ("Cleanup: discarding lookahead",
  5692                    yytoken, &yylval);
  5693      }
  5694    /* Do not reclaim the symbols of the rule which action triggered
  5695       this YYABORT or YYACCEPT.  */
  5696    YYPOPSTACK (yylen);
  5697    YY_STACK_PRINT (yyss, yyssp);
  5698    while (yyssp != yyss)
  5699      {
  5700        yydestruct ("Cleanup: popping",
  5701  		  yystos[*yyssp], yyvsp);
  5702        YYPOPSTACK (1);
  5703      }
  5704  #ifndef yyoverflow
  5705    if (yyss != yyssa)
  5706      YYSTACK_FREE (yyss);
  5707  #endif
  5708  #if YYERROR_VERBOSE
  5709    if (yymsg != yymsgbuf)
  5710      YYSTACK_FREE (yymsg);
  5711  #endif
  5712    /* Make sure YYID is used.  */
  5713    return YYID (yyresult);
  5714  }
  5715  
  5716  
  5717  
  5718  /* Line 2067 of yacc.c  */
  5719  #line 2199 "go.y"
  5720  
  5721  
  5722  static void
  5723  fixlbrace(int lbr)
  5724  {
  5725  	// If the opening brace was an LBODY,
  5726  	// set up for another one now that we're done.
  5727  	// See comment in lex.c about loophack.
  5728  	if(lbr == LBODY)
  5729  		loophack = 1;
  5730  }
  5731  
  5732