src/VTKWrapping/ParaView/vtkParse.tab.c

   1
   2 /* A Bison parser, made by GNU Bison 2.4.1.  */
   3
   4 /* Skeleton implementation for Bison's Yacc-like parsers in C
   5
   6       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   7    Free Software Foundation, Inc.
   8
   9    This program is free software: you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation, either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 /* As a special exception, you may create a larger work that contains
  23    part or all of the Bison parser skeleton and distribute that work
  24    under terms of your choice, so long as that work isn't itself a
  25    parser generator using the skeleton or a modified version thereof
  26    as a parser skeleton.  Alternatively, if you modify or redistribute
  27    the parser skeleton itself, you may (at your option) remove this
  28    special exception, which will cause the skeleton and the resulting
  29    Bison output files to be licensed under the GNU General Public
  30    License without this special exception.
  31
  32    This special exception was added by the Free Software Foundation in
  33    version 2.2 of Bison.  */
  34
  35 /* C LALR(1) parser skeleton written by Richard Stallman, by
  36    simplifying the original so-called "semantic" parser.  */
  37
  38 /* All symbols defined below should begin with yy or YY, to avoid
  39    infringing on user name space.  This should be done even for local
  40    variables, as they might otherwise be expanded by user macros.
  41    There are some unavoidable exceptions within include files to
  42    define necessary library symbols; they are noted "INFRINGES ON
  43    USER NAME SPACE" below.  */
  44
  45 /* Identify Bison output.  */
  46 #define YYBISON 1
  47
  48 /* Bison version.  */
  49 #define YYBISON_VERSION "2.4.1"
  50
  51 /* Skeleton name.  */
  52 #define YYSKELETON_NAME "yacc.c"
  53
  54 /* Pure parsers.  */
  55 #define YYPURE 0
  56
  57 /* Push parsers.  */
  58 #define YYPUSH 0
  59
  60 /* Pull parsers.  */
  61 #define YYPULL 1
  62
  63 /* Using locations.  */
  64 #define YYLSP_NEEDED 0
  65
  66
  67
  68 /* Copy the first part of user declarations.  */
  69
  70 /* Line 189 of yacc.c  */
  71 #line 15 "vtkParse.y"
  72
  73
  74 /*
  75
  76 This file must be translated to C and modified to build everywhere.
  77
  78 Run yacc like this:
  79
  80   yacc -b vtkParse vtkParse.y
  81
  82 Modify vtkParse.tab.c:
  83   - convert TABs to spaces (eight per tab)
  84   - remove spaces from ends of lines, s/ *$//g
  85   - remove the "goto yyerrlab1;" that appears right before yyerrlab1:
  86   - remove the #defined constants that appear right after the anonymous_enums
  87
  88 */
  89
  90 /*
  91 The purpose of this parser is to read C++ header files in order to
  92 generate data structures that describe the C++ interface of a library,
  93 one header file at a time.  As such, it is not a complete C++ parser.
  94 It only parses what is relevant to the interface and skips the rest.
  95
  96 While the parser reads method definitions, type definitions, and
  97 template definitions it generates a "signature" which is a string
  98 that matches (apart from whitespace) the text that was parsed.
  99
 100 While parsing types, the parser creates an unsigned int that describes
 101 the type as well as creating other data structures for arrays, function
 102 pointers, etc.  The parser also creates a typeId string, which is either
 103 a simple id that gives the class name or type name, or is "function" for
 104 function pointer types, or "method" for method pointer types.
 105 */
 106
 107 /*
 108 Conformance Notes:
 109
 110 This parser was designed empirically and incrementally.  It has been
 111 refactored to make it more similar to the ANSI C++ 1996 BNF grammar,
 112 but there are still many very significant differences.
 113
 114 The most significant difference between this parser and a "standard"
 115 parser is that it only parses declarations in detail.  All other
 116 statements and expressions are parsed as arbitrary sequences of symbols,
 117 without any syntactic analysis.
 118
 119 The "unqualified_id" does not directly include "operator_function_id" or
 120 "conversion_function_id" (e.g. ids like "operator=" or "operator int*").
 121 Instead, these two id types are used to allow operator functions to be
 122 handled by their own rules, rather than by the generic function rules.
 123 These ids can only be used in function declarations and using declarations.
 124
 125 Types are handled quite differently from the ANSI BNF.  These differences
 126 represent a prolonged (and ultimately successful) attempt to empirically
 127 create a yacc parser without any shift/reduce conflicts.  The rules for
 128 types are organized according to the way that types are usually defined
 129 in working code, rather than strictly according to C++ grammar.
 130
 131 The declaration specifiers "friend" and "typedef" can only appear at the
 132 beginning of a declaration sequence.  There are also restrictions on
 133 where class and enum specifiers can be used: you can declare a new struct
 134 within a variable declaration, but not within a parameter declaration.
 135
 136 The lexer returns each of "(scope::*", "(*", "(a::b::*", etc. as single
 137 tokens.  The ANSI BNF, in contrast, would consider these to be a "("
 138 followed by a "ptr_operator".  The lexer concatenates these tokens in
 139 order to eliminate shift/reduce conflicts in the parser.  However, this
 140 means that this parser will only recognize "scope::*" as valid if it is
 141 preceded by "(", e.g. as part of a member function pointer specification.
 142
 143 An odd bit of C++ ambiguity is that y(x); can be interpreted variously
 144 as declaration of variable "x" of type "y", as a function call if "y"
 145 is the name of a function, or as a constructor if "y" is the name of
 146 a class.  This parser always interprets this pattern as a constructor
 147 declaration, because function calls are ignored by the parser, and
 148 variable declarations of the form y(x); are exceedingly rare compared
 149 to the more usual form y x; without parentheses.
 150 */
 151
 152 #include <stdio.h>
 153 #include <stdlib.h>
 154 #include <string.h>
 155 #define yyerror(a) fprintf(stderr,"%s\n",a)
 156 #define yywrap() 1
 157
 158 /* Make sure yacc-generated code knows we have included stdlib.h.  */
 159 #ifndef _STDLIB_H
 160 # define _STDLIB_H
 161 #endif
 162 #define YYINCLUDED_STDLIB_H
 163
 164 /* Borland and MSVC do not define __STDC__ properly. */
 165 #if !defined(__STDC__)
 166 # if (defined(_MSC_VER) && _MSC_VER >= 1200) || defined(__BORLANDC__)
 167 #  define __STDC__ 1
 168 # endif
 169 #endif
 170
 171 /* Disable warnings in generated code. */
 172 #if defined(_MSC_VER)
 173 # pragma warning (disable: 4127) /* conditional expression is constant */
 174 # pragma warning (disable: 4244) /* conversion to smaller integer type */
 175 #endif
 176 #if defined(__BORLANDC__)
 177 # pragma warn -8004 /* assigned a value that is never used */
 178 # pragma warn -8008 /* conditional is always true */
 179 # pragma warn -8066 /* unreachable code */
 180 #endif
 181
 182 /* Map from the type anonymous_enumeration in vtkType.h to the
 183    VTK wrapping type system number for the type. */
 184
 185 #include "vtkParse.h"
 186 #include "vtkParsePreprocess.h"
 187 #include "vtkParseData.h"
 188 #include "vtkType.h"
 189
 190 static unsigned int vtkParseTypeMap[] =
 191   {
 192   VTK_PARSE_VOID,               /* VTK_VOID                0 */
 193   0,                            /* VTK_BIT                 1 */
 194   VTK_PARSE_CHAR,               /* VTK_CHAR                2 */
 195   VTK_PARSE_UNSIGNED_CHAR,      /* VTK_UNSIGNED_CHAR       3 */
 196   VTK_PARSE_SHORT,              /* VTK_SHORT               4 */
 197   VTK_PARSE_UNSIGNED_SHORT,     /* VTK_UNSIGNED_SHORT      5 */
 198   VTK_PARSE_INT,                /* VTK_INT                 6 */
 199   VTK_PARSE_UNSIGNED_INT,       /* VTK_UNSIGNED_INT        7 */
 200   VTK_PARSE_LONG,               /* VTK_LONG                8 */
 201   VTK_PARSE_UNSIGNED_LONG,      /* VTK_UNSIGNED_LONG       9 */
 202   VTK_PARSE_FLOAT,              /* VTK_FLOAT              10 */
 203   VTK_PARSE_DOUBLE,             /* VTK_DOUBLE             11 */
 204   VTK_PARSE_ID_TYPE,            /* VTK_ID_TYPE            12 */
 205   VTK_PARSE_STRING,             /* VTK_STRING             13 */
 206   0,                            /* VTK_OPAQUE             14 */
 207   VTK_PARSE_SIGNED_CHAR,        /* VTK_SIGNED_CHAR        15 */
 208   VTK_PARSE_LONG_LONG,          /* VTK_LONG_LONG          16 */
 209   VTK_PARSE_UNSIGNED_LONG_LONG, /* VTK_UNSIGNED_LONG_LONG 17 */
 210   VTK_PARSE___INT64,            /* VTK___INT64            18 */
 211   VTK_PARSE_UNSIGNED___INT64,   /* VTK_UNSIGNED___INT64   19 */
 212   0,                            /* VTK_VARIANT            20 */
 213   0,                            /* VTK_OBJECT             21 */
 214   VTK_PARSE_UNICODE_STRING      /* VTK_UNICODE_STRING     22 */
 215   };
 216
 217 /* Define some constants to simplify references to the table lookup in
 218    the primitive_type production rule code.  */
 219 #define VTK_PARSE_INT8 vtkParseTypeMap[VTK_TYPE_INT8]
 220 #define VTK_PARSE_UINT8 vtkParseTypeMap[VTK_TYPE_UINT8]
 221 #define VTK_PARSE_INT16 vtkParseTypeMap[VTK_TYPE_INT16]
 222 #define VTK_PARSE_UINT16 vtkParseTypeMap[VTK_TYPE_UINT16]
 223 #define VTK_PARSE_INT32 vtkParseTypeMap[VTK_TYPE_INT32]
 224 #define VTK_PARSE_UINT32 vtkParseTypeMap[VTK_TYPE_UINT32]
 225 #define VTK_PARSE_INT64 vtkParseTypeMap[VTK_TYPE_INT64]
 226 #define VTK_PARSE_UINT64 vtkParseTypeMap[VTK_TYPE_UINT64]
 227 #define VTK_PARSE_FLOAT32 vtkParseTypeMap[VTK_TYPE_FLOAT32]
 228 #define VTK_PARSE_FLOAT64 vtkParseTypeMap[VTK_TYPE_FLOAT64]
 229
 230 #define vtkParseDebug(s1, s2) \
 231   if ( parseDebug ) { fprintf(stderr, "   %s %s\n", s1, s2); }
 232
 233 /* the tokenizer */
 234 int yylex(void);
 235
 236 /* global variables */
 237 FileInfo      *data = NULL;
 238 int            parseDebug;
 239
 240 /* the "preprocessor" */
 241 PreprocessInfo *preprocessor = NULL;
 242
 243 /* include dirs specified on the command line */
 244 int            NumberOfIncludeDirectories= 0;
 245 const char   **IncludeDirectories;
 246
 247 /* macros specified on the command line */
 248 int            NumberOfDefinitions = 0;
 249 const char   **Definitions;
 250
 251 /* options that can be set by the programs that use the parser */
 252 int            IgnoreBTX = 0;
 253 int            Recursive = 0;
 254
 255 /* various state variables */
 256 NamespaceInfo *currentNamespace = NULL;
 257 ClassInfo     *currentClass = NULL;
 258 FunctionInfo  *currentFunction = NULL;
 259 TemplateInfo  *currentTemplate = NULL;
 260 const char    *currentEnumName = NULL;
 261 const char    *currentEnumValue = NULL;
 262 parse_access_t access_level = VTK_ACCESS_PUBLIC;
 263
 264 /* functions from vtkParse.l */
 265 void print_parser_error(const char *text, const char *cp, size_t n);
 266
 267 /* helper functions */
 268 const char *type_class(unsigned int type, const char *classname);
 269 void start_class(const char *classname, int is_struct_or_union);
 270 void reject_class(const char *classname, int is_struct_or_union);
 271 void end_class();
 272 void add_base_class(ClassInfo *cls, const char *name, int access_lev,
 273                     int is_virtual);
 274 void output_friend_function(void);
 275 void output_function(void);
 276 void reject_function(void);
 277 void set_return(FunctionInfo *func, unsigned int type,
 278                 const char *typeclass, int count);
 279 void add_parameter(FunctionInfo *func, unsigned int type,
 280                    const char *classname, int count);
 281 void add_template_parameter(unsigned int datatype,
 282                             unsigned int extra, const char *funcSig);
 283 void add_using(const char *name, int is_namespace);
 284 void start_enum(const char *enumname);
 285 void add_enum(const char *name, const char *value);
 286 void end_enum();
 287 unsigned int guess_constant_type(const char *value);
 288 void add_constant(const char *name, const char *value,
 289                   unsigned int type, const char *typeclass, int global);
 290 const char *add_const_scope(const char *name);
 291 void prepend_scope(char *cp, const char *arg);
 292 unsigned int guess_id_type(const char *cp);
 293 unsigned int add_indirection(unsigned int tval, unsigned int ptr);
 294 unsigned int add_indirection_to_array(unsigned int ptr);
 295 void handle_complex_type(ValueInfo *val, unsigned int datatype,
 296                          unsigned int extra, const char *funcSig);
 297 void handle_function_type(ValueInfo *param, const char *name,
 298                           const char *funcSig);
 299 void add_legacy_parameter(FunctionInfo *func, ValueInfo *param);
 300
 301 void outputSetVectorMacro(const char *var, unsigned int paramType,
 302                           const char *typeText, int n);
 303 void outputGetVectorMacro(const char *var, unsigned int paramType,
 304                           const char *typeText, int n);
 305
 306 /*----------------------------------------------------------------
 307  * String utility methods
 308  *
 309  * Strings are centrally allocated and are const, and they are not
 310  * freed until the program exits.  If they need to be freed before
 311  * then, vtkParse_FreeStringCache() can be called.
 312  */
 313
 314 /* duplicate the first n bytes of a string and terminate */
 315 static const char *vtkstrndup(const char *in, size_t n)
 316 {
 317   return vtkParse_CacheString(data->Strings, in, n);
 318 }
 319
 320 /* duplicate a string */
 321 static const char *vtkstrdup(const char *in)
 322 {
 323   if (in)
 324     {
 325     in = vtkParse_CacheString(data->Strings, in, strlen(in));
 326     }
 327
 328   return in;
 329 }
 330
 331 /* helper function for concatenating strings */
 332 static const char *vtkstrncat(size_t n, const char **str)
 333 {
 334   char *cp;
 335   size_t i;
 336   size_t j[8];
 337   size_t m = 0;
 338
 339   for (i = 0; i < n; i++)
 340     {
 341     j[i] = 0;
 342     if (str[i])
 343       {
 344       j[i] = strlen(str[i]);
 345       m += j[i];
 346       }
 347     }
 348   cp = vtkParse_NewString(data->Strings, m);
 349   m = 0;
 350   for (i = 0; i < n; i++)
 351     {
 352     if (j[i])
 353       {
 354       strncpy(&cp[m], str[i], j[i]);
 355       m += j[i];
 356       }
 357     }
 358   cp[m] = '\0';
 359
 360   return cp;
 361 }
 362
 363 /* concatenate strings */
 364 static const char *vtkstrcat(const char *str1, const char *str2)
 365 {
 366   const char *cp[2];
 367
 368   cp[0] = str1;
 369   cp[1] = str2;
 370   return vtkstrncat(2, cp);
 371 }
 372
 373 static const char *vtkstrcat3(const char *str1, const char *str2,
 374                               const char *str3)
 375 {
 376   const char *cp[3];
 377
 378   cp[0] = str1;
 379   cp[1] = str2;
 380   cp[2] = str3;
 381   return vtkstrncat(3, cp);
 382 }
 383
 384 static const char *vtkstrcat4(const char *str1, const char *str2,
 385                               const char *str3, const char *str4)
 386 {
 387   const char *cp[4];
 388
 389   cp[0] = str1;
 390   cp[1] = str2;
 391   cp[2] = str3;
 392   cp[3] = str4;
 393   return vtkstrncat(4, cp);
 394 }
 395
 396 static const char *vtkstrcat5(const char *str1, const char *str2,
 397                               const char *str3, const char *str4,
 398                               const char *str5)
 399 {
 400   const char *cp[5];
 401
 402   cp[0] = str1;
 403   cp[1] = str2;
 404   cp[2] = str3;
 405   cp[3] = str4;
 406   cp[4] = str5;
 407   return vtkstrncat(5, cp);
 408 }
 409
 410 static const char *vtkstrcat7(const char *str1, const char *str2,
 411                               const char *str3, const char *str4,
 412                               const char *str5, const char *str6,
 413                               const char *str7)
 414 {
 415   const char *cp[7];
 416
 417   cp[0] = str1;
 418   cp[1] = str2;
 419   cp[2] = str3;
 420   cp[3] = str4;
 421   cp[4] = str5;
 422   cp[5] = str6;
 423   cp[6] = str7;
 424   return vtkstrncat(7, cp);
 425 }
 426
 427 static size_t vtkidlen(const char *text)
 428 {
 429   size_t i = 0;
 430   char c = text[0];
 431
 432   if ((c >= 'a' && c <= 'z') ||
 433       (c >= 'A' && c <= 'Z') ||
 434        c == '_')
 435     {
 436     do
 437       {
 438       c = text[++i];
 439       }
 440     while ((c >= 'a' && c <= 'z') ||
 441            (c >= 'A' && c <= 'Z') ||
 442            (c >= '0' && c <= '9') ||
 443            c == '_');
 444     }
 445
 446   return i;
 447 }
 448
 449 /*----------------------------------------------------------------
 450  * Comments
 451  */
 452
 453 /* "private" variables */
 454 char          *commentText = NULL;
 455 size_t         commentLength = 0;
 456 size_t         commentAllocatedLength = 0;
 457 int            commentState = 0;
 458
 459 const char *getComment()
 460 {
 461   if (commentState != 0)
 462     {
 463     return commentText;
 464     }
 465   return NULL;
 466 }
 467
 468 void clearComment()
 469 {
 470   commentLength = 0;
 471   if (commentText)
 472     {
 473     commentText[commentLength] = '\0';
 474     }
 475   commentState = 0;
 476 }
 477
 478 void addCommentLine(const char *line, size_t n)
 479 {
 480   if (commentState <= 0)
 481     {
 482     clearComment();
 483     return;
 484     }
 485
 486   if (commentText == NULL)
 487     {
 488     commentAllocatedLength = n+80;
 489     commentText = (char *)malloc(commentAllocatedLength);
 490     commentLength = 0;
 491     commentText[0] = '\0';
 492     }
 493   else if (commentLength + n + 2 > commentAllocatedLength)
 494     {
 495     commentAllocatedLength = commentAllocatedLength + commentLength + n + 2;
 496     commentText = (char *)realloc(commentText, commentAllocatedLength);
 497     }
 498
 499   if (n > 0)
 500     {
 501     memcpy(&commentText[commentLength], line, n);
 502     }
 503   commentLength += n;
 504   commentText[commentLength++] = '\n';
 505   commentText[commentLength] = '\0';
 506 }
 507
 508 void closeComment()
 509 {
 510   switch (commentState)
 511     {
 512     case 1:
 513       /* Make comment persist until a new comment starts */
 514       commentState = -1;
 515       break;
 516     case 2:
 517       data->Description = vtkstrdup(getComment());
 518       clearComment();
 519       break;
 520     case 3:
 521       data->SeeAlso = vtkstrdup(getComment());
 522       clearComment();
 523       break;
 524     case 4:
 525       data->Caveats = vtkstrdup(getComment());
 526       clearComment();
 527       break;
 528     }
 529 }
 530
 531 void closeOrClearComment()
 532 {
 533   if (commentState < 0)
 534     {
 535     clearComment();
 536     }
 537   else
 538     {
 539     closeComment();
 540     }
 541 }
 542
 543 void setCommentState(int state)
 544 {
 545   switch (state)
 546     {
 547     case 0:
 548       closeComment();
 549       break;
 550     default:
 551       closeComment();
 552       clearComment();
 553       break;
 554     }
 555
 556   commentState = state;
 557 }
 558
 559
 560 /*----------------------------------------------------------------
 561  * Macros
 562  */
 563
 564 /* "private" variables */
 565 const char *macroName = NULL;
 566 int macroUsed = 0;
 567 int macroEnded = 0;
 568
 569 const char *getMacro()
 570 {
 571   if (macroUsed == 0)
 572     {
 573     macroUsed = macroEnded;
 574     return macroName;
 575     }
 576   return NULL;
 577 }
 578
 579
 580 /*----------------------------------------------------------------
 581  * Namespaces
 582  *
 583  * operates on: currentNamespace
 584  */
 585
 586 /* "private" variables */
 587 NamespaceInfo *namespaceStack[10];
 588 int namespaceDepth = 0;
 589
 590 /* enter a namespace */
 591 void pushNamespace(const char *name)
 592 {
 593   int i;
 594   NamespaceInfo *oldNamespace = currentNamespace;
 595
 596   for (i = 0; i < oldNamespace->NumberOfNamespaces; i++)
 597     {
 598     /* see if the namespace already exists */
 599     if (strcmp(name, oldNamespace->Namespaces[i]->Name) == 0)
 600       {
 601       currentNamespace = oldNamespace->Namespaces[i];
 602       }
 603     }
 604
 605   /* create a new namespace */
 606   if (i == oldNamespace->NumberOfNamespaces)
 607     {
 608     currentNamespace = (NamespaceInfo *)malloc(sizeof(NamespaceInfo));
 609     vtkParse_InitNamespace(currentNamespace);
 610     currentNamespace->Name = name;
 611     vtkParse_AddNamespaceToNamespace(oldNamespace, currentNamespace);
 612     }
 613
 614   namespaceStack[namespaceDepth++] = oldNamespace;
 615 }
 616
 617 /* leave the namespace */
 618 void popNamespace()
 619 {
 620   currentNamespace = namespaceStack[--namespaceDepth];
 621 }
 622
 623
 624 /*----------------------------------------------------------------
 625  * Classes
 626  *
 627  * operates on: currentClass, access_level
 628  */
 629
 630 /* "private" variables */
 631 ClassInfo *classStack[10];
 632 parse_access_t classAccessStack[10];
 633 int classDepth = 0;
 634
 635 /* start an internal class definition */
 636 void pushClass()
 637 {
 638   classAccessStack[classDepth] = access_level;
 639   classStack[classDepth++] = currentClass;
 640 }
 641
 642 /* leave the internal class */
 643 void popClass()
 644 {
 645   currentClass = classStack[--classDepth];
 646   access_level = classAccessStack[classDepth];
 647 }
 648
 649
 650 /*----------------------------------------------------------------
 651  * Templates
 652  *
 653  * operates on: currentTemplate
 654  */
 655
 656 /* "private" variables */
 657 TemplateInfo *templateStack[10];
 658 int templateDepth = 0;
 659
 660 /* begin a template */
 661 void startTemplate()
 662 {
 663   currentTemplate = (TemplateInfo *)malloc(sizeof(TemplateInfo));
 664   vtkParse_InitTemplate(currentTemplate);
 665 }
 666
 667 /* clear a template, if set */
 668 void clearTemplate()
 669 {
 670   if (currentTemplate)
 671     {
 672     free(currentTemplate);
 673     }
 674   currentTemplate = NULL;
 675 }
 676
 677 /* push the template onto the stack, and start a new one */
 678 void pushTemplate()
 679 {
 680   templateStack[templateDepth++] = currentTemplate;
 681   startTemplate();
 682 }
 683
 684 /* pop a template off the stack */
 685 void popTemplate()
 686 {
 687   currentTemplate = templateStack[--templateDepth];
 688 }
 689
 690 /*----------------------------------------------------------------
 691  * Function signatures
 692  *
 693  * operates on: currentFunction
 694  */
 695
 696 /* "private" variables */
 697 int sigClosed = 0;
 698 size_t sigMark[10];
 699 size_t sigLength = 0;
 700 size_t sigAllocatedLength = 0;
 701 int sigMarkDepth = 0;
 702 char *signature = NULL;
 703
 704 /* start a new signature */
 705 void startSig()
 706 {
 707   signature = NULL;
 708   sigLength = 0;
 709   sigAllocatedLength = 0;
 710   sigClosed = 0;
 711   sigMarkDepth = 0;
 712   sigMark[0] = 0;
 713 }
 714
 715 /* get the signature */
 716 const char *getSig()
 717 {
 718   return signature;
 719 }
 720
 721 /* get the signature length */
 722 size_t getSigLength()
 723 {
 724   return sigLength;
 725 }
 726
 727 /* reset the sig to the specified length */
 728 void resetSig(size_t n)
 729 {
 730   if (n < sigLength)
 731     {
 732     sigLength = n;
 733     }
 734 }
 735
 736 /* reallocate Signature if n chars cannot be appended */
 737 void checkSigSize(size_t n)
 738 {
 739   const char *ccp;
 740
 741   if (sigAllocatedLength == 0)
 742     {
 743     sigLength = 0;
 744     sigAllocatedLength = 80 + n;
 745     signature = vtkParse_NewString(data->Strings, sigAllocatedLength);
 746     signature[0] = '\0';
 747     }
 748   else if (sigLength + n > sigAllocatedLength)
 749     {
 750     sigAllocatedLength += sigLength + n;
 751     ccp = signature;
 752     signature = vtkParse_NewString(data->Strings, sigAllocatedLength);
 753     strncpy(signature, ccp, sigLength);
 754     signature[sigLength] = '\0';
 755     }
 756 }
 757
 758 /* close the signature, i.e. allow no more additions to it */
 759 void closeSig()
 760 {
 761   sigClosed = 1;
 762 }
 763
 764 /* re-open the signature */
 765 void openSig()
 766 {
 767   sigClosed = 0;
 768 }
 769
 770 /* insert text at the beginning of the signature */
 771 void preSig(const char *arg)
 772 {
 773   if (!sigClosed)
 774     {
 775     size_t n = strlen(arg);
 776     checkSigSize(n);
 777     if (n > 0)
 778       {
 779       memmove(&signature[n], signature, sigLength);
 780       strncpy(signature, arg, n);
 781       sigLength += n;
 782       }
 783     signature[sigLength] = '\0';
 784     }
 785 }
 786
 787 /* append text to the end of the signature */
 788 void postSig(const char *arg)
 789 {
 790   if (!sigClosed)
 791     {
 792     size_t n = strlen(arg);
 793     checkSigSize(n);
 794     if (n > 0)
 795       {
 796       strncpy(&signature[sigLength], arg, n);
 797       sigLength += n;
 798       }
 799     signature[sigLength] = '\0';
 800     }
 801 }
 802
 803 /* set a mark in the signature for later operations */
 804 void markSig()
 805 {
 806   sigMark[sigMarkDepth] = 0;
 807   if (signature)
 808     {
 809     sigMark[sigMarkDepth] = sigLength;
 810     }
 811   sigMarkDepth++;
 812 }
 813
 814 /* get the contents of the sig from the mark, and clear the mark */
 815 const char *copySig()
 816 {
 817   const char *cp = NULL;
 818   if (sigMarkDepth > 0)
 819     {
 820     sigMarkDepth--;
 821     }
 822   if (signature)
 823     {
 824     cp = &signature[sigMark[sigMarkDepth]];
 825     }
 826   return vtkstrdup(cp);
 827 }
 828
 829 /* swap the signature text using the mark as the radix */
 830 void swapSig()
 831 {
 832   if (sigMarkDepth > 0)
 833     {
 834     sigMarkDepth--;
 835     }
 836   if (signature && sigMark[sigMarkDepth] > 0)
 837     {
 838     size_t i, m, n, nn;
 839     char c;
 840     char *cp;
 841     cp = signature;
 842     n = sigLength;
 843     m = sigMark[sigMarkDepth];
 844     nn = m/2;
 845     for (i = 0; i < nn; i++)
 846       {
 847       c = cp[i]; cp[i] = cp[m-i-1]; cp[m-i-1] = c;
 848       }
 849     nn = (n-m)/2;
 850     for (i = 0; i < nn; i++)
 851       {
 852       c = cp[i+m]; cp[i+m] = cp[n-i-1]; cp[n-i-1] = c;
 853       }
 854     nn = n/2;
 855     for (i = 0; i < nn; i++)
 856       {
 857       c = cp[i]; cp[i] = cp[n-i-1]; cp[n-i-1] = c;
 858       }
 859     }
 860 }
 861
 862 /* chop the last space from the signature */
 863 void chopSig(void)
 864 {
 865   if (signature)
 866     {
 867     size_t n = sigLength;
 868     if (n > 0 && signature[n-1] == ' ')
 869       {
 870       signature[n-1] = '\0';
 871       sigLength--;
 872       }
 873     }
 874 }
 875
 876 /*----------------------------------------------------------------
 877  * Subroutines for building a type
 878  */
 879
 880 /* "private" variables */
 881 unsigned int storedType;
 882 unsigned int typeStack[10];
 883 int typeDepth = 0;
 884
 885 /* save the type on the stack */
 886 void pushType()
 887 {
 888   typeStack[typeDepth++] = storedType;
 889 }
 890
 891 /* pop the type stack */
 892 void popType()
 893 {
 894   storedType = typeStack[--typeDepth];
 895 }
 896
 897 /* clear the storage type */
 898 void clearType()
 899 {
 900   storedType = 0;
 901 }
 902
 903 /* save the type */
 904 void setTypeBase(unsigned int base)
 905 {
 906   storedType &= ~(unsigned int)(VTK_PARSE_BASE_TYPE);
 907   storedType |= base;
 908 }
 909
 910 /* set a type modifier bit */
 911 void setTypeMod(unsigned int mod)
 912 {
 913   storedType |= mod;
 914 }
 915
 916 /* modify the indirection (pointers, refs) in the storage type */
 917 void setTypePtr(unsigned int ind)
 918 {
 919   storedType &= ~(unsigned int)(VTK_PARSE_INDIRECT);
 920   ind &= VTK_PARSE_INDIRECT;
 921   storedType |= ind;
 922 }
 923
 924 /* retrieve the storage type */
 925 unsigned int getType()
 926 {
 927   return storedType;
 928 }
 929
 930 /* combine two primitive type parts, e.g. "long int" */
 931 unsigned int buildTypeBase(unsigned int a, unsigned int b)
 932 {
 933   unsigned int base = (a & VTK_PARSE_BASE_TYPE);
 934   unsigned int basemod = (b & VTK_PARSE_BASE_TYPE);
 935
 936   switch (base)
 937     {
 938     case 0:
 939       base = basemod;
 940       break;
 941     case VTK_PARSE_UNSIGNED_INT:
 942       base = (basemod | VTK_PARSE_UNSIGNED);
 943       break;
 944     case VTK_PARSE_INT:
 945       base = basemod;
 946       if (base == VTK_PARSE_CHAR)
 947         {
 948         base = VTK_PARSE_SIGNED_CHAR;
 949         }
 950       break;
 951     case VTK_PARSE_CHAR:
 952       if (basemod == VTK_PARSE_INT)
 953         {
 954         base = VTK_PARSE_SIGNED_CHAR;
 955         }
 956       else if (basemod == VTK_PARSE_UNSIGNED_INT)
 957         {
 958         base = VTK_PARSE_UNSIGNED_CHAR;
 959         }
 960       break;
 961     case VTK_PARSE_SHORT:
 962       if (basemod == VTK_PARSE_UNSIGNED_INT)
 963         {
 964         base = VTK_PARSE_UNSIGNED_SHORT;
 965         }
 966       break;
 967     case VTK_PARSE_LONG:
 968       if (basemod == VTK_PARSE_UNSIGNED_INT)
 969         {
 970         base = VTK_PARSE_UNSIGNED_LONG;
 971         }
 972       else if (basemod == VTK_PARSE_LONG)
 973         {
 974         base = VTK_PARSE_LONG_LONG;
 975         }
 976       else if (basemod == VTK_PARSE_DOUBLE)
 977         {
 978         base = VTK_PARSE_LONG_DOUBLE;
 979         }
 980       break;
 981     case VTK_PARSE_UNSIGNED_LONG:
 982       if (basemod == VTK_PARSE_LONG)
 983         {
 984         base = VTK_PARSE_UNSIGNED_LONG_LONG;
 985         }
 986       break;
 987     case VTK_PARSE_LONG_LONG:
 988       if (basemod == VTK_PARSE_UNSIGNED_INT)
 989         {
 990         base = VTK_PARSE_UNSIGNED_LONG_LONG;
 991         }
 992       break;
 993     case VTK_PARSE___INT64:
 994       if (basemod == VTK_PARSE_UNSIGNED_INT)
 995         {
 996         base = VTK_PARSE_UNSIGNED___INT64;
 997         }
 998       break;
 999     case VTK_PARSE_DOUBLE:
1000       if (basemod == VTK_PARSE_LONG)
1001         {
1002         base = VTK_PARSE_LONG_DOUBLE;
1003         }
1004       break;
1005     }
1006
1007   return ((a & ~(unsigned int)(VTK_PARSE_BASE_TYPE)) | base);
1008 }
1009
1010
1011 /*----------------------------------------------------------------
1012  * Array information
1013  */
1014
1015 /* "private" variables */
1016 int numberOfDimensions = 0;
1017 const char **arrayDimensions = NULL;
1018
1019 /* clear the array counter */
1020 void clearArray(void)
1021 {
1022   numberOfDimensions = 0;
1023   arrayDimensions = NULL;
1024 }
1025
1026 /* add another dimension */
1027 void pushArraySize(const char *size)
1028 {
1029   vtkParse_AddStringToArray(&arrayDimensions, &numberOfDimensions,
1030                             size);
1031 }
1032
1033 /* add another dimension to the front */
1034 void pushArrayFront(const char *size)
1035 {
1036   int i;
1037
1038   vtkParse_AddStringToArray(&arrayDimensions, &numberOfDimensions, 0);
1039
1040   for (i = numberOfDimensions-1; i > 0; i--)
1041     {
1042     arrayDimensions[i] = arrayDimensions[i-1];
1043     }
1044
1045   arrayDimensions[0] = size;
1046 }
1047
1048 /* get the number of dimensions */
1049 int getArrayNDims()
1050 {
1051   return numberOfDimensions;
1052 }
1053
1054 /* get the whole array */
1055 const char **getArray()
1056 {
1057   if (numberOfDimensions > 0)
1058     {
1059     return arrayDimensions;
1060     }
1061   return NULL;
1062 }
1063
1064 /*----------------------------------------------------------------
1065  * Variables and Parameters
1066  */
1067
1068 /* "private" variables */
1069 const char *currentVarName = 0;
1070 const char *currentVarValue = 0;
1071 const char *currentId = 0;
1072
1073 /* clear the var Id */
1074 void clearVarName(void)
1075 {
1076   currentVarName = NULL;
1077 }
1078
1079 /* set the var Id */
1080 void setVarName(const char *text)
1081 {
1082   currentVarName = text;
1083 }
1084
1085 /* return the var id */
1086 const char *getVarName()
1087 {
1088   return currentVarName;
1089 }
1090
1091 /* variable value -------------- */
1092
1093 /* clear the var value */
1094 void clearVarValue(void)
1095 {
1096   currentVarValue = NULL;
1097 }
1098
1099 /* set the var value */
1100 void setVarValue(const char *text)
1101 {
1102   currentVarValue = text;
1103 }
1104
1105 /* return the var value */
1106 const char *getVarValue()
1107 {
1108   return currentVarValue;
1109 }
1110
1111 /* variable type -------------- */
1112
1113 /* clear the current Id */
1114 void clearTypeId(void)
1115 {
1116   currentId = NULL;
1117 }
1118
1119 /* set the current Id, it is sticky until cleared */
1120 void setTypeId(const char *text)
1121 {
1122   if (currentId == NULL)
1123     {
1124     currentId = text;
1125     }
1126 }
1127
1128 /* set the signature and type together */
1129 void typeSig(const char *text)
1130 {
1131   postSig(text);
1132   postSig(" ");
1133
1134   if (currentId == 0)
1135     {
1136     setTypeId(text);
1137     }
1138 }
1139
1140 /* return the current Id */
1141 const char *getTypeId()
1142 {
1143   return currentId;
1144 }
1145
1146 /*----------------------------------------------------------------
1147  * Specifically for function pointers, the scope (i.e. class) that
1148  * the function is a method of.
1149  */
1150
1151 const char *pointerScopeStack[10];
1152 int pointerScopeDepth = 0;
1153
1154 /* save the scope for scoped method pointers */
1155 void scopeSig(const char *scope)
1156 {
1157   if (scope && scope[0] != '\0')
1158     {
1159     postSig(scope);
1160     }
1161   else
1162     {
1163     scope = NULL;
1164     }
1165   pointerScopeStack[pointerScopeDepth++] = vtkstrdup(scope);
1166 }
1167
1168 /* get the scope back */
1169 const char *getScope()
1170 {
1171   return pointerScopeStack[--pointerScopeDepth];
1172 }
1173
1174 /*----------------------------------------------------------------
1175  * Function stack
1176  *
1177  * operates on: currentFunction
1178  */
1179
1180 /* "private" variables */
1181 FunctionInfo *functionStack[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1182 const char *functionVarNameStack[10];
1183 const char *functionTypeIdStack[10];
1184 int functionDepth = 0;
1185
1186 void pushFunction()
1187 {
1188   functionStack[functionDepth] = currentFunction;
1189   currentFunction = (FunctionInfo *)malloc(sizeof(FunctionInfo));
1190   vtkParse_InitFunction(currentFunction);
1191   if (!functionStack[functionDepth])
1192     {
1193     startSig();
1194     }
1195   functionVarNameStack[functionDepth] = getVarName();
1196   functionTypeIdStack[functionDepth] = getTypeId();
1197   pushType();
1198   clearType();
1199   clearVarName();
1200   clearTypeId();
1201   functionDepth++;
1202   functionStack[functionDepth] = 0;
1203 }
1204
1205 void popFunction()
1206 {
1207   FunctionInfo *newFunction = currentFunction;
1208
1209   --functionDepth;
1210   currentFunction = functionStack[functionDepth];
1211   clearVarName();
1212   if (functionVarNameStack[functionDepth])
1213     {
1214     setVarName(functionVarNameStack[functionDepth]);
1215     }
1216   clearTypeId();
1217   if (functionTypeIdStack[functionDepth])
1218     {
1219     setTypeId(functionTypeIdStack[functionDepth]);
1220     }
1221   popType();
1222
1223   functionStack[functionDepth+1] = newFunction;
1224 }
1225
1226 FunctionInfo *getFunction()
1227 {
1228   return functionStack[functionDepth+1];
1229 }
1230
1231 /*----------------------------------------------------------------
1232  * Utility methods
1233  */
1234
1235 /* prepend a scope:: to a name */
1236 void prepend_scope(char *cp, const char *arg)
1237 {
1238   size_t i, j, m, n;
1239   int depth;
1240
1241   m = strlen(cp);
1242   n = strlen(arg);
1243   i = m;
1244   while (i > 0 &&
1245          ((cp[i-1] >= 'a' && cp[i-1] <= 'z') ||
1246           (cp[i-1] >= 'A' && cp[i-1] <= 'Z') ||
1247           (cp[i-1] >= '0' && cp[i-1] <= '9') ||
1248           cp[i-1] == '_' || cp[i-1] == ':' ||
1249           cp[i-1] == '>'))
1250     {
1251     i--;
1252     if (cp[i] == '>')
1253       {
1254       depth = 1;
1255       while (i > 0)
1256         {
1257         i--;
1258         if (cp[i] == '<')
1259           {
1260           if (--depth == 0)
1261             {
1262             break;
1263             }
1264           }
1265         if (cp[i] == '>')
1266           {
1267           depth++;
1268           }
1269         }
1270       }
1271     }
1272
1273   for (j = m; j > i; j--)
1274     {
1275     cp[j+n+1] = cp[j-1];
1276     }
1277   for (j = 0; j < n; j++)
1278     {
1279     cp[j+i] = arg[j];
1280     }
1281   cp[n+i] = ':'; cp[n+i+1] = ':';
1282   cp[m+n+2] = '\0';
1283 }
1284
1285 /* expand a type by including pointers from another */
1286 unsigned int add_indirection(unsigned int type1, unsigned int type2)
1287 {
1288   unsigned int ptr1 = (type1 & VTK_PARSE_POINTER_MASK);
1289   unsigned int ptr2 = (type2 & VTK_PARSE_POINTER_MASK);
1290   unsigned int reverse = 0;
1291   unsigned int result;
1292
1293   /* one of type1 or type2 will only have VTK_PARSE_INDIRECT, but
1294    * we don't know which one. */
1295   result = ((type1 & ~VTK_PARSE_POINTER_MASK) |
1296             (type2 & ~VTK_PARSE_POINTER_MASK));
1297
1298   while (ptr2)
1299     {
1300     reverse = ((reverse << 2) | (ptr2 & VTK_PARSE_POINTER_LOWMASK));
1301     ptr2 = ((ptr2 >> 2) & VTK_PARSE_POINTER_MASK);
1302     }
1303
1304   while (reverse)
1305     {
1306     ptr1 = ((ptr1 << 2) | (reverse & VTK_PARSE_POINTER_LOWMASK));
1307     reverse = ((reverse >> 2) & VTK_PARSE_POINTER_MASK);
1308
1309     /* make sure we don't exceed the VTK_PARSE_POINTER bitfield */
1310     if ((ptr1 & VTK_PARSE_POINTER_MASK) != ptr1)
1311       {
1312       ptr1 = VTK_PARSE_BAD_INDIRECT;
1313       break;
1314       }
1315     }
1316
1317   return (ptr1 | result);
1318 }
1319
1320 /* There is only one array, so add any parenthetical indirection to it */
1321 unsigned int add_indirection_to_array(unsigned int type)
1322 {
1323   unsigned int ptrs = (type & VTK_PARSE_POINTER_MASK);
1324   unsigned int result = (type & ~VTK_PARSE_POINTER_MASK);
1325   unsigned int reverse = 0;
1326
1327   if ((type & VTK_PARSE_INDIRECT) == VTK_PARSE_BAD_INDIRECT)
1328     {
1329     return (result | VTK_PARSE_BAD_INDIRECT);
1330     }
1331
1332   while (ptrs)
1333     {
1334     reverse = ((reverse << 2) | (ptrs & VTK_PARSE_POINTER_LOWMASK));
1335     ptrs = ((ptrs >> 2) & VTK_PARSE_POINTER_MASK);
1336     }
1337
1338   /* I know the reversal makes no difference, but it is still
1339    * nice to add the pointers in the correct order, just in
1340    * case const pointers are thrown into the mix. */
1341   while (reverse)
1342     {
1343     pushArrayFront("");
1344     reverse = ((reverse >> 2) & VTK_PARSE_POINTER_MASK);
1345     }
1346
1347   return result;
1348 }
1349
1350
1351
1352 /* Line 189 of yacc.c  */
1353 #line 1354 "vtkParse.tab.c"
1354
1355 /* Enabling traces.  */
1356 #ifndef YYDEBUG
1357 # define YYDEBUG 0
1358 #endif
1359
1360 /* Enabling verbose error messages.  */
1361 #ifdef YYERROR_VERBOSE
1362 # undef YYERROR_VERBOSE
1363 # define YYERROR_VERBOSE 1
1364 #else
1365 # define YYERROR_VERBOSE 0
1366 #endif
1367
1368 /* Enabling the token table.  */
1369 #ifndef YYTOKEN_TABLE
1370 # define YYTOKEN_TABLE 0
1371 #endif
1372
1373
1374 /* Tokens.  */
1375 #ifndef YYTOKENTYPE
1376 # define YYTOKENTYPE
1377    /* Put the tokens into the symbol table, so that GDB and other debuggers
1378       know about them.  */
1379    enum yytokentype {
1380      ID = 258,
1381      VTK_ID = 259,
1382      QT_ID = 260,
1383      StdString = 261,
1384      UnicodeString = 262,
1385      OSTREAM = 263,
1386      ISTREAM = 264,
1387      LP = 265,
1388      LA = 266,
1389      STRING_LITERAL = 267,
1390      INT_LITERAL = 268,
1391      HEX_LITERAL = 269,
1392      OCT_LITERAL = 270,
1393      FLOAT_LITERAL = 271,
1394      CHAR_LITERAL = 272,
1395      ZERO = 273,
1396      STRUCT = 274,
1397      CLASS = 275,
1398      UNION = 276,
1399      ENUM = 277,
1400      PUBLIC = 278,
1401      PRIVATE = 279,
1402      PROTECTED = 280,
1403      CONST = 281,
1404      VOLATILE = 282,
1405      MUTABLE = 283,
1406      STATIC = 284,
1407      VIRTUAL = 285,
1408      EXPLICIT = 286,
1409      INLINE = 287,
1410      FRIEND = 288,
1411      EXTERN = 289,
1412      OPERATOR = 290,
1413      TEMPLATE = 291,
1414      THROW = 292,
1415      TYPENAME = 293,
1416      TYPEDEF = 294,
1417      NAMESPACE = 295,
1418      USING = 296,
1419      NEW = 297,
1420      DELETE = 298,
1421      STATIC_CAST = 299,
1422      DYNAMIC_CAST = 300,
1423      CONST_CAST = 301,
1424      REINTERPRET_CAST = 302,
1425      OP_LSHIFT_EQ = 303,
1426      OP_RSHIFT_EQ = 304,
1427      OP_LSHIFT = 305,
1428      OP_RSHIFT = 306,
1429      OP_DOT_POINTER = 307,
1430      OP_ARROW_POINTER = 308,
1431      OP_ARROW = 309,
1432      OP_INCR = 310,
1433      OP_DECR = 311,
1434      OP_PLUS_EQ = 312,
1435      OP_MINUS_EQ = 313,
1436      OP_TIMES_EQ = 314,
1437      OP_DIVIDE_EQ = 315,
1438      OP_REMAINDER_EQ = 316,
1439      OP_AND_EQ = 317,
1440      OP_OR_EQ = 318,
1441      OP_XOR_EQ = 319,
1442      OP_LOGIC_AND = 320,
1443      OP_LOGIC_OR = 321,
1444      OP_LOGIC_EQ = 322,
1445      OP_LOGIC_NEQ = 323,
1446      OP_LOGIC_LEQ = 324,
1447      OP_LOGIC_GEQ = 325,
1448      ELLIPSIS = 326,
1449      DOUBLE_COLON = 327,
1450      OTHER = 328,
1451      VOID = 329,
1452      BOOL = 330,
1453      FLOAT = 331,
1454      DOUBLE = 332,
1455      INT = 333,
1456      SHORT = 334,
1457      LONG = 335,
1458      INT64__ = 336,
1459      CHAR = 337,
1460      SIGNED = 338,
1461      UNSIGNED = 339,
1462      SSIZE_T = 340,
1463      SIZE_T = 341,
1464      IdType = 342,
1465      TypeInt8 = 343,
1466      TypeUInt8 = 344,
1467      TypeInt16 = 345,
1468      TypeUInt16 = 346,
1469      TypeInt32 = 347,
1470      TypeUInt32 = 348,
1471      TypeInt64 = 349,
1472      TypeUInt64 = 350,
1473      TypeFloat32 = 351,
1474      TypeFloat64 = 352,
1475      SetMacro = 353,
1476      GetMacro = 354,
1477      SetStringMacro = 355,
1478      GetStringMacro = 356,
1479      SetClampMacro = 357,
1480      SetObjectMacro = 358,
1481      GetObjectMacro = 359,
1482      BooleanMacro = 360,
1483      SetVector2Macro = 361,
1484      SetVector3Macro = 362,
1485      SetVector4Macro = 363,
1486      SetVector6Macro = 364,
1487      GetVector2Macro = 365,
1488      GetVector3Macro = 366,
1489      GetVector4Macro = 367,
1490      GetVector6Macro = 368,
1491      SetVectorMacro = 369,
1492      GetVectorMacro = 370,
1493      ViewportCoordinateMacro = 371,
1494      WorldCoordinateMacro = 372,
1495      TypeMacro = 373,
1496      VTK_BYTE_SWAP_DECL = 374
1497    };
1498 #endif
1499
1500
1501
1502
1503 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1504 typedef union YYSTYPE
1505 {
1506
1507 /* Line 222 of yacc.c  */
1508 #line 1302 "vtkParse.y"
1509
1510   const char   *str;
1511   unsigned int  integer;
1512
1513
1514
1515 /* Line 222 of yacc.c  */
1516 #line 1635 "vtkParse.tab.c"
1517 } YYSTYPE;
1518 # define YYSTYPE_IS_TRIVIAL 1
1519 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1520 # define YYSTYPE_IS_DECLARED 1
1521 #endif
1522
1523
1524 /* Copy the second part of user declarations.  */
1525
1526
1527 /* Line 264 of yacc.c  */
1528 #line 1647 "vtkParse.tab.c"
1529
1530 #ifdef short
1531 # undef short
1532 #endif
1533
1534 #ifdef YYTYPE_UINT8
1535 typedef YYTYPE_UINT8 yytype_uint8;
1536 #else
1537 typedef unsigned char yytype_uint8;
1538 #endif
1539
1540 #ifdef YYTYPE_INT8
1541 typedef YYTYPE_INT8 yytype_int8;
1542 #elif (defined __STDC__ || defined __C99__FUNC__ \
1543      || defined __cplusplus || defined _MSC_VER)
1544 typedef signed char yytype_int8;
1545 #else
1546 typedef short int yytype_int8;
1547 #endif
1548
1549 #ifdef YYTYPE_UINT16
1550 typedef YYTYPE_UINT16 yytype_uint16;
1551 #else
1552 typedef unsigned short int yytype_uint16;
1553 #endif
1554
1555 #ifdef YYTYPE_INT16
1556 typedef YYTYPE_INT16 yytype_int16;
1557 #else
1558 typedef short int yytype_int16;
1559 #endif
1560
1561 #ifndef YYSIZE_T
1562 # ifdef __SIZE_TYPE__
1563 #  define YYSIZE_T __SIZE_TYPE__
1564 # elif defined size_t
1565 #  define YYSIZE_T size_t
1566 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
1567      || defined __cplusplus || defined _MSC_VER)
1568 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1569 #  define YYSIZE_T size_t
1570 # else
1571 #  define YYSIZE_T unsigned int
1572 # endif
1573 #endif
1574
1575 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
1576
1577 #ifndef YY_
1578 # if YYENABLE_NLS
1579 #  if ENABLE_NLS
1580 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1581 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
1582 #  endif
1583 # endif
1584 # ifndef YY_
1585 #  define YY_(msgid) msgid
1586 # endif
1587 #endif
1588
1589 /* Suppress unused-variable warnings by "using" E.  */
1590 #if ! defined lint || defined __GNUC__
1591 # define YYUSE(e) ((void) (e))
1592 #else
1593 # define YYUSE(e) /* empty */
1594 #endif
1595
1596 /* Identity function, used to suppress warnings about constant conditions.  */
1597 #ifndef lint
1598 # define YYID(n) (n)
1599 #else
1600 #if (defined __STDC__ || defined __C99__FUNC__ \
1601      || defined __cplusplus || defined _MSC_VER)
1602 static int
1603 YYID (int yyi)
1604 #else
1605 static int
1606 YYID (yyi)
1607     int yyi;
1608 #endif
1609 {
1610   return yyi;
1611 }
1612 #endif
1613
1614 #if ! defined yyoverflow || YYERROR_VERBOSE
1615
1616 /* The parser invokes alloca or malloc; define the necessary symbols.  */
1617
1618 # ifdef YYSTACK_USE_ALLOCA
1619 #  if YYSTACK_USE_ALLOCA
1620 #   ifdef __GNUC__
1621 #    define YYSTACK_ALLOC __builtin_alloca
1622 #   elif defined __BUILTIN_VA_ARG_INCR
1623 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1624 #   elif defined _AIX
1625 #    define YYSTACK_ALLOC __alloca
1626 #   elif defined _MSC_VER
1627 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1628 #    define alloca _alloca
1629 #   else
1630 #    define YYSTACK_ALLOC alloca
1631 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1632      || defined __cplusplus || defined _MSC_VER)
1633 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1634 #     ifndef _STDLIB_H
1635 #      define _STDLIB_H 1
1636 #     endif
1637 #    endif
1638 #   endif
1639 #  endif
1640 # endif
1641
1642 # ifdef YYSTACK_ALLOC
1643    /* Pacify GCC's `empty if-body' warning.  */
1644 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1645 #  ifndef YYSTACK_ALLOC_MAXIMUM
1646     /* The OS might guarantee only one guard page at the bottom of the stack,
1647        and a page size can be as small as 4096 bytes.  So we cannot safely
1648        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
1649        to allow for a few compiler-allocated temporary stack slots.  */
1650 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1651 #  endif
1652 # else
1653 #  define YYSTACK_ALLOC YYMALLOC
1654 #  define YYSTACK_FREE YYFREE
1655 #  ifndef YYSTACK_ALLOC_MAXIMUM
1656 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1657 #  endif
1658 #  if (defined __cplusplus && ! defined _STDLIB_H \
1659        && ! ((defined YYMALLOC || defined malloc) \
1660              && (defined YYFREE || defined free)))
1661 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1662 #   ifndef _STDLIB_H
1663 #    define _STDLIB_H 1
1664 #   endif
1665 #  endif
1666 #  ifndef YYMALLOC
1667 #   define YYMALLOC malloc
1668 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1669      || defined __cplusplus || defined _MSC_VER)
1670 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1671 #   endif
1672 #  endif
1673 #  ifndef YYFREE
1674 #   define YYFREE free
1675 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1676      || defined __cplusplus || defined _MSC_VER)
1677 void free (void *); /* INFRINGES ON USER NAME SPACE */
1678 #   endif
1679 #  endif
1680 # endif
1681 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1682
1683
1684 #if (! defined yyoverflow \
1685      && (! defined __cplusplus \
1686          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1687
1688 /* A type that is properly aligned for any stack member.  */
1689 union yyalloc
1690 {
1691   yytype_int16 yyss_alloc;
1692   YYSTYPE yyvs_alloc;
1693 };
1694
1695 /* The size of the maximum gap between one aligned stack and the next.  */
1696 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1697
1698 /* The size of an array large to enough to hold all stacks, each with
1699    N elements.  */
1700 # define YYSTACK_BYTES(N) \
1701      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1702       + YYSTACK_GAP_MAXIMUM)
1703
1704 /* Copy COUNT objects from FROM to TO.  The source and destination do
1705    not overlap.  */
1706 # ifndef YYCOPY
1707 #  if defined __GNUC__ && 1 < __GNUC__
1708 #   define YYCOPY(To, From, Count) \
1709       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1710 #  else
1711 #   define YYCOPY(To, From, Count)                \
1712       do                                        \
1713         {                                        \
1714           YYSIZE_T yyi;                                \
1715           for (yyi = 0; yyi < (Count); yyi++)        \
1716             (To)[yyi] = (From)[yyi];                \
1717         }                                        \
1718       while (YYID (0))
1719 #  endif
1720 # endif
1721
1722 /* Relocate STACK from its old location to the new one.  The
1723    local variables YYSIZE and YYSTACKSIZE give the old and new number of
1724    elements in the stack, and YYPTR gives the new location of the
1725    stack.  Advance YYPTR to a properly aligned location for the next
1726    stack.  */
1727 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                                \
1728     do                                                                        \
1729       {                                                                        \
1730         YYSIZE_T yynewbytes;                                                \
1731         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                        \
1732         Stack = &yyptr->Stack_alloc;                                        \
1733         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1734         yyptr += yynewbytes / sizeof (*yyptr);                                \
1735       }                                                                        \
1736     while (YYID (0))
1737
1738 #endif
1739
1740 /* YYFINAL -- State number of the termination state.  */
1741 #define YYFINAL  3
1742 /* YYLAST -- Last index in YYTABLE.  */
1743 #define YYLAST   5657
1744
1745 /* YYNTOKENS -- Number of terminals.  */
1746 #define YYNTOKENS  143
1747 /* YYNNTS -- Number of nonterminals.  */
1748 #define YYNNTS  240
1749 /* YYNRULES -- Number of rules.  */
1750 #define YYNRULES  603
1751 /* YYNRULES -- Number of states.  */
1752 #define YYNSTATES  968
1753
1754 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1755 #define YYUNDEFTOK  2
1756 #define YYMAXUTOK   374
1757
1758 #define YYTRANSLATE(YYX)                                                \
1759   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1760
1761 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
1762 static const yytype_uint8 yytranslate[] =
1763 {
1764        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1765        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1766        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1767        2,     2,     2,   139,     2,     2,     2,   135,   133,     2,
1768      126,   127,   134,   138,   125,   137,   142,   136,     2,     2,
1769        2,     2,     2,     2,     2,     2,     2,     2,   124,   120,
1770      128,   123,   129,     2,     2,     2,     2,     2,     2,     2,
1771        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1772        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1773        2,   130,     2,   131,   141,     2,     2,     2,     2,     2,
1774        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1775        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1776        2,     2,     2,   121,   140,   122,   132,     2,     2,     2,
1777        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1778        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1779        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1780        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1781        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1782        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1783        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1784        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1785        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1786        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1787        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1788        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1789        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1790        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1791       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1792       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1793       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1794       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1795       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
1796       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
1797       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
1798       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
1799       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
1800      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
1801      115,   116,   117,   118,   119
1802 };
1803
1804 #if YYDEBUG
1805 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1806    YYRHS.  */
1807 static const yytype_uint16 yyprhs[] =
1808 {
1809        0,     0,     3,     5,     6,     7,    11,    13,    15,    17,
1810       19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
1811       40,    42,    45,    48,    51,    54,    60,    65,    66,    73,
1812       79,    81,    84,    88,    93,    98,   104,   105,   111,   112,
1813      117,   118,   122,   124,   126,   128,   129,   130,   134,   138,
1814      140,   142,   144,   146,   148,   150,   152,   154,   156,   158,
1815      160,   162,   164,   167,   170,   172,   175,   178,   181,   185,
1816      188,   192,   193,   195,   198,   200,   204,   206,   210,   214,
1817      215,   217,   218,   220,   222,   224,   226,   231,   237,   238,
1818      244,   247,   249,   250,   252,   254,   257,   261,   263,   264,
1819      269,   276,   280,   285,   288,   292,   298,   302,   304,   307,
1820      313,   319,   326,   332,   339,   342,   343,   347,   350,   352,
1821      354,   355,   356,   364,   366,   370,   372,   375,   378,   381,
1822      385,   389,   394,   398,   399,   405,   407,   408,   413,   414,
1823      415,   421,   422,   423,   429,   430,   431,   432,   440,   442,
1824      444,   445,   447,   448,   452,   454,   457,   460,   463,   466,
1825      469,   472,   476,   479,   483,   486,   490,   494,   497,   501,
1826      506,   509,   511,   513,   516,   518,   521,   524,   525,   526,
1827      534,   537,   538,   542,   543,   549,   552,   554,   557,   558,
1828      561,   562,   566,   568,   571,   575,   577,   578,   584,   586,
1829      588,   589,   590,   596,   597,   603,   604,   607,   609,   613,
1830      616,   617,   618,   621,   623,   624,   629,   633,   634,   635,
1831      641,   642,   644,   645,   649,   654,   657,   658,   661,   662,
1832      663,   668,   671,   672,   674,   677,   678,   684,   687,   688,
1833      694,   696,   698,   700,   702,   704,   705,   706,   707,   714,
1834      716,   717,   720,   723,   727,   729,   732,   734,   737,   738,
1835      740,   742,   746,   748,   750,   752,   753,   755,   756,   759,
1836      761,   764,   765,   770,   771,   772,   775,   777,   779,   781,
1837      783,   786,   789,   792,   795,   798,   802,   806,   807,   813,
1838      815,   817,   818,   824,   826,   828,   830,   832,   834,   836,
1839      838,   841,   844,   847,   850,   853,   856,   859,   861,   863,
1840      865,   867,   869,   871,   873,   875,   877,   879,   881,   883,
1841      885,   887,   889,   891,   893,   895,   897,   899,   900,   903,
1842      905,   907,   909,   911,   913,   916,   918,   920,   922,   924,
1843      926,   929,   931,   933,   935,   937,   939,   941,   943,   946,
1844      949,   950,   954,   955,   960,   962,   963,   967,   969,   971,
1845      974,   977,   980,   981,   985,   986,   991,   993,   995,   997,
1846     1000,  1003,  1006,  1008,  1010,  1012,  1014,  1016,  1018,  1020,
1847     1022,  1024,  1026,  1028,  1030,  1032,  1034,  1036,  1038,  1040,
1848     1042,  1044,  1046,  1048,  1050,  1052,  1054,  1056,  1058,  1060,
1849     1062,  1064,  1066,  1068,  1070,  1072,  1074,  1076,  1079,  1081,
1850     1083,  1084,  1088,  1090,  1093,  1094,  1102,  1103,  1104,  1105,
1851     1115,  1116,  1122,  1123,  1129,  1130,  1131,  1142,  1143,  1151,
1852     1152,  1153,  1154,  1164,  1171,  1172,  1180,  1181,  1189,  1190,
1853     1198,  1199,  1207,  1208,  1216,  1217,  1225,  1226,  1234,  1235,
1854     1243,  1244,  1254,  1255,  1265,  1270,  1275,  1283,  1284,  1286,
1855     1289,  1292,  1296,  1300,  1302,  1304,  1306,  1308,  1310,  1312,
1856     1314,  1316,  1318,  1320,  1322,  1324,  1326,  1328,  1330,  1332,
1857     1334,  1336,  1338,  1340,  1342,  1344,  1346,  1348,  1350,  1352,
1858     1354,  1356,  1358,  1360,  1362,  1364,  1366,  1368,  1370,  1372,
1859     1374,  1376,  1378,  1380,  1382,  1384,  1386,  1388,  1390,  1392,
1860     1394,  1396,  1398,  1400,  1402,  1404,  1406,  1408,  1410,  1412,
1861     1414,  1416,  1418,  1420,  1422,  1424,  1426,  1428,  1430,  1432,
1862     1434,  1436,  1438,  1440,  1443,  1445,  1447,  1449,  1451,  1453,
1863     1455,  1457,  1459,  1461,  1463,  1465,  1466,  1469,  1471,  1473,
1864     1475,  1477,  1479,  1481,  1483,  1485,  1486,  1489,  1490,  1493,
1865     1495,  1497,  1499,  1501,  1503,  1504,  1509,  1510,  1515,  1516,
1866     1521,  1522,  1527,  1528,  1533,  1534,  1539,  1540,  1543,  1544,
1867     1547,  1549,  1551,  1553,  1555,  1557,  1559,  1561,  1563,  1565,
1868     1567,  1569,  1571,  1573,  1575,  1577,  1579,  1581,  1583,  1587,
1869     1591,  1595,  1597,  1599
1870 };
1871
1872 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1873 static const yytype_int16 yyrhs[] =
1874 {
1875      144,     0,    -1,   145,    -1,    -1,    -1,   145,   146,   147,
1876       -1,   198,    -1,   196,    -1,   153,    -1,   150,    -1,   152,
1877       -1,   149,    -1,   186,    -1,   259,    -1,   175,    -1,   155,
1878       -1,   216,    -1,   148,    -1,   327,    -1,   289,   120,    -1,
1879      120,    -1,   199,   155,    -1,   199,   216,    -1,   199,   183,
1880       -1,   199,   148,    -1,    34,    12,   121,   145,   122,    -1,
1881       40,   121,   375,   122,    -1,    -1,    40,   299,   151,   121,
1882      145,   122,    -1,    40,   299,   123,   291,   120,    -1,   154,
1883       -1,   199,   154,    -1,   161,   289,   120,    -1,   302,   161,
1884      289,   120,    -1,   156,   300,   261,   120,    -1,   302,   156,
1885      300,   261,   120,    -1,    -1,   158,   157,   121,   162,   122,
1886       -1,    -1,   161,   289,   159,   168,    -1,    -1,   161,   160,
1887      168,    -1,    20,    -1,    19,    -1,    21,    -1,    -1,    -1,
1888      162,   163,   165,    -1,   162,   164,   124,    -1,    23,    -1,
1889       24,    -1,    25,    -1,   196,    -1,   153,    -1,   167,    -1,
1890      186,    -1,   259,    -1,   175,    -1,   155,    -1,   220,    -1,
1891      166,    -1,   327,    -1,   119,   381,    -1,   289,   120,    -1,
1892      120,    -1,   199,   155,    -1,   199,   220,    -1,    33,   184,
1893       -1,    33,   199,   184,    -1,    33,   153,    -1,    33,   221,
1894      237,    -1,    -1,   169,    -1,   124,   170,    -1,   171,    -1,
1895      170,   125,   171,    -1,   289,    -1,    30,   173,   289,    -1,
1896      174,   172,   289,    -1,    -1,    30,    -1,    -1,   174,    -1,
1897       23,    -1,    24,    -1,    25,    -1,   176,   300,   261,   120,
1898       -1,   302,   176,   300,   261,   120,    -1,    -1,   178,   121,
1899      177,   179,   122,    -1,    22,   289,    -1,    22,    -1,    -1,
1900      180,    -1,   181,    -1,   180,   125,    -1,   180,   125,   181,
1901       -1,   298,    -1,    -1,   298,   123,   182,   355,    -1,   308,
1902      292,   298,   123,   376,   120,    -1,   161,   289,   185,    -1,
1903      302,   161,   289,   185,    -1,   161,   185,    -1,   302,   161,
1904      185,    -1,   121,   375,   122,   376,   120,    -1,   124,   376,
1905      120,    -1,   187,    -1,   302,   187,    -1,    39,   308,   195,
1906      189,   120,    -1,    39,   156,   300,   188,   120,    -1,    39,
1907      302,   156,   300,   188,   120,    -1,    39,   176,   300,   188,
1908      120,    -1,    39,   302,   176,   300,   188,   120,    -1,   190,
1909      189,    -1,    -1,   189,   125,   190,    -1,   265,   195,    -1,
1910      268,    -1,   192,    -1,    -1,    -1,   279,   126,   193,   249,
1911      127,   194,   275,    -1,   191,    -1,    41,   197,   120,    -1,
1912      289,    -1,    38,   289,    -1,   292,   231,    -1,   292,   226,
1913       -1,   295,   292,   231,    -1,   295,   292,   226,    -1,    41,
1914       40,   289,   120,    -1,    36,   128,   129,    -1,    -1,    36,
1915      128,   200,   201,   129,    -1,   203,    -1,    -1,   201,   125,
1916      202,   203,    -1,    -1,    -1,   204,   314,   266,   205,   212,
1917       -1,    -1,    -1,   206,   211,   266,   207,   212,    -1,    -1,
1918       -1,    -1,   208,   199,    20,   209,   266,   210,   212,    -1,
1919       20,    -1,    38,    -1,    -1,   213,    -1,    -1,   123,   214,
1920      215,    -1,   363,    -1,   215,   363,    -1,   217,   237,    -1,
1921      222,   237,    -1,   218,   237,    -1,   219,   237,    -1,   308,
1922      233,    -1,   308,   292,   233,    -1,   292,   241,    -1,   302,
1923      292,   241,    -1,   292,   223,    -1,   302,   292,   223,    -1,
1924      308,   292,   227,    -1,   221,   237,    -1,   292,   231,   120,
1925       -1,   302,   292,   231,   120,    -1,   308,   233,    -1,   222,
1926       -1,   241,    -1,   302,   241,    -1,   223,    -1,   302,   223,
1927       -1,   308,   227,    -1,    -1,    -1,   226,   126,   224,   249,
1928      127,   225,   234,    -1,   232,   308,    -1,    -1,   229,   228,
1929      234,    -1,    -1,   231,   126,   230,   249,   127,    -1,   232,
1930      351,    -1,    35,    -1,   238,   234,    -1,    -1,   234,   235,
1931       -1,    -1,    37,   236,   369,    -1,    26,    -1,   123,    18,
1932       -1,   121,   375,   122,    -1,   120,    -1,    -1,   240,   126,
1933      239,   249,   127,    -1,   298,    -1,   296,    -1,    -1,    -1,
1934      244,   242,   246,   243,   234,    -1,    -1,   240,   126,   245,
1935      249,   127,    -1,    -1,   124,   247,    -1,   248,    -1,   247,
1936      125,   248,    -1,   289,   381,    -1,    -1,    -1,   250,   251,
1937       -1,   253,    -1,    -1,   251,   125,   252,   253,    -1,   251,
1938      125,    71,    -1,    -1,    -1,   254,   308,   266,   255,   256,
1939       -1,    -1,   257,    -1,    -1,   123,   258,   355,    -1,   308,
1940      260,   262,   120,    -1,   268,   256,    -1,    -1,   264,   262,
1941       -1,    -1,    -1,   262,   125,   263,   264,    -1,   265,   260,
1942       -1,    -1,   322,    -1,   278,   281,    -1,    -1,   270,   276,
1943      127,   267,   272,    -1,   279,   281,    -1,    -1,   271,   277,
1944      127,   269,   272,    -1,   126,    -1,    10,    -1,    11,    -1,
1945       10,    -1,    11,    -1,    -1,    -1,    -1,   126,   273,   249,
1946      127,   274,   275,    -1,   282,    -1,    -1,   275,    28,    -1,
1947      275,    26,    -1,   275,    37,   381,    -1,   266,    -1,   322,
1948      266,    -1,   268,    -1,   322,   268,    -1,    -1,   279,    -1,
1949      298,    -1,   298,   124,   280,    -1,    15,    -1,    13,    -1,
1950       14,    -1,    -1,   282,    -1,    -1,   283,   284,    -1,   285,
1951       -1,   284,   285,    -1,    -1,   130,   286,   287,   131,    -1,
1952       -1,    -1,   288,   355,    -1,   290,    -1,   291,    -1,   298,
1953       -1,   296,    -1,   292,   290,    -1,   295,   290,    -1,   295,
1954      291,    -1,   294,   295,    -1,   296,   295,    -1,   292,   294,
1955      295,    -1,   292,   296,   295,    -1,    -1,   292,    36,   293,
1956      296,   295,    -1,   299,    -1,    72,    -1,    -1,   299,   128,
1957      297,   361,   129,    -1,     4,    -1,     5,    -1,     3,    -1,
1958        9,    -1,     8,    -1,     6,    -1,     7,    -1,   132,     4,
1959       -1,   132,     5,    -1,   132,     3,    -1,   132,     9,    -1,
1960      132,     8,    -1,   132,     6,    -1,   132,     7,    -1,    86,
1961       -1,    85,    -1,    88,    -1,    89,    -1,    90,    -1,    91,
1962       -1,    92,    -1,    93,    -1,    94,    -1,    95,    -1,    96,
1963       -1,    97,    -1,    87,    -1,     3,    -1,     5,    -1,     4,
1964       -1,     9,    -1,     8,    -1,     6,    -1,     7,    -1,    -1,
1965      300,   301,    -1,   303,    -1,   321,    -1,    39,    -1,    33,
1966       -1,   303,    -1,   302,   303,    -1,   304,    -1,   305,    -1,
1967      306,    -1,    28,    -1,    34,    -1,    34,    12,    -1,    29,
1968       -1,    32,    -1,    30,    -1,    31,    -1,    26,    -1,    27,
1969       -1,   306,    -1,   307,   306,    -1,   309,   265,    -1,    -1,
1970      312,   310,   300,    -1,    -1,   302,   312,   311,   300,    -1,
1971      319,    -1,    -1,    38,   313,   289,    -1,   296,    -1,   291,
1972       -1,   161,   289,    -1,    22,   289,    -1,   315,   265,    -1,
1973       -1,   318,   316,   300,    -1,    -1,   302,   312,   317,   300,
1974       -1,   319,    -1,   296,    -1,   291,    -1,    19,   289,    -1,
1975       21,   289,    -1,    22,   289,    -1,   321,    -1,   320,    -1,
1976        6,    -1,     7,    -1,     8,    -1,     9,    -1,     3,    -1,
1977        4,    -1,     5,    -1,    85,    -1,    86,    -1,    88,    -1,
1978       89,    -1,    90,    -1,    91,    -1,    92,    -1,    93,    -1,
1979       94,    -1,    95,    -1,    96,    -1,    97,    -1,    87,    -1,
1980       74,    -1,    75,    -1,    76,    -1,    77,    -1,    82,    -1,
1981       78,    -1,    79,    -1,    80,    -1,    81,    -1,    83,    -1,
1982       84,    -1,   323,    -1,   326,    -1,   326,   323,    -1,   133,
1983       -1,   134,    -1,    -1,   134,   325,   307,    -1,   324,    -1,
1984      326,   324,    -1,    -1,    98,   126,   298,   125,   328,   308,
1985      127,    -1,    -1,    -1,    -1,    99,   126,   329,   298,   125,
1986      330,   308,   331,   127,    -1,    -1,   100,   126,   332,   298,
1987      127,    -1,    -1,   101,   126,   333,   298,   127,    -1,    -1,
1988       -1,   102,   126,   298,   125,   334,   308,   335,   125,   376,
1989      127,    -1,    -1,   103,   126,   298,   125,   336,   308,   127,
1990       -1,    -1,    -1,    -1,   104,   126,   337,   298,   125,   338,
1991      308,   339,   127,    -1,   105,   126,   298,   125,   308,   127,
1992       -1,    -1,   106,   126,   298,   125,   340,   308,   127,    -1,
1993       -1,   110,   126,   298,   125,   341,   308,   127,    -1,    -1,
1994      107,   126,   298,   125,   342,   308,   127,    -1,    -1,   111,
1995      126,   298,   125,   343,   308,   127,    -1,    -1,   108,   126,
1996      298,   125,   344,   308,   127,    -1,    -1,   112,   126,   298,
1997      125,   345,   308,   127,    -1,    -1,   109,   126,   298,   125,
1998      346,   308,   127,    -1,    -1,   113,   126,   298,   125,   347,
1999      308,   127,    -1,    -1,   114,   126,   298,   125,   348,   308,
2000      125,    13,   127,    -1,    -1,   115,   126,   298,   125,   349,
2001      308,   125,    13,   127,    -1,   116,   126,   298,   127,    -1,
2002      117,   126,   298,   127,    -1,   118,   126,   298,   125,   298,
2003      350,   127,    -1,    -1,   125,    -1,   126,   127,    -1,   130,
2004      131,    -1,    42,   130,   131,    -1,    43,   130,   131,    -1,
2005      128,    -1,   129,    -1,   125,    -1,   123,    -1,   352,    -1,
2006      135,    -1,   134,    -1,   136,    -1,   137,    -1,   138,    -1,
2007      139,    -1,   132,    -1,   133,    -1,   140,    -1,   141,    -1,
2008       42,    -1,    43,    -1,    48,    -1,    49,    -1,    50,    -1,
2009       51,    -1,    52,    -1,    53,    -1,    54,    -1,    57,    -1,
2010       58,    -1,    59,    -1,    60,    -1,    61,    -1,    55,    -1,
2011       56,    -1,    62,    -1,    63,    -1,    64,    -1,    65,    -1,
2012       66,    -1,    67,    -1,    68,    -1,    69,    -1,    70,    -1,
2013       39,    -1,    38,    -1,    20,    -1,    19,    -1,    21,    -1,
2014       36,    -1,    23,    -1,    25,    -1,    24,    -1,    26,    -1,
2015       29,    -1,    32,    -1,    30,    -1,    34,    -1,    40,    -1,
2016       35,    -1,    22,    -1,    37,    -1,    46,    -1,    45,    -1,
2017       44,    -1,    47,    -1,    15,    -1,    13,    -1,    14,    -1,
2018       16,    -1,    17,    -1,    12,    -1,    18,    -1,   358,    -1,
2019      355,   358,    -1,   367,    -1,   369,    -1,   373,    -1,   352,
2020       -1,   124,    -1,   142,    -1,    72,    -1,   353,    -1,   354,
2021       -1,   321,    -1,   320,    -1,    -1,   357,   359,    -1,   356,
2022       -1,   128,    -1,   129,    -1,   358,    -1,   123,    -1,   125,
2023       -1,   359,    -1,   120,    -1,    -1,   361,   364,    -1,    -1,
2024      362,   360,    -1,   365,    -1,   356,    -1,   363,    -1,   123,
2025       -1,   125,    -1,    -1,   128,   366,   361,   129,    -1,    -1,
2026      130,   368,   357,   131,    -1,    -1,   126,   370,   357,   127,
2027       -1,    -1,    10,   371,   357,   127,    -1,    -1,    11,   372,
2028      357,   127,    -1,    -1,   121,   374,   362,   122,    -1,    -1,
2029      375,   377,    -1,    -1,   376,   378,    -1,   378,    -1,   120,
2030       -1,   379,    -1,   381,    -1,   380,    -1,    72,    -1,    71,
2031       -1,   352,    -1,   124,    -1,   142,    -1,   128,    -1,   129,
2032       -1,   123,    -1,   125,    -1,   353,    -1,   354,    -1,   319,
2033       -1,    73,    -1,   121,   375,   122,    -1,   130,   375,   131,
2034       -1,   382,   375,   127,    -1,   126,    -1,    10,    -1,    11,
2035       -1
2036 };
2037
2038 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
2039 static const yytype_uint16 yyrline[] =
2040 {
2041        0,  1460,  1460,  1462,  1464,  1463,  1474,  1475,  1476,  1477,
2042     1478,  1479,  1480,  1481,  1482,  1483,  1484,  1485,  1486,  1487,
2043     1488,  1491,  1492,  1493,  1494,  1501,  1508,  1509,  1509,  1513,
2044     1520,  1521,  1524,  1525,  1528,  1529,  1532,  1532,  1546,  1546,
2045     1548,  1548,  1552,  1553,  1554,  1556,  1558,  1557,  1566,  1570,
2046     1571,  1572,  1575,  1576,  1577,  1578,  1579,  1580,  1581,  1582,
2047     1583,  1584,  1585,  1586,  1587,  1590,  1591,  1594,  1595,  1596,
2048     1597,  1599,  1600,  1603,  1606,  1607,  1610,  1612,  1614,  1618,
2049     1619,  1622,  1623,  1626,  1627,  1628,  1639,  1640,  1644,  1644,
2050     1657,  1658,  1660,  1661,  1664,  1665,  1666,  1669,  1670,  1670,
2051     1678,  1681,  1682,  1683,  1684,  1687,  1688,  1696,  1697,  1700,
2052     1701,  1703,  1705,  1707,  1711,  1713,  1714,  1717,  1720,  1721,
2053     1724,  1725,  1724,  1729,  1763,  1766,  1767,  1768,  1770,  1772,
2054     1774,  1778,  1785,  1788,  1787,  1805,  1807,  1806,  1811,  1813,
2055     1811,  1815,  1817,  1815,  1819,  1820,  1822,  1819,  1833,  1834,
2056     1836,  1837,  1840,  1840,  1850,  1851,  1859,  1860,  1861,  1862,
2057     1865,  1868,  1869,  1870,  1873,  1874,  1875,  1878,  1879,  1880,
2058     1883,  1884,  1885,  1886,  1889,  1890,  1891,  1895,  1899,  1894,
2059     1911,  1915,  1915,  1926,  1925,  1934,  1938,  1941,  1950,  1951,
2060     1954,  1954,  1955,  1956,  1964,  1965,  1969,  1968,  1976,  1977,
2061     1985,  1986,  1985,  2004,  2004,  2007,  2008,  2011,  2012,  2015,
2062     2021,  2022,  2022,  2025,  2026,  2026,  2028,  2032,  2034,  2032,
2063     2058,  2059,  2062,  2062,  2070,  2073,  2132,  2133,  2135,  2136,
2064     2136,  2139,  2142,  2143,  2147,  2148,  2148,  2167,  2168,  2168,
2065     2186,  2187,  2189,  2193,  2195,  2198,  2199,  2200,  2199,  2205,
2066     2207,  2208,  2209,  2210,  2213,  2214,  2218,  2219,  2223,  2224,
2067     2227,  2228,  2231,  2232,  2233,  2236,  2237,  2240,  2240,  2243,
2068     2244,  2247,  2247,  2250,  2251,  2251,  2258,  2259,  2262,  2263,
2069     2266,  2268,  2270,  2274,  2276,  2278,  2280,  2282,  2282,  2287,
2070     2290,  2293,  2293,  2308,  2309,  2310,  2311,  2312,  2313,  2314,
2071     2315,  2316,  2317,  2318,  2319,  2320,  2321,  2322,  2323,  2324,
2072     2325,  2326,  2327,  2328,  2329,  2330,  2331,  2332,  2333,  2334,
2073     2341,  2342,  2343,  2344,  2345,  2346,  2347,  2354,  2355,  2358,
2074     2359,  2361,  2362,  2365,  2366,  2369,  2370,  2371,  2374,  2375,
2075     2376,  2377,  2380,  2381,  2382,  2385,  2386,  2389,  2390,  2399,
2076     2402,  2402,  2404,  2404,  2408,  2409,  2409,  2411,  2413,  2415,
2077     2417,  2421,  2424,  2424,  2426,  2426,  2430,  2431,  2433,  2435,
2078     2437,  2439,  2443,  2444,  2447,  2448,  2449,  2450,  2451,  2452,
2079     2453,  2454,  2455,  2456,  2457,  2458,  2459,  2460,  2461,  2462,
2080     2463,  2464,  2465,  2466,  2469,  2470,  2471,  2472,  2473,  2474,
2081     2475,  2476,  2477,  2478,  2479,  2499,  2500,  2501,  2504,  2507,
2082     2508,  2508,  2523,  2524,  2541,  2541,  2551,  2552,  2552,  2551,
2083     2561,  2561,  2571,  2571,  2580,  2580,  2580,  2613,  2612,  2623,
2084     2624,  2624,  2623,  2633,  2651,  2651,  2656,  2656,  2661,  2661,
2085     2666,  2666,  2671,  2671,  2676,  2676,  2681,  2681,  2686,  2686,
2086     2691,  2691,  2708,  2708,  2722,  2759,  2797,  2834,  2835,  2842,
2087     2843,  2844,  2845,  2846,  2847,  2848,  2849,  2850,  2853,  2854,
2088     2855,  2856,  2857,  2858,  2859,  2860,  2861,  2862,  2863,  2864,
2089     2865,  2866,  2867,  2868,  2869,  2870,  2871,  2872,  2873,  2874,
2090     2875,  2876,  2877,  2878,  2879,  2880,  2881,  2882,  2883,  2884,
2091     2885,  2886,  2887,  2890,  2891,  2892,  2893,  2894,  2895,  2896,
2092     2897,  2898,  2899,  2900,  2901,  2902,  2903,  2904,  2905,  2906,
2093     2907,  2908,  2909,  2910,  2911,  2914,  2915,  2916,  2917,  2918,
2094     2919,  2920,  2927,  2928,  2931,  2932,  2933,  2934,  2965,  2965,
2095     2966,  2967,  2968,  2969,  2970,  2993,  2994,  2996,  2997,  2998,
2096     3000,  3001,  3002,  3004,  3005,  3007,  3008,  3010,  3011,  3014,
2097     3015,  3018,  3019,  3020,  3024,  3023,  3037,  3037,  3041,  3041,
2098     3043,  3043,  3045,  3045,  3049,  3049,  3054,  3055,  3057,  3058,
2099     3061,  3062,  3065,  3066,  3067,  3068,  3069,  3070,  3071,  3071,
2100     3071,  3071,  3071,  3071,  3072,  3072,  3073,  3074,  3077,  3080,
2101     3083,  3086,  3086,  3086
2102 };
2103 #endif
2104
2105 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
2106 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2107    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
2108 static const char *const yytname[] =
2109 {
2110   "$end", "error", "$undefined", "ID", "VTK_ID", "QT_ID", "StdString",
2111   "UnicodeString", "OSTREAM", "ISTREAM", "LP", "LA", "STRING_LITERAL",
2112   "INT_LITERAL", "HEX_LITERAL", "OCT_LITERAL", "FLOAT_LITERAL",
2113   "CHAR_LITERAL", "ZERO", "STRUCT", "CLASS", "UNION", "ENUM", "PUBLIC",
2114   "PRIVATE", "PROTECTED", "CONST", "VOLATILE", "MUTABLE", "STATIC",
2115   "VIRTUAL", "EXPLICIT", "INLINE", "FRIEND", "EXTERN", "OPERATOR",
2116   "TEMPLATE", "THROW", "TYPENAME", "TYPEDEF", "NAMESPACE", "USING", "NEW",
2117   "DELETE", "STATIC_CAST", "DYNAMIC_CAST", "CONST_CAST",
2118   "REINTERPRET_CAST", "OP_LSHIFT_EQ", "OP_RSHIFT_EQ", "OP_LSHIFT",
2119   "OP_RSHIFT", "OP_DOT_POINTER", "OP_ARROW_POINTER", "OP_ARROW", "OP_INCR",
2120   "OP_DECR", "OP_PLUS_EQ", "OP_MINUS_EQ", "OP_TIMES_EQ", "OP_DIVIDE_EQ",
2121   "OP_REMAINDER_EQ", "OP_AND_EQ", "OP_OR_EQ", "OP_XOR_EQ", "OP_LOGIC_AND",
2122   "OP_LOGIC_OR", "OP_LOGIC_EQ", "OP_LOGIC_NEQ", "OP_LOGIC_LEQ",
2123   "OP_LOGIC_GEQ", "ELLIPSIS", "DOUBLE_COLON", "OTHER", "VOID", "BOOL",
2124   "FLOAT", "DOUBLE", "INT", "SHORT", "LONG", "INT64__", "CHAR", "SIGNED",
2125   "UNSIGNED", "SSIZE_T", "SIZE_T", "IdType", "TypeInt8", "TypeUInt8",
2126   "TypeInt16", "TypeUInt16", "TypeInt32", "TypeUInt32", "TypeInt64",
2127   "TypeUInt64", "TypeFloat32", "TypeFloat64", "SetMacro", "GetMacro",
2128   "SetStringMacro", "GetStringMacro", "SetClampMacro", "SetObjectMacro",
2129   "GetObjectMacro", "BooleanMacro", "SetVector2Macro", "SetVector3Macro",
2130   "SetVector4Macro", "SetVector6Macro", "GetVector2Macro",
2131   "GetVector3Macro", "GetVector4Macro", "GetVector6Macro",
2132   "SetVectorMacro", "GetVectorMacro", "ViewportCoordinateMacro",
2133   "WorldCoordinateMacro", "TypeMacro", "VTK_BYTE_SWAP_DECL", "';'", "'{'",
2134   "'}'", "'='", "':'", "','", "'('", "')'", "'<'", "'>'", "'['", "']'",
2135   "'~'", "'&'", "'*'", "'%'", "'/'", "'-'", "'+'", "'!'", "'|'", "'^'",
2136   "'.'", "$accept", "translation_unit", "opt_declaration_seq", "$@1",
2137   "declaration", "template_declaration", "linkage_specification",
2138   "namespace_definition", "$@2", "namespace_alias_definition",
2139   "forward_declaration", "simple_forward_declaration", "class_definition",
2140   "class_specifier", "$@3", "class_head", "$@4", "$@5", "class_key",
2141   "member_specification", "$@6", "member_access_specifier",
2142   "member_declaration", "template_member_declaration",
2143   "friend_declaration", "opt_base_clause", "base_clause",
2144   "base_specifier_list", "base_specifier", "opt_virtual",
2145   "opt_access_specifier", "access_specifier", "enum_definition",
2146   "enum_specifier", "$@7", "enum_head", "opt_enumerator_list",
2147   "enumerator_list", "enumerator_definition", "$@8",
2148   "nested_variable_initialization", "ignored_class", "ignored_class_body",
2149   "typedef_declaration", "basic_typedef_declaration",
2150   "typedef_declarator_list", "typedef_declarator_list_cont",
2151   "typedef_declarator", "typedef_direct_declarator",
2152   "function_direct_declarator", "$@9", "$@10", "typedef_declarator_id",
2153   "using_declaration", "using_id", "using_directive", "template_head",
2154   "$@11", "template_parameter_list", "$@12", "template_parameter", "$@13",
2155   "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "class_or_typename",
2156   "opt_template_parameter_initializer", "template_parameter_initializer",
2157   "$@20", "template_parameter_value", "function_definition",
2158   "function_declaration", "nested_method_declaration",
2159   "nested_operator_declaration", "method_definition", "method_declaration",
2160   "operator_declaration", "conversion_function", "$@21", "$@22",
2161   "conversion_function_id", "operator_function_nr", "$@23",
2162   "operator_function_sig", "$@24", "operator_function_id", "operator_sig",
2163   "function_nr", "function_trailer_clause", "function_trailer", "$@25",
2164   "function_body", "function_sig", "$@26", "function_name",
2165   "structor_declaration", "$@27", "$@28", "structor_sig", "$@29",
2166   "opt_ctor_initializer", "mem_initializer_list", "mem_initializer",
2167   "parameter_declaration_clause", "$@30", "parameter_list", "$@31",
2168   "parameter_declaration", "$@32", "$@33", "opt_initializer",
2169   "initializer", "$@34", "variable_declaration", "init_declarator_id",
2170   "opt_declarator_list", "declarator_list_cont", "$@35", "init_declarator",
2171   "opt_ptr_operator_seq", "direct_abstract_declarator", "$@36",
2172   "direct_declarator", "$@37", "p_or_lp_or_la", "lp_or_la",
2173   "opt_array_or_parameters", "$@38", "$@39", "function_qualifiers",
2174   "abstract_declarator", "declarator", "opt_declarator_id",
2175   "declarator_id", "bitfield_size", "opt_array_decorator_seq",
2176   "array_decorator_seq", "$@40", "array_decorator_seq_impl",
2177   "array_decorator", "$@41", "array_size_specifier", "$@42",
2178   "id_expression", "unqualified_id", "qualified_id",
2179   "nested_name_specifier", "$@43", "identifier_sig", "scope_operator_sig",
2180   "template_id", "$@44", "simple_id", "identifier",
2181   "opt_decl_specifier_seq", "decl_specifier2", "decl_specifier_seq",
2182   "decl_specifier", "storage_class_specifier", "function_specifier",
2183   "cv_qualifier", "cv_qualifier_seq", "store_type", "store_type_specifier",
2184   "$@45", "$@46", "type_specifier", "$@47", "tparam_type",
2185   "tparam_type_specifier2", "$@48", "$@49", "tparam_type_specifier",
2186   "simple_type_specifier", "type_name", "primitive_type",
2187   "ptr_operator_seq", "reference", "pointer", "$@50", "pointer_seq",
2188   "declaration_macro", "$@51", "$@52", "$@53", "$@54", "$@55", "$@56",
2189   "$@57", "$@58", "$@59", "$@60", "$@61", "$@62", "$@63", "$@64", "$@65",
2190   "$@66", "$@67", "$@68", "$@69", "$@70", "$@71", "$@72", "opt_comma",
2191   "operator_id", "operator_id_no_delim", "keyword", "literal",
2192   "constant_expression", "common_bracket_item", "any_bracket_contents",
2193   "bracket_pitem", "any_bracket_item", "braces_item",
2194   "angle_bracket_contents", "braces_contents", "angle_bracket_pitem",
2195   "angle_bracket_item", "angle_brackets_sig", "$@73", "brackets_sig",
2196   "$@74", "parentheses_sig", "$@75", "$@76", "$@77", "braces_sig", "$@78",
2197   "ignored_items", "ignored_expression", "ignored_item",
2198   "ignored_item_no_semi", "ignored_braces", "ignored_brackets",
2199   "ignored_parentheses", "ignored_left_parenthesis", 0
2200 };
2201 #endif
2202
2203 # ifdef YYPRINT
2204 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
2205    token YYLEX-NUM.  */
2206 static const yytype_uint16 yytoknum[] =
2207 {
2208        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
2209      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
2210      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
2211      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
2212      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
2213      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
2214      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
2215      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
2216      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
2217      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
2218      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
2219      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
2220       59,   123,   125,    61,    58,    44,    40,    41,    60,    62,
2221       91,    93,   126,    38,    42,    37,    47,    45,    43,    33,
2222      124,    94,    46
2223 };
2224 # endif
2225
2226 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
2227 static const yytype_uint16 yyr1[] =
2228 {
2229        0,   143,   144,   145,   146,   145,   147,   147,   147,   147,
2230      147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
2231      147,   148,   148,   148,   148,   149,   150,   151,   150,   152,
2232      153,   153,   154,   154,   155,   155,   157,   156,   159,   158,
2233      160,   158,   161,   161,   161,   162,   163,   162,   162,   164,
2234      164,   164,   165,   165,   165,   165,   165,   165,   165,   165,
2235      165,   165,   165,   165,   165,   166,   166,   167,   167,   167,
2236      167,   168,   168,   169,   170,   170,   171,   171,   171,   172,
2237      172,   173,   173,   174,   174,   174,   175,   175,   177,   176,
2238      178,   178,   179,   179,   180,   180,   180,   181,   182,   181,
2239      183,   184,   184,   184,   184,   185,   185,   186,   186,   187,
2240      187,   187,   187,   187,   188,   189,   189,   190,   191,   191,
2241      193,   194,   192,   195,   196,   197,   197,   197,   197,   197,
2242      197,   198,   199,   200,   199,   201,   202,   201,   204,   205,
2243      203,   206,   207,   203,   208,   209,   210,   203,   211,   211,
2244      212,   212,   214,   213,   215,   215,   216,   216,   216,   216,
2245      217,   218,   218,   218,   219,   219,   219,   220,   220,   220,
2246      221,   221,   221,   221,   222,   222,   222,   224,   225,   223,
2247      226,   228,   227,   230,   229,   231,   232,   233,   234,   234,
2248      236,   235,   235,   235,   237,   237,   239,   238,   240,   240,
2249      242,   243,   241,   245,   244,   246,   246,   247,   247,   248,
2250      249,   250,   249,   251,   252,   251,   251,   254,   255,   253,
2251      256,   256,   258,   257,   259,   260,   261,   261,   262,   263,
2252      262,   264,   265,   265,   266,   267,   266,   268,   269,   268,
2253      270,   270,   270,   271,   271,   272,   273,   274,   272,   272,
2254      275,   275,   275,   275,   276,   276,   277,   277,   278,   278,
2255      279,   279,   280,   280,   280,   281,   281,   283,   282,   284,
2256      284,   286,   285,   287,   288,   287,   289,   289,   290,   290,
2257      291,   291,   291,   292,   292,   292,   292,   293,   292,   294,
2258      295,   297,   296,   298,   298,   298,   298,   298,   298,   298,
2259      298,   298,   298,   298,   298,   298,   298,   298,   298,   298,
2260      298,   298,   298,   298,   298,   298,   298,   298,   298,   298,
2261      299,   299,   299,   299,   299,   299,   299,   300,   300,   301,
2262      301,   301,   301,   302,   302,   303,   303,   303,   304,   304,
2263      304,   304,   305,   305,   305,   306,   306,   307,   307,   308,
2264      310,   309,   311,   309,   312,   313,   312,   312,   312,   312,
2265      312,   314,   316,   315,   317,   315,   318,   318,   318,   318,
2266      318,   318,   319,   319,   320,   320,   320,   320,   320,   320,
2267      320,   320,   320,   320,   320,   320,   320,   320,   320,   320,
2268      320,   320,   320,   320,   321,   321,   321,   321,   321,   321,
2269      321,   321,   321,   321,   321,   322,   322,   322,   323,   324,
2270      325,   324,   326,   326,   328,   327,   329,   330,   331,   327,
2271      332,   327,   333,   327,   334,   335,   327,   336,   327,   337,
2272      338,   339,   327,   327,   340,   327,   341,   327,   342,   327,
2273      343,   327,   344,   327,   345,   327,   346,   327,   347,   327,
2274      348,   327,   349,   327,   327,   327,   327,   350,   350,   351,
2275      351,   351,   351,   351,   351,   351,   351,   351,   352,   352,
2276      352,   352,   352,   352,   352,   352,   352,   352,   352,   352,
2277      352,   352,   352,   352,   352,   352,   352,   352,   352,   352,
2278      352,   352,   352,   352,   352,   352,   352,   352,   352,   352,
2279      352,   352,   352,   353,   353,   353,   353,   353,   353,   353,
2280      353,   353,   353,   353,   353,   353,   353,   353,   353,   353,
2281      353,   353,   353,   353,   353,   354,   354,   354,   354,   354,
2282      354,   354,   355,   355,   356,   356,   356,   356,   356,   356,
2283      356,   356,   356,   356,   356,   357,   357,   358,   358,   358,
2284      359,   359,   359,   360,   360,   361,   361,   362,   362,   363,
2285      363,   364,   364,   364,   366,   365,   368,   367,   370,   369,
2286      371,   369,   372,   369,   374,   373,   375,   375,   376,   376,
2287      377,   377,   378,   378,   378,   378,   378,   378,   378,   378,
2288      378,   378,   378,   378,   378,   378,   378,   378,   379,   380,
2289      381,   382,   382,   382
2290 };
2291
2292 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
2293 static const yytype_uint8 yyr2[] =
2294 {
2295        0,     2,     1,     0,     0,     3,     1,     1,     1,     1,
2296        1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
2297        1,     2,     2,     2,     2,     5,     4,     0,     6,     5,
2298        1,     2,     3,     4,     4,     5,     0,     5,     0,     4,
2299        0,     3,     1,     1,     1,     0,     0,     3,     3,     1,
2300        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2301        1,     1,     2,     2,     1,     2,     2,     2,     3,     2,
2302        3,     0,     1,     2,     1,     3,     1,     3,     3,     0,
2303        1,     0,     1,     1,     1,     1,     4,     5,     0,     5,
2304        2,     1,     0,     1,     1,     2,     3,     1,     0,     4,
2305        6,     3,     4,     2,     3,     5,     3,     1,     2,     5,
2306        5,     6,     5,     6,     2,     0,     3,     2,     1,     1,
2307        0,     0,     7,     1,     3,     1,     2,     2,     2,     3,
2308        3,     4,     3,     0,     5,     1,     0,     4,     0,     0,
2309        5,     0,     0,     5,     0,     0,     0,     7,     1,     1,
2310        0,     1,     0,     3,     1,     2,     2,     2,     2,     2,
2311        2,     3,     2,     3,     2,     3,     3,     2,     3,     4,
2312        2,     1,     1,     2,     1,     2,     2,     0,     0,     7,
2313        2,     0,     3,     0,     5,     2,     1,     2,     0,     2,
2314        0,     3,     1,     2,     3,     1,     0,     5,     1,     1,
2315        0,     0,     5,     0,     5,     0,     2,     1,     3,     2,
2316        0,     0,     2,     1,     0,     4,     3,     0,     0,     5,
2317        0,     1,     0,     3,     4,     2,     0,     2,     0,     0,
2318        4,     2,     0,     1,     2,     0,     5,     2,     0,     5,
2319        1,     1,     1,     1,     1,     0,     0,     0,     6,     1,
2320        0,     2,     2,     3,     1,     2,     1,     2,     0,     1,
2321        1,     3,     1,     1,     1,     0,     1,     0,     2,     1,
2322        2,     0,     4,     0,     0,     2,     1,     1,     1,     1,
2323        2,     2,     2,     2,     2,     3,     3,     0,     5,     1,
2324        1,     0,     5,     1,     1,     1,     1,     1,     1,     1,
2325        2,     2,     2,     2,     2,     2,     2,     1,     1,     1,
2326        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2327        1,     1,     1,     1,     1,     1,     1,     0,     2,     1,
2328        1,     1,     1,     1,     2,     1,     1,     1,     1,     1,
2329        2,     1,     1,     1,     1,     1,     1,     1,     2,     2,
2330        0,     3,     0,     4,     1,     0,     3,     1,     1,     2,
2331        2,     2,     0,     3,     0,     4,     1,     1,     1,     2,
2332        2,     2,     1,     1,     1,     1,     1,     1,     1,     1,
2333        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2334        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2335        1,     1,     1,     1,     1,     1,     1,     2,     1,     1,
2336        0,     3,     1,     2,     0,     7,     0,     0,     0,     9,
2337        0,     5,     0,     5,     0,     0,    10,     0,     7,     0,
2338        0,     0,     9,     6,     0,     7,     0,     7,     0,     7,
2339        0,     7,     0,     7,     0,     7,     0,     7,     0,     7,
2340        0,     9,     0,     9,     4,     4,     7,     0,     1,     2,
2341        2,     3,     3,     1,     1,     1,     1,     1,     1,     1,
2342        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2343        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2344        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2345        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2346        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2347        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2348        1,     1,     1,     2,     1,     1,     1,     1,     1,     1,
2349        1,     1,     1,     1,     1,     0,     2,     1,     1,     1,
2350        1,     1,     1,     1,     1,     0,     2,     0,     2,     1,
2351        1,     1,     1,     1,     0,     4,     0,     4,     0,     4,
2352        0,     4,     0,     4,     0,     4,     0,     2,     0,     2,
2353        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
2354        1,     1,     1,     1,     1,     1,     1,     1,     3,     3,
2355        3,     1,     1,     1
2356 };
2357
2358 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2359    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
2360    means the default is an error.  */
2361 static const yytype_uint16 yydefact[] =
2362 {
2363        3,     0,     4,     1,     0,   378,   379,   380,   374,   375,
2364      376,   377,    43,    42,    44,    91,   345,   346,   338,   341,
2365      343,   344,   342,   339,   186,     0,   355,     0,     0,     0,
2366      290,   394,   395,   396,   397,   399,   400,   401,   402,   398,
2367      403,   404,   381,   382,   393,   383,   384,   385,   386,   387,
2368      388,   389,   390,   391,   392,     0,     0,     0,     0,     0,
2369        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2370        0,     0,     0,     0,     0,     0,    20,     0,     5,    17,
2371       11,     9,    10,     8,    30,    15,   327,    36,    40,    14,
2372      327,     0,    12,   107,     7,     6,     0,    16,     0,     0,
2373        0,     0,   174,     0,     0,    13,     0,   276,   358,     0,
2374        0,     0,   357,   278,   289,     0,   333,   335,   336,   337,
2375        0,   232,   350,   354,   373,   372,    18,   295,   293,   294,
2376      298,   299,   297,   296,   308,   307,   319,   309,   310,   311,
2377      312,   313,   314,   315,   316,   317,   318,   360,   277,     0,
2378      279,   340,   133,     0,   378,   379,   380,   374,   375,   376,
2379      377,   339,   381,   382,   393,   383,   384,   385,   386,   387,
2380      388,   389,   390,   391,   392,   327,    40,   327,   358,   357,
2381        0,     0,   320,   322,   321,   325,   326,   324,   323,   576,
2382       27,     0,     0,     0,   125,     0,     0,     0,   416,   420,
2383      422,     0,     0,   429,     0,     0,     0,     0,     0,     0,
2384        0,     0,     0,     0,     0,     0,     0,     0,   302,   300,
2385      301,   305,   306,   304,   303,   232,     0,    71,   359,   232,
2386       88,     0,    24,    31,    21,    23,     0,    22,     0,     0,
2387      195,   576,   156,   158,   159,   157,   177,     0,     0,   180,
2388       19,   287,   164,     0,   162,   200,   280,     0,   279,   278,
2389      283,   281,   282,   284,   291,   327,    40,   327,   108,   175,
2390        0,   334,   352,   243,   244,   176,   181,     0,     0,   160,
2391      188,     0,   228,   220,     0,   265,     0,   199,   260,   408,
2392      409,   349,   233,   405,   412,   406,   327,   279,     3,   132,
2393      138,   356,   340,   232,   359,   232,   327,   327,   295,   293,
2394      294,   298,   299,   297,   296,   123,   119,   115,   118,   265,
2395      260,     0,     0,     0,   126,     0,   124,   128,   127,     0,
2396        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2397        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2398        0,     0,   332,   331,     0,   228,     0,   328,   329,   330,
2399       45,     0,    41,    72,    32,    71,     0,    92,   360,     0,
2400        0,   198,     0,   211,   359,     0,   203,   205,   285,   286,
2401      555,   232,   359,   232,   165,   163,   327,   188,   183,   478,
2402      479,   480,   481,   482,   483,   484,   485,   486,   492,   493,
2403      487,   488,   489,   490,   491,   494,   495,   496,   497,   498,
2404      499,   500,   501,   502,   466,   465,     0,   463,   464,     0,
2405      474,   475,   469,   468,   470,   471,   472,   473,   476,   477,
2406      185,   467,   187,   196,     0,   222,   225,   221,   256,     0,
2407        0,   237,   266,     0,   166,   161,   199,     0,     0,   407,
2408      413,   351,     4,     0,   135,     0,     0,     0,     0,   115,
2409        0,     0,   232,   232,     0,   120,   378,   379,   380,   374,
2410      375,   376,   377,   602,   603,   530,   526,   527,   525,   528,
2411      529,   531,   506,   505,   507,   519,   509,   511,   510,   512,
2412      513,   515,   514,   516,   518,   508,   520,   504,   503,   517,
2413      478,   479,   523,   522,   521,   524,   586,   585,   597,   581,
2414      576,    26,   592,   588,   593,   601,   590,   591,   576,   589,
2415      596,   587,   594,   595,   577,   580,   582,   584,   583,   576,
2416        0,     0,     3,   131,   130,   129,   414,     0,     0,     0,
2417      424,   427,     0,     0,   434,   438,   442,   446,   436,   440,
2418      444,   448,   450,   452,   454,   455,     0,    34,   227,   231,
2419       46,    83,    84,    85,    81,    73,    74,    79,    76,    39,
2420       86,     0,    93,    94,    97,   198,   194,     0,   217,     0,
2421        0,   211,     0,   201,     0,     0,    33,     0,   353,   182,
2422      211,     0,     0,   459,   460,   192,   190,     0,   189,   211,
2423      224,   229,     0,   238,   257,   271,   268,   269,   263,   264,
2424      262,   261,   347,   411,    25,   136,   134,     0,     0,     0,
2425      368,   367,     0,   258,   232,   362,   366,   148,   149,   258,
2426        0,   110,   114,   117,   112,     0,     0,   109,   232,   211,
2427        0,     0,     0,    29,     4,     0,   417,   421,   423,     0,
2428        0,   430,     0,     0,     0,     0,     0,     0,     0,     0,
2429        0,     0,     0,   457,    49,    50,    51,    37,     0,     0,
2430        0,    82,     0,    80,     0,    89,    95,    98,   578,   178,
2431      212,   213,     0,   288,     0,   206,   207,     0,   188,   570,
2432      572,   540,   574,   562,   538,   563,   568,   564,   292,   566,
2433      539,   544,   543,   537,   541,   542,   560,   561,   556,   559,
2434      534,   535,   536,    35,    87,     0,   461,   462,     0,   193,
2435        0,   232,   548,   549,   223,   547,   532,   245,   274,   270,
2436      348,   138,   369,   370,   371,   364,   241,   242,   240,   139,
2437      258,   265,   259,   361,   327,   142,   145,   111,   113,   116,
2438        0,   598,   599,   600,    28,     0,     0,   425,     0,     0,
2439      433,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2440        0,   458,     0,     0,     0,     0,    64,    53,    58,    47,
2441       60,    54,    57,    55,    52,     0,    59,     0,   171,   172,
2442       56,     0,     0,   357,     0,     0,    61,    48,    77,    75,
2443       78,    96,     0,     0,   188,   214,   258,   204,     0,   209,
2444      202,   545,   545,   557,   545,   555,   545,   184,   191,   197,
2445      230,   533,   246,   239,   249,     0,     0,   137,   327,   150,
2446      254,     0,   258,   234,   363,   150,   258,   121,   415,   418,
2447        0,   428,   431,   435,   439,   443,   447,   437,   441,   445,
2448      449,     0,     0,   456,    69,     0,    67,     0,     0,   357,
2449        0,     0,    62,    65,    66,     0,   167,    63,     0,   173,
2450        0,   170,   199,    99,   100,   579,   179,   216,   217,   218,
2451      208,     0,     0,     0,     0,     0,     0,   211,   272,   275,
2452      365,   152,   140,   151,   235,   255,   143,   146,   250,     0,
2453      578,     0,     0,     0,   576,   578,   103,   359,     0,    68,
2454        0,    70,     0,   168,     0,   215,   220,   551,   552,   571,
2455      550,   546,   573,   554,   575,   553,   558,   569,   565,   567,
2456        0,     0,   245,   150,   122,   419,     0,   432,   451,   453,
2457        0,     0,   101,     0,     0,   104,   359,   169,   219,   247,
2458      153,   154,   236,   147,   252,   251,     0,   426,   578,   106,
2459        0,   102,   250,   155,   253,     0,   248,   105
2460 };
2461
2462 /* YYDEFGOTO[NTERM-NUM].  */
2463 static const yytype_int16 yydefgoto[] =
2464 {
2465       -1,     1,     2,     4,    78,   232,    80,    81,   323,    82,
2466       83,    84,   234,    86,   226,    87,   365,   227,   247,   560,
2467      668,   669,   779,   780,   781,   362,   363,   565,   566,   674,
2468      670,   567,    89,    90,   367,    91,   571,   572,   573,   802,
2469      235,   856,   906,    92,    93,   458,   464,   459,   315,   316,
2470      639,   898,   317,    94,   193,    95,   236,   300,   453,   731,
2471      454,   455,   829,   456,   835,   457,   836,   933,   629,   892,
2472      893,   931,   950,   237,    98,    99,   100,   786,   787,   101,
2473      102,   373,   804,   103,   275,   387,   276,   590,   277,   104,
2474      279,   432,   598,   718,   242,   280,   599,   253,   789,   377,
2475      688,   255,   581,   583,   685,   686,   577,   578,   680,   878,
2476      681,   682,   916,   436,   437,   602,   105,   282,   354,   434,
2477      721,   355,   356,   739,   932,   283,   727,   740,   284,   823,
2478      887,   962,   934,   831,   439,   741,   742,   611,   441,   442,
2479      443,   606,   607,   728,   825,   826,   194,   107,   178,   149,
2480      375,   110,   111,   179,   380,   113,   114,   225,   357,   248,
2481      116,   117,   118,   119,   613,   239,   121,   296,   386,   122,
2482      153,   623,   624,   744,   828,   625,   123,   124,   125,   292,
2483      293,   294,   448,   295,   126,   645,   332,   756,   899,   333,
2484      334,   649,   840,   650,   337,   759,   901,   653,   657,   654,
2485      658,   655,   659,   656,   660,   661,   662,   772,   430,   703,
2486      704,   705,   724,   725,   881,   920,   921,   926,   584,   883,
2487      707,   708,   709,   815,   710,   816,   711,   814,   811,   812,
2488      712,   813,   321,   803,   524,   525,   526,   527,   528,   529
2489 };
2490
2491 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2492    STATE-NUM.  */
2493 #define YYPACT_NINF -872
2494 static const yytype_int16 yypact[] =
2495 {
2496     -872,    77,    87,  -872,  4255,   167,   191,   227,   280,   300,
2497      301,   304,  -872,  -872,  -872,  4899,  -872,  -872,  -872,  -872,
2498     -872,  -872,  -872,    98,  -872,    -8,  -872,  5429,   383,  4624,
2499     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2500     -872,  -872,   -38,   106,   121,   122,   133,   158,   171,   186,
2501      196,   203,   210,   228,   243,    -3,    36,    43,    45,    90,
2502      114,   130,   138,   151,   179,   183,   187,   202,   215,   233,
2503      235,   249,   258,   267,   269,   271,  -872,   438,  -872,  -872,
2504     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  4899,  -872,
2505     -872,    21,  -872,  -872,  -872,  -872,  5144,  -872,   -71,   -71,
2506      -71,   -71,  -872,   281,  5524,  -872,    54,  -872,   284,  4742,
2507      350,  4899,   -25,  -872,   297,  5239,  -872,  -872,  -872,  -872,
2508     4672,   276,  -872,  -872,  -872,  -872,  -872,   -10,     9,    18,
2509       50,    52,   148,   166,  -872,  -872,  -872,  -872,  -872,  -872,
2510     -872,  -872,  -872,  -872,  -872,  -872,  -872,   310,  -872,  4921,
2511      350,   312,   321,  4899,   -10,     9,    18,    50,    52,   148,
2512      166,   441,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2513     -872,  -872,  -872,  -872,  -872,  -872,  4899,  -872,  -872,   350,
2514     5429,  4790,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2515      332,  4899,  4899,   337,  -872,  4742,  4899,  4529,  -872,  -872,
2516     -872,  4529,  4529,  -872,  4529,  4529,  4529,  4529,  4529,  4529,
2517     4529,  4529,  4529,  4529,  4529,  4529,  4529,  4529,  -872,  -872,
2518     -872,  -872,  -872,  -872,  -872,  1286,   343,   348,   259,  1286,
2519     -872,  4899,  -872,  -872,  -872,  -872,  5144,  -872,  5334,  4947,
2520     -872,  -872,  -872,  -872,  -872,  -872,  -872,  4899,  5524,  -872,
2521     -872,  -872,  -872,   360,  -872,  -872,  -872,   350,   -13,   362,
2522     -872,  -872,  -872,  -872,  -872,  -872,  4899,  -872,  -872,  -872,
2523     4742,  -872,  -872,  -872,  -872,  -872,  -872,   363,  5071,  -872,
2524     -872,   370,  -872,   377,  1478,   372,  4742,   350,    15,  -872,
2525      435,  -872,  -872,  -872,  -872,   276,  -872,   350,  -872,  -872,
2526       73,  -872,  -872,  5028,   177,  5028,  -872,  -872,  -872,  -872,
2527     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,   107,
2528      379,  1212,   409,   384,  -872,   386,  -872,  -872,  -872,  1383,
2529     4742,   387,  4529,  4529,  4529,   388,   389,  4529,   390,   391,
2530      392,   393,   397,   398,   399,   401,   402,   403,   405,   404,
2531      406,   407,  -872,  -872,   414,  -872,  4790,  -872,  -872,  -872,
2532     -872,  1111,  -872,  -872,  -872,   348,   415,  4529,  -872,  5334,
2533     4742,  -872,  1617,   424,  -872,   471,  -872,   412,  -872,  -872,
2534     -872,  1286,   278,  1286,  -872,  -872,  -872,  -872,  -872,   381,
2535      423,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2536     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2537     -872,  -872,  -872,  -872,  -872,  -872,   428,  -872,  -872,   411,
2538     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2539     -872,  -872,    41,  -872,   212,  -872,  -872,  -872,  -872,   429,
2540     4790,  -872,  -872,   427,  -872,  -872,   350,   470,   440,  -872,
2541     -872,  4121,   436,    11,  -872,  5560,    88,   524,   442,  -872,
2542     4790,   443,  5028,  5028,   224,  -872,  -872,  -872,  -872,  -872,
2543     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2544     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2545     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2546     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2547     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2548     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2549      444,   350,  -872,  -872,  -872,  -872,  -872,   445,   434,   439,
2550     -872,  -872,   446,  5524,  -872,  -872,  -872,  -872,  -872,  -872,
2551     -872,  -872,  -872,  -872,  -872,  -872,  4529,  -872,   447,  -872,
2552       48,  -872,  -872,  -872,   485,   448,  -872,   535,  -872,  -872,
2553     -872,   452,   451,  -872,   456,   457,  -872,   454,  -872,   350,
2554      297,   424,  4899,  -872,  3577,   449,  -872,   462,  4121,    41,
2555      424,   437,   453,  -872,  -872,  -872,  -872,   549,  -872,   424,
2556     -872,  -872,  3857,  -872,  -872,  -872,   427,  -872,  -872,  -872,
2557     -872,  -872,  -872,   440,  -872,  -872,  -872,  4899,  4899,  4899,
2558     -872,   350,  5524,  4694,   276,  -872,  -872,  -872,  -872,  4694,
2559      563,  -872,   461,  -872,  -872,   467,   468,  -872,   276,   424,
2560     1757,  1897,  2037,  -872,   472,  5524,  -872,  -872,  -872,  5524,
2561     5524,  -872,   463,  5524,  5524,  5524,  5524,  5524,  5524,  5524,
2562     5524,  5524,  5524,   464,  -872,  -872,  -872,  -872,  4137,   469,
2563     4899,  -872,  1111,  -872,  4899,  -872,  4529,  -872,  -872,  -872,
2564      473,  -872,  5524,  -872,   474,   475,  -872,    58,  -872,  -872,
2565     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2566     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2567     -872,  -872,  -872,  -872,  -872,   477,  -872,  -872,    92,  -872,
2568      478,   276,  -872,  -872,  3857,  -872,  -872,   160,   465,  -872,
2569     -872,    73,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2570      969,   372,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2571      479,  -872,  -872,  -872,  -872,   480,  5524,  -872,   481,  5524,
2572     -872,   482,   483,   484,   489,   490,   491,   492,   496,   487,
2573      499,  -872,   498,  4373,  4851,    58,  -872,  -872,  -872,  -872,
2574     -872,  -872,  -872,  -872,  -872,  4563,  -872,   -71,  -872,  -872,
2575     -872,   506,  4742,   129,  4468,  4672,  -872,  -872,  -872,  -872,
2576     -872,  -872,  3857,  2317,  -872,   526,  4694,  -872,  4899,  -872,
2577       41,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2578     -872,  -872,  -872,  -872,  -872,   497,  3857,  -872,  -872,   504,
2579     -872,   502,  4694,  -872,  4121,   504,  4694,  -872,  -872,  -872,
2580      508,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2581     -872,   622,   623,  -872,  -872,  4720,  -872,   518,   -71,   -13,
2582     4563,  4947,  -872,  -872,  -872,  4563,  -872,  -872,   520,  -872,
2583     4742,  -872,  -872,  3857,  -872,  -872,    41,  -872,  -872,  -872,
2584     -872,  3017,  3157,  2877,  3297,  3717,  3437,   424,  -872,  3857,
2585     4121,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,   514,
2586     -872,   515,   516,   519,  -872,  -872,  -872,   328,  4720,  -872,
2587      518,  -872,  4720,  -872,   527,  -872,   377,  -872,  -872,  -872,
2588     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2589      521,  3997,   160,   504,    93,  -872,  2457,  -872,  -872,  -872,
2590     2177,  2597,  -872,   328,  4720,  -872,   339,  -872,  -872,  -872,
2591     3997,  -872,  -872,  -872,  -872,  -872,    58,  -872,  -872,  -872,
2592      339,  -872,  -872,  -872,  -872,  2737,    93,  -872
2593 };
2594
2595 /* YYPGOTO[NTERM-NUM].  */
2596 static const yytype_int16 yypgoto[] =
2597 {
2598     -872,  -872,  -260,  -872,  -872,   645,  -872,  -872,  -872,  -872,
2599     -613,   -94,     1,   -26,  -872,  -872,  -872,  -872,    16,  -872,
2600     -872,  -872,  -872,  -872,  -872,   285,  -872,  -872,   -20,  -872,
2601     -872,    89,   -17,   -21,  -872,  -872,  -872,  -872,   -22,  -872,
2602     -872,  -202,  -473,    -9,  -102,  -249,   199,    22,  -872,  -872,
2603     -872,  -872,   201,    -6,  -872,  -872,    -1,  -872,  -872,  -872,
2604      -66,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -770,
2605     -872,  -872,  -872,   668,  -872,  -872,  -872,  -111,   -97,  -576,
2606      -80,  -872,  -872,  -154,  -241,  -872,  -872,  -872,  -155,    35,
2607     -270,  -364,  -872,  -872,   -91,  -872,  -872,  -105,   -67,  -872,
2608     -872,  -872,  -872,  -872,  -872,  -129,  -542,  -872,  -872,  -872,
2609     -198,  -872,  -872,  -230,  -872,  -872,    20,   333,  -166,   338,
2610     -872,    -5,   -95,  -575,  -872,  -157,  -872,  -872,  -872,  -237,
2611     -872,  -872,  -261,  -872,  -872,  -872,   -98,  -872,   -29,  -696,
2612     -872,  -872,   112,  -872,  -872,  -872,    13,   -45,     3,    32,
2613     -872,   -63,    23,    -4,  -872,   754,   -24,     8,  -872,    10,
2614      -81,  -872,  -872,  -415,  -872,    49,  -872,  -872,  -872,   -19,
2615     -872,  -872,  -872,  -872,  -872,  -872,  -121,  -391,   194,  -272,
2616      425,   430,  -872,  -872,    51,  -872,  -872,  -872,  -872,  -872,
2617     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,
2618     -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -872,  -204,
2619     -302,    82,  -751,  -554,  -456,  -581,  -153,  -872,   -89,  -872,
2620     -871,  -872,  -872,  -872,  -872,  -872,    17,  -872,  -872,  -872,
2621     -872,  -872,  -183,  -820,  -872,  -759,  -872,  -872,  -660,  -872
2622 };
2623
2624 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
2625    positive, shift that token.  If negative, reduce the rule which
2626    number is the opposite.  If zero, do what YYDEFACT says.
2627    If YYTABLE_NINF, syntax error.  */
2628 #define YYTABLE_NINF -411
2629 static const yytype_int16 yytable[] =
2630 {
2631      112,   175,   233,    96,   190,    85,   177,   108,   243,   244,
2632      245,   150,   440,   268,   115,   281,   445,   106,   148,   522,
2633       88,   726,   285,   589,   318,   150,   291,   809,   147,   252,
2634      706,   824,   148,   612,   271,   269,   109,   180,   452,   684,
2635      328,   327,   254,   176,   875,   444,   257,    30,   715,   240,
2636      241,   873,   196,   120,   745,   777,   461,   720,   372,    30,
2637      951,   195,  -320,   366,   256,   896,   261,   595,   473,   474,
2638      522,   664,   665,   666,   431,   889,   181,     3,   596,   963,
2639      936,  -322,  -308,   319,   150,   941,   257,    -2,  -308,   265,
2640     -321,   148,   788,  -141,   267,  -279,   272,   750,   229,   271,
2641      445,   228,   689,   690,   256,   258,   238,   150,   627,  -144,
2642      151,  -141,    88,  -199,   262,   862,   287,   521,  -320,   954,
2643      152,   955,  -325,   197,  -326,   431,   628,   438,   109,   444,
2644      956,   266,   257,   260,   281,   263,   615,  -322,   965,   447,
2645      616,  -198,   230,   821,   358,   297,  -321,   270,   358,   150,
2646      256,   261,   286,   249,   306,   278,   148,   271,   269,   307,
2647      854,   272,   198,   953,   597,   830,   301,   271,   521,   199,
2648      667,   200,   150,   263,   250,   535,   534,   875,  -325,   148,
2649     -326,   281,   875,   303,   515,   305,   285,   150,   150,   304,
2650      384,   297,   150,   701,   148,   148,   176,   788,   730,   262,
2651      520,    30,   263,   385,   324,   325,   875,   257,   460,   788,
2652      460,   701,   265,   635,   636,   585,   201,   587,   696,   272,
2653     -324,   726,   358,   257,   358,   256,  -307,   150,   330,   272,
2654      329,   879,  -307,   465,   148,   287,   824,  -267,  -323,  -320,
2655      202,  -319,  -309,   150,   368,   726,   369,  -319,  -309,  -279,
2656      148,   520,   176,  -310,   266,  -199,   203,   895,   285,  -310,
2657      374,   897,   150,  -322,   204,   281,   258,   257,   109,   148,
2658      270,   370,   644,   381,   278,   383,  -324,   205,  -311,   382,
2659      378,   379,   446,   604,  -311,   256,   822,  -295,   271,   269,
2660     -267,  -312,   821,  -295,  -323,  -320,   964,  -312,   -38,  -321,
2661      358,   -38,   358,   318,   451,   206,  -313,   257,   821,   207,
2662      263,  -293,  -313,   208,   462,   463,  -314,  -293,   531,  -322,
2663      379,   278,  -314,  -315,   810,   530,   297,   640,   209,  -315,
2664     -316,   706,   600,   701,   626,   641,  -316,   601,   522,   522,
2665      522,   210,   285,   265,   637,   930,   642,  -294,  -317,   638,
2666      272,   580,  -325,  -294,  -317,  -321,   882,   150,   884,   211,
2667      886,   212,   319,  -318,   148,   329,   446,   460,   460,  -318,
2668      358,   579,  -326,  -324,   568,   213,  -323,   706,   249,   364,
2669      -38,   358,   358,   -38,   214,   176,   182,   183,   184,   185,
2670      186,   187,   188,   215,   588,   216,   706,   217,   586,   -38,
2671     -298,   270,   -38,   523,  -277,   278,  -298,   246,  -325,   289,
2672      290,   701,   182,   183,   184,   185,   186,   187,   188,   359,
2673     -299,  -297,    30,   359,  -296,   264,  -299,  -297,  -326,  -324,
2674     -296,   -90,  -323,   298,   942,   701,   521,   521,   521,   945,
2675      876,   218,   219,   220,   221,   222,   223,   224,   364,   904,
2676      299,   621,   905,   302,   523,   322,   630,   326,   620,   586,
2677      904,  -410,  -410,   905,   360,   622,    16,    17,   832,   379,
2678      942,   945,   361,   961,   182,   183,   184,   185,   186,   187,
2679      188,    30,   701,   608,   609,   610,   376,   961,  -198,   388,
2680      701,   701,   701,   701,   701,   701,   433,   359,   701,   359,
2681      435,   522,  -267,   447,   189,   532,   533,   358,   561,   562,
2682      563,   591,   536,   540,   541,   543,   544,   545,   546,   520,
2683      520,   520,   547,   548,   549,   871,   550,   551,   552,   743,
2684      553,   554,   556,   555,   557,   570,   582,    12,    13,    14,
2685      701,   271,   594,   460,    16,    17,    18,    19,    20,    21,
2686       22,  -210,   161,   592,   263,   593,   603,   605,   614,   701,
2687       25,   647,   631,   634,   643,   673,   648,   719,   716,   713,
2688      646,   651,   601,   672,   675,   359,   676,   359,   150,   677,
2689      678,   679,   714,   746,   717,   148,   638,   747,   748,   771,
2690      760,   871,   652,   797,   754,   687,  -273,   877,   805,   521,
2691      808,   807,   683,   735,   817,   819,   837,   838,   841,   843,
2692      844,   845,   851,   150,   150,   150,   846,   847,   848,   849,
2693      148,   148,   148,   850,   852,   853,   867,   891,   888,   894,
2694      732,   733,   734,   900,   522,   902,   903,   868,   522,   522,
2695      913,   935,   937,   938,   263,   359,   939,   947,   949,    79,
2696      569,   782,   799,   671,   801,   909,   359,   359,   632,   783,
2697      749,   633,   784,   522,   793,   827,   150,   785,   150,   778,
2698      150,   108,    97,   148,   864,   148,   858,   148,   794,   880,
2699      915,   791,   520,   798,    88,   568,   948,   800,   790,   559,
2700      281,   233,   268,   558,   755,   952,   866,   285,   757,   758,
2701      792,   966,   761,   762,   763,   764,   765,   766,   767,   768,
2702      769,   770,   833,   271,   269,   914,   820,   795,   729,   796,
2703      449,   940,   523,   523,   523,   450,   885,   869,     0,   257,
2704      925,   806,   521,     0,     0,   818,   521,   521,     0,     0,
2705        0,     0,     0,     0,     0,     0,     0,   256,     0,     0,
2706        0,     0,   834,   358,     0,     0,   281,     0,     0,     0,
2707        0,   521,     0,   233,     0,     0,     0,   911,   265,   859,
2708      150,   580,   857,   267,     0,   272,     0,   148,   702,   271,
2709      269,   859,   359,   860,   271,   269,   863,     0,   297,   855,
2710      859,   872,     0,   869,     0,   865,   702,   196,   869,     0,
2711        0,    88,     0,     0,   150,   839,   195,   257,   842,   358,
2712      266,   148,     0,     0,     0,   520,   263,   792,     0,   520,
2713      520,   687,   861,     0,     0,   256,   870,   278,     0,   271,
2714      278,     0,     0,     0,   861,     0,   890,   580,     0,   265,
2715        0,   272,     0,     0,   520,     0,   272,     0,     0,     0,
2716        0,   150,     0,     0,     0,     0,   859,   872,   148,     0,
2717        0,   859,     0,   259,     0,     0,   297,   910,   907,     0,
2718        0,     0,     0,   908,   288,     0,   912,     0,     0,     0,
2719        0,   266,   263,     0,     0,   523,     0,     0,     0,     0,
2720        0,     0,     0,     0,     0,     0,   278,   870,     0,     0,
2721        0,     0,     0,     0,   150,   278,     0,     0,   150,     0,
2722        0,   148,     0,     0,     0,   148,     0,     0,   702,     0,
2723        0,   943,     0,     0,     0,   946,   944,     0,     0,     0,
2724        0,     0,     0,     0,     0,   320,     0,     0,     0,     0,
2725      150,     0,     0,     0,     0,     0,     0,   148,     0,     0,
2726        0,   331,     0,     0,     0,   335,   336,   960,   338,   339,
2727      340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
2728      350,   351,   308,   309,   310,   311,   312,   313,   314,   736,
2729      737,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2730        0,     0,     0,   371,     0,     0,   702,     0,     0,     0,
2731        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2732        0,     0,     0,     0,     0,     0,     0,     0,   523,     0,
2733      702,     0,   523,   523,   259,     0,     0,     0,   359,     0,
2734        0,     0,     0,     0,     0,     0,     0,     0,   320,     0,
2735      371,     0,     0,     0,     0,     0,     0,   523,     0,     0,
2736        0,     0,     0,     0,   134,   135,   136,   137,   138,   139,
2737      140,   141,   142,   143,   144,   145,   146,   702,     0,     0,
2738        0,     0,     0,     0,     0,   702,   702,   702,   702,   702,
2739      702,     0,     0,   702,   359,     0,   537,   538,   539,     0,
2740        0,   542,     0,     0,     0,   738,     0,     0,     0,     0,
2741        0,    77,   289,   290,     0,     0,     0,     0,     0,     0,
2742      320,     0,     0,     0,   127,   128,   129,   130,   131,   132,
2743      133,   574,     0,     0,   575,   702,     0,     0,     0,     0,
2744        0,     0,     0,     0,   561,   562,   563,     0,     0,     0,
2745        0,   564,     0,     0,   702,     0,     0,     0,     0,     0,
2746        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2747        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2748        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2749        0,     0,     0,    30,     0,     0,     0,     0,     0,     0,
2750        0,     0,     0,     0,   320,     0,   134,   135,   136,   137,
2751      138,   139,   140,   141,   142,   143,   144,   145,   146,     0,
2752        0,     0,     0,     0,   320,   466,   467,   468,   469,   470,
2753      471,   472,   473,   474,   475,   476,   477,   478,   479,   480,
2754      481,   482,   483,   484,   485,   486,   487,   488,   489,     0,
2755        0,   490,   491,    77,   492,     0,   493,   494,   495,   496,
2756      497,   498,   499,     0,   500,   501,   502,   503,   504,   505,
2757      391,   392,   393,   394,   395,   396,   397,   398,   399,   400,
2758      401,   402,   403,   404,   405,   406,   407,   408,   409,   410,
2759      411,   412,   413,   506,   507,   508,    31,    32,    33,    34,
2760       35,    36,    37,    38,    39,    40,    41,   162,   163,   164,
2761      165,   166,   167,   168,   169,   170,   171,   172,   173,   174,
2762      663,     0,    16,    17,    18,    19,    20,    21,    22,   352,
2763      161,     0,     0,     0,     0,   353,     0,     0,     0,     0,
2764        0,     0,   509,   510,   511,   512,   513,   514,   515,     0,
2765      516,   517,   518,     0,   420,   421,   422,   423,   424,   425,
2766      426,   427,   428,   429,   519,     0,     0,     0,     0,     0,
2767       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
2768       41,     0,     0,     0,     0,     0,     0,   320,     0,     0,
2769        0,     0,     0,   320,     0,     0,   154,   155,   156,   157,
2770      158,   159,   160,     0,     0,     0,     0,     0,     0,     0,
2771        0,     0,    12,    13,    14,   231,  -226,     0,     0,    16,
2772       17,    18,    19,    20,    21,    22,     0,   161,     0,   289,
2773      290,    26,   259,     0,     0,   389,   390,     0,     0,     0,
2774      574,   391,   392,   393,   394,   395,   396,   397,   398,   399,
2775      400,   401,   402,   403,   404,   405,   406,   407,   408,   409,
2776      410,   411,   412,   413,     0,    30,     0,    31,    32,    33,
2777       34,    35,    36,    37,    38,    39,    40,    41,   162,   163,
2778      164,   165,   166,   167,   168,   169,   170,   171,   172,   173,
2779      174,   308,   309,   310,   311,   312,   313,   314,   273,   274,
2780        0,     0,     0,     0,   320,     0,     0,     0,     0,     0,
2781        0,     0,     0,     0,     0,     0,   414,     0,   415,   416,
2782        0,   417,   418,   419,     0,   420,   421,   422,   423,   424,
2783      425,   426,   427,   428,   429,     0,     0,   371,     0,     0,
2784        0,     0,     0,     0,     0,     0,     0,     0,     0,   371,
2785        0,     0,     0,     0,     0,     0,     0,     0,   371,   288,
2786        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2787      320,     0,     0,   134,   135,   136,   137,   138,   139,   140,
2788      141,   142,   143,   144,   145,   146,     0,     0,     0,     0,
2789        0,     0,     0,     0,     0,     0,   320,     0,     0,     0,
2790      320,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2791        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2792       77,   289,   290,     0,   371,   371,     0,     0,     0,   371,
2793      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2794      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2795      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2796        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2797      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2798      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2799      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2800      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2801       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2802      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2803        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2804        0,     0,     0,     0,     0,     0,     0,   509,   510,   576,
2805      512,   513,   514,   515,     0,   516,   517,   518,     0,   420,
2806      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2807      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2808      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2809      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2810        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2811      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2812      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2813      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2814      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2815       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2816      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2817        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2818        0,     0,     0,     0,     0,     0,     0,   509,   510,   751,
2819      512,   513,   514,   515,     0,   516,   517,   518,     0,   420,
2820      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2821      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2822      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2823      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2824        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2825      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2826      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2827      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2828      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2829       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2830      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2831        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2832        0,     0,     0,     0,     0,     0,     0,   509,   510,     0,
2833      512,   513,   514,   515,     0,   516,   517,   518,   752,   420,
2834      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2835      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2836      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2837      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2838        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2839      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2840      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2841      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2842      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2843       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2844      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2845        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2846        0,     0,     0,     0,     0,     0,     0,   509,   510,     0,
2847      512,   513,   514,   515,   753,   516,   517,   518,     0,   420,
2848      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2849      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2850      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2851      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2852        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2853      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2854      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2855      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2856      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2857       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2858      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2859        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2860        0,     0,     0,     0,     0,     0,     0,   509,   510,   958,
2861      512,   513,   514,   515,     0,   516,   517,   518,     0,   420,
2862      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2863      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2864      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2865      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2866        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2867      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2868      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2869      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2870      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2871       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2872      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2873        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2874        0,     0,     0,     0,     0,     0,     0,   874,   510,     0,
2875      512,   513,   514,   515,     0,   516,   517,   518,     0,   420,
2876      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2877      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2878      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2879      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2880        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2881      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2882      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2883      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2884      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2885       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2886      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2887        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2888        0,     0,     0,     0,     0,     0,     0,     0,   510,     0,
2889      512,   513,   514,   515,   957,   516,   517,   518,     0,   420,
2890      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2891      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2892      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2893      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2894        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2895      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2896      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2897      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2898      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2899       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2900      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2901        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2902        0,     0,     0,     0,     0,     0,     0,   959,   510,     0,
2903      512,   513,   514,   515,     0,   516,   517,   518,     0,   420,
2904      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2905      466,   467,   468,   469,   470,   471,   472,   473,   474,   475,
2906      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2907      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2908        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2909      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2910      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2911      406,   407,   408,   409,   410,   411,   412,   413,   506,   507,
2912      508,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2913       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2914      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2915        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2916        0,     0,     0,     0,     0,     0,     0,   967,   510,     0,
2917      512,   513,   514,   515,     0,   516,   517,   518,     0,   420,
2918      421,   422,   423,   424,   425,   426,   427,   428,   429,   519,
2919      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
2920      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2921      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2922        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2923      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2924      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2925      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
2926        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2927       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2928      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2929        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2930        0,     0,     0,     0,     0,     0,     0,   923,   692,   924,
2931      917,   694,   918,   696,     0,   722,   723,   699,     0,   420,
2932      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
2933      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
2934      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2935      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2936        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2937      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2938      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2939      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
2940        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2941       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2942      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2943        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2944        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
2945      917,   694,   918,   696,   919,   722,   723,   699,     0,   420,
2946      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
2947      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
2948      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2949      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2950        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2951      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2952      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2953      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
2954        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2955       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2956      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2957        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2958        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
2959      917,   694,   918,   696,   922,   722,   723,   699,     0,   420,
2960      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
2961      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
2962      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2963      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2964        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2965      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2966      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2967      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
2968        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2969       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2970      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2971        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2972        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
2973      917,   694,   918,   696,   927,   722,   723,   699,     0,   420,
2974      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
2975      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
2976      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2977      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2978        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2979      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2980      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2981      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
2982        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2983       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2984      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2985        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
2986        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
2987      917,   694,   918,   696,     0,   722,   723,   699,   929,   420,
2988      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
2989      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
2990      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
2991      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
2992        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
2993      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
2994      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
2995      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
2996        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
2997       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
2998      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
2999        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3000        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
3001      693,   694,   695,   696,     0,   697,   698,   699,     0,   420,
3002      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
3003      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
3004      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
3005      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
3006        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
3007      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
3008      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
3009      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
3010        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
3011       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
3012      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
3013        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3014        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
3015      693,   694,   695,   696,     0,   697,   928,   699,     0,   420,
3016      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
3017      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
3018      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
3019      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
3020        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
3021      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
3022      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
3023      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
3024        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
3025       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
3026      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
3027        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3028        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
3029        0,   694,     0,   696,     0,   722,   723,   699,     0,   420,
3030      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
3031      466,   467,   468,   469,   470,   471,   472,   689,   690,   475,
3032      476,   477,   478,   479,   480,   481,   482,   483,   484,   485,
3033      486,   487,   488,   489,     0,     0,   490,   491,     0,   492,
3034        0,   493,   494,   495,   496,   497,   498,   499,     0,   500,
3035      501,   502,   503,   504,   505,   391,   392,   393,   394,   395,
3036      396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
3037      406,   407,   408,   409,   410,   411,   412,   413,     0,   691,
3038        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
3039       40,    41,   162,   163,   164,   165,   166,   167,   168,   169,
3040      170,   171,   172,   173,   174,     0,     0,     0,     0,     0,
3041        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3042        0,     0,     0,     0,     0,     0,     0,     0,   692,     0,
3043        0,   694,     0,   696,     0,   697,     0,   699,     0,   420,
3044      421,   422,   423,   424,   425,   426,   427,   428,   429,   700,
3045        5,     6,     7,     8,     9,    10,    11,    16,    17,    18,
3046       19,    20,    21,    22,   352,   161,    12,    13,    14,    15,
3047      353,     0,     0,    16,    17,    18,    19,    20,    21,    22,
3048      773,   161,    24,    25,     0,    26,    27,     0,   774,     0,
3049        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3050        0,     0,     0,     0,     0,    31,    32,    33,    34,    35,
3051       36,    37,    38,    39,    40,    41,     0,     0,     0,    30,
3052        0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
3053       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
3054       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
3055       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
3056       70,    71,    72,    73,    74,    75,   775,   776,     5,     6,
3057        7,     8,     9,    10,    11,     0,     0,     0,     0,    77,
3058        0,     0,     0,     0,    12,    13,    14,    15,     0,     0,
3059        0,    16,    17,    18,    19,    20,    21,    22,     0,    23,
3060       24,    25,     0,    26,    27,    28,    29,     0,     0,     0,
3061        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3062        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3063        0,     0,     0,     0,     0,     0,     0,    30,     0,    31,
3064       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
3065       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
3066       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
3067       62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
3068       72,    73,    74,    75,     0,    76,     5,     6,     7,     8,
3069        9,    10,    11,     0,     0,     0,     0,    77,     0,     0,
3070        0,     0,    12,    13,    14,   231,     0,     0,     0,    16,
3071       17,    18,    19,    20,    21,    22,     0,   161,    24,    25,
3072        0,    26,     0,     0,     0,     0,     0,     0,     0,     0,
3073        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3074        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3075        0,     0,     0,     0,     0,    30,     0,    31,    32,    33,
3076       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
3077       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
3078       54,     5,     6,     7,     8,     9,    10,    11,     0,     0,
3079        0,     0,     0,     0,     0,     0,     0,    12,    13,    14,
3080       15,     0,     0,     0,    16,    17,    18,    19,    20,    21,
3081       22,     0,   161,    24,     0,    77,    26,    27,     0,     0,
3082        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3083        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3084        0,     0,   308,   309,   310,   311,   312,   313,   314,     0,
3085       30,     0,    31,    32,    33,    34,    35,    36,    37,    38,
3086       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
3087       49,    50,    51,    52,    53,    54,     5,     6,     7,     8,
3088        9,    10,    11,     0,     0,     0,     0,     0,     0,     0,
3089        0,     0,    12,    13,    14,   231,     0,     0,     0,    16,
3090       17,    18,    19,    20,    21,    22,     0,   161,    24,     0,
3091       77,    26,     0,     0,     0,     0,     0,     0,     0,     0,
3092        0,     0,     0,     0,   134,   135,   136,   137,   138,   139,
3093      140,   141,   142,   143,   144,   145,   146,   127,   128,   129,
3094      130,   131,   132,   133,     0,    30,     0,    31,    32,    33,
3095       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
3096       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
3097       54,    77,   191,     0,   192,     0,     0,     0,     0,     0,
3098        0,     0,     0,     0,     0,   127,   128,   129,   130,   131,
3099      132,   133,   273,   274,     0,     0,     0,     0,     0,     0,
3100        0,     0,     0,     0,     0,    77,    30,   308,   309,   310,
3101      311,   312,   313,   314,   736,   737,     0,    24,     0,   134,
3102      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
3103      145,   146,     0,   127,   128,   129,   130,   131,   132,   133,
3104        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3105        0,     0,     0,     0,     0,   127,   128,   129,   130,   131,
3106      132,   133,     0,     0,     0,     0,    77,   134,   135,   136,
3107      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
3108        0,     0,     0,     0,     0,     0,     0,    24,   251,   134,
3109      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
3110      145,   146,    30,   308,   309,   310,   311,   312,   313,   314,
3111      273,   274,     0,     0,    77,   134,   135,   136,   137,   138,
3112      139,   140,   141,   142,   143,   144,   145,   146,     0,     0,
3113      738,     0,     0,     0,     0,     0,    77,   134,   135,   136,
3114      137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
3115        0,   904,     0,     0,   905,     0,     0,     0,     0,     0,
3116        0,     0,    77,     0,   127,   128,   129,   130,   131,   132,
3117      133,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3118        0,     0,     0,     0,    77,   134,   135,   136,   137,   138,
3119      139,   140,   141,   142,   143,   144,   145,   146,     0,   191,
3120        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3121        0,     0,   127,   128,   129,   130,   131,   132,   133,     0,
3122        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3123        0,     0,    77,    30,   127,   128,   129,   130,   131,   132,
3124      133,     0,     0,     0,     0,     0,   134,   135,   136,   137,
3125      138,   139,   140,   141,   142,   143,   144,   145,   146,     0,
3126      127,   128,   129,   130,   131,   132,   133,   251,     0,     0,
3127        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3128        0,    30,     0,     0,     0,     0,     0,     0,     0,     0,
3129        0,     0,    24,    77,   134,   135,   136,   137,   138,   139,
3130      140,   141,   142,   143,   144,   145,   146,     0,     0,     0,
3131        0,     0,     0,     0,     0,     0,   134,   135,   136,   137,
3132      138,   139,   140,   141,   142,   143,   144,   145,   146,     0,
3133        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3134        0,    77,   134,   135,   136,   137,   138,   139,   140,   141,
3135      142,   143,   144,   145,   146,     0,     0,     0,     0,     0,
3136        0,     0,     0,    77,    16,    17,    18,    19,    20,    21,
3137       22,   352,   161,     0,     0,     0,     0,   353,     0,     0,
3138        0,     0,     0,     0,     0,     0,     0,     0,     0,    77,
3139        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3140        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3141        0,     0,    31,    32,    33,    34,    35,    36,    37,    38,
3142       39,    40,    41,   389,   390,     0,     0,     0,     0,   391,
3143      392,   393,   394,   395,   396,   397,   398,   399,   400,   401,
3144      402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
3145      412,   413,     0,     0,     0,     0,     0,   154,   155,   156,
3146      157,   158,   159,   160,     0,     0,     0,     0,     0,     0,
3147        0,   289,   290,    12,    13,    14,   231,     0,     0,     0,
3148       16,    17,    18,    19,    20,    21,    22,     0,   161,    24,
3149       25,     0,    26,     0,     0,     0,     0,     0,     0,     0,
3150        0,     0,     0,     0,   414,     0,   415,   416,     0,   417,
3151      418,   419,     0,   420,   421,   422,   423,   424,   425,   426,
3152      427,   428,   429,     0,     0,     0,    30,     0,    31,    32,
3153       33,    34,    35,    36,    37,    38,    39,    40,    41,   162,
3154      163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
3155      173,   174,   154,   155,   156,   157,   158,   159,   160,     0,
3156        0,     0,     0,     0,     0,     0,     0,     0,    12,    13,
3157       14,    15,     0,     0,     0,    16,    17,    18,    19,    20,
3158       21,    22,     0,   161,    24,     0,     0,    26,    27,     0,
3159        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3160        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3161        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3162        0,    30,     0,    31,    32,    33,    34,    35,    36,    37,
3163       38,    39,    40,    41,   162,   163,   164,   165,   166,   167,
3164      168,   169,   170,   171,   172,   173,   174,   154,   155,   156,
3165      157,   158,   159,   160,     0,     0,     0,     0,     0,     0,
3166        0,     0,     0,    12,    13,    14,   231,     0,     0,     0,
3167       16,    17,    18,    19,    20,    21,    22,     0,   161,    24,
3168        0,     0,    26,     0,     0,     0,     0,     0,     0,     0,
3169        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3170        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3171        0,     0,     0,     0,     0,     0,    30,     0,    31,    32,
3172       33,    34,    35,    36,    37,    38,    39,    40,    41,   162,
3173      163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
3174      173,   174,   154,   155,   156,   157,   158,   159,   160,     0,
3175        0,     0,     0,     0,     0,     0,     0,     0,    12,    13,
3176       14,    15,     0,     0,     0,    16,    17,    18,    19,    20,
3177       21,    22,     0,   161,     0,     0,     0,    26,     0,     0,
3178        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3179        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3180        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
3181        0,    30,     0,    31,    32,    33,    34,    35,    36,    37,
3182       38,    39,    40,    41,   162,   163,   164,   165,   166,   167,
3183      168,   169,   170,   171,   172,   173,   174,   154,   155,   156,
3184      157,   158,   159,   160,     0,     0,     0,     0,     0,     0,
3185        0,     0,     0,    12,    13,    14,   231,     0,     0,     0,
3186       16,    17,    18,    19,    20,    21,    22,     0,   161,     0,
3187        0,     0,    26,   154,   155,   156,   157,   158,   159,   160,
3188        0,     0,     0,     0,     0,     0,     0,     0,     0,   617,
3189        0,   618,   619,     0,     0,     0,    16,    17,    18,    19,
3190       20,    21,    22,     0,   161,     0,    30,     0,    31,    32,
3191       33,    34,    35,    36,    37,    38,    39,    40,    41,   162,
3192      163,   164,   165,   166,   167,   168,   169,   170,   171,   172,
3193      173,   174,     0,     0,     0,     0,     0,     0,     0,     0,
3194        0,     0,    30,     0,    31,    32,    33,    34,    35,    36,
3195       37,    38,    39,    40,    41,   162,   163,   164,   165,   166,
3196      167,   168,   169,   170,   171,   172,   173,   174
3197 };
3198
3199 static const yytype_int16 yycheck[] =
3200 {
3201        4,    27,    96,     4,    28,     4,    27,     4,    99,   100,
3202      101,    15,   284,   115,     4,   120,   286,     4,    15,   321,
3203        4,   602,   120,   387,   181,    29,   121,   687,    15,   109,
3204      584,   727,    29,   448,   115,   115,     4,    27,   298,   581,
3205      195,   195,   109,    27,   803,   286,   109,    72,   590,   120,
3206      121,   802,    29,     4,   629,   668,   305,   599,   241,    72,
3207      931,    29,    72,   229,   109,   835,   111,    26,    10,    11,
3208      372,    23,    24,    25,   278,   826,    27,     0,    37,   950,
3209      900,    72,   120,   181,    88,   905,   149,     0,   126,   115,
3210       72,    88,   668,    20,   115,   120,   115,   639,    90,   180,
3211      370,    88,    10,    11,   149,   109,    96,   111,    20,    36,
3212       12,    38,    96,   126,   111,   775,   120,   321,   128,    26,
3213      128,    28,    72,   126,    72,   329,    38,   284,    96,   370,
3214       37,   115,   195,   110,   239,   112,   125,   128,   958,   124,
3215      129,   126,   121,   724,   225,   149,   128,   115,   229,   153,
3216      195,   196,   120,   104,   180,   120,   153,   238,   238,   180,
3217      773,   180,   126,   933,   123,   740,   153,   248,   372,   126,
3218      122,   126,   176,   150,   120,   330,   330,   936,   128,   176,
3219      128,   286,   941,   175,   126,   177,   284,   191,   192,   176,
3220      270,   195,   196,   584,   191,   192,   180,   773,   613,   196,
3221      321,    72,   179,   270,   191,   192,   965,   270,   303,   785,
3222      305,   602,   238,   462,   463,   381,   126,   383,   126,   238,
3223       72,   802,   303,   286,   305,   270,   120,   231,   196,   248,
3224      195,   806,   126,   126,   231,   239,   932,   130,    72,    72,
3225      126,   120,   120,   247,   231,   826,   236,   126,   126,   120,
3226      247,   372,   236,   120,   238,   126,   126,   832,   356,   126,
3227      247,   836,   266,    72,   126,   370,   270,   330,   236,   266,
3228      238,   239,   532,   265,   239,   267,   128,   126,   120,   266,
3229      257,   258,   286,   440,   126,   330,   126,   120,   369,   369,
3230      130,   120,   873,   126,   128,   128,   956,   126,   121,    72,
3231      381,   124,   383,   460,   296,   126,   120,   370,   889,   126,
3232      287,   120,   126,   126,   306,   307,   120,   126,   322,   128,
3233      297,   286,   126,   120,   688,   322,   330,   510,   126,   126,
3234      120,   885,   120,   724,   455,   518,   126,   125,   640,   641,
3235      642,   126,   440,   369,   120,   887,   529,   120,   120,   125,
3236      369,   375,    72,   126,   126,   128,   812,   361,   814,   126,
3237      816,   126,   460,   120,   361,   330,   370,   462,   463,   126,
3238      451,   375,    72,    72,   361,   126,    72,   931,   329,   120,
3239      121,   462,   463,   124,   126,   369,     3,     4,     5,     6,
3240        7,     8,     9,   126,   386,   126,   950,   126,   120,   121,
3241      120,   369,   124,   321,   120,   370,   126,   126,   128,   133,
3242      134,   802,     3,     4,     5,     6,     7,     8,     9,   225,
3243      120,   120,    72,   229,   120,   128,   126,   126,   128,   128,
3244      126,   121,   128,   121,   907,   826,   640,   641,   642,   912,
3245      804,     3,     4,     5,     6,     7,     8,     9,   120,   121,
3246      129,   455,   124,    12,   372,   123,   457,   120,   455,   120,
3247      121,    26,    27,   124,   121,   455,    26,    27,   740,   446,
3248      943,   944,   124,   946,     3,     4,     5,     6,     7,     8,
3249        9,    72,   873,    13,    14,    15,   126,   960,   126,   126,
3250      881,   882,   883,   884,   885,   886,   126,   303,   889,   305,
3251      123,   803,   130,   124,   121,   121,   120,   588,    23,    24,
3252       25,   130,   125,   125,   125,   125,   125,   125,   125,   640,
3253      641,   642,   125,   125,   125,   795,   125,   125,   125,   624,
3254      125,   127,   125,   127,   120,   120,   124,    19,    20,    21,
3255      931,   622,   131,   638,    26,    27,    28,    29,    30,    31,
3256       32,   127,    34,   130,   531,   127,   127,   130,   122,   950,
3257       36,   127,   120,   120,   120,    30,   127,    18,   131,   120,
3258      125,   125,   125,   125,   122,   381,   125,   383,   582,   123,
3259      123,   127,   120,    20,   131,   582,   125,   120,   120,   125,
3260      127,   861,   543,   124,   122,   582,   131,    71,   125,   803,
3261      125,   127,   579,   622,   127,   127,   127,   127,   127,   127,
3262      127,   127,   125,   617,   618,   619,   127,   127,   127,   127,
3263      617,   618,   619,   127,   125,   127,   120,   123,   131,   127,
3264      617,   618,   619,   125,   936,    13,    13,   792,   940,   941,
3265      120,   127,   127,   127,   621,   451,   127,   120,   127,     4,
3266      365,   668,   672,   564,   676,   857,   462,   463,   459,   668,
3267      638,   460,   668,   965,   668,   731,   670,   668,   672,   668,
3268      674,   668,     4,   670,   785,   672,   773,   674,   668,   808,
3269      878,   668,   803,   670,   668,   672,   916,   674,   668,   356,
3270      795,   785,   794,   355,   645,   932,   787,   795,   649,   650,
3271      668,   962,   653,   654,   655,   656,   657,   658,   659,   660,
3272      661,   662,   741,   794,   794,   870,   721,   668,   606,   668,
3273      295,   904,   640,   641,   642,   295,   815,   794,    -1,   792,
3274      883,   682,   936,    -1,    -1,   718,   940,   941,    -1,    -1,
3275       -1,    -1,    -1,    -1,    -1,    -1,    -1,   792,    -1,    -1,
3276       -1,    -1,   744,   834,    -1,    -1,   861,    -1,    -1,    -1,
3277       -1,   965,    -1,   857,    -1,    -1,    -1,   858,   794,   773,
3278      774,   795,   773,   794,    -1,   794,    -1,   774,   584,   860,
3279      860,   785,   588,   773,   865,   865,   785,    -1,   792,   773,
3280      794,   795,    -1,   860,    -1,   785,   602,   774,   865,    -1,
3281       -1,   785,    -1,    -1,   808,   756,   774,   870,   759,   890,
3282      794,   808,    -1,    -1,    -1,   936,   793,   785,    -1,   940,
3283      941,   808,   773,    -1,    -1,   870,   794,   792,    -1,   910,
3284      795,    -1,    -1,    -1,   785,    -1,   828,   861,    -1,   865,
3285       -1,   860,    -1,    -1,   965,    -1,   865,    -1,    -1,    -1,
3286       -1,   855,    -1,    -1,    -1,    -1,   860,   861,   855,    -1,
3287       -1,   865,    -1,   109,    -1,    -1,   870,   857,   855,    -1,
3288       -1,    -1,    -1,   857,   120,    -1,   860,    -1,    -1,    -1,
3289       -1,   865,   859,    -1,    -1,   803,    -1,    -1,    -1,    -1,
3290       -1,    -1,    -1,    -1,    -1,    -1,   861,   865,    -1,    -1,
3291       -1,    -1,    -1,    -1,   908,   870,    -1,    -1,   912,    -1,
3292       -1,   908,    -1,    -1,    -1,   912,    -1,    -1,   724,    -1,
3293       -1,   908,    -1,    -1,    -1,   912,   910,    -1,    -1,    -1,
3294       -1,    -1,    -1,    -1,    -1,   181,    -1,    -1,    -1,    -1,
3295      944,    -1,    -1,    -1,    -1,    -1,    -1,   944,    -1,    -1,
3296       -1,   197,    -1,    -1,    -1,   201,   202,   944,   204,   205,
3297      206,   207,   208,   209,   210,   211,   212,   213,   214,   215,
3298      216,   217,     3,     4,     5,     6,     7,     8,     9,    10,
3299       11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3300       -1,    -1,    -1,   239,    -1,    -1,   802,    -1,    -1,    -1,
3301       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3302       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   936,    -1,
3303      826,    -1,   940,   941,   270,    -1,    -1,    -1,   834,    -1,
3304       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   284,    -1,
3305      286,    -1,    -1,    -1,    -1,    -1,    -1,   965,    -1,    -1,
3306       -1,    -1,    -1,    -1,    85,    86,    87,    88,    89,    90,
3307       91,    92,    93,    94,    95,    96,    97,   873,    -1,    -1,
3308       -1,    -1,    -1,    -1,    -1,   881,   882,   883,   884,   885,
3309      886,    -1,    -1,   889,   890,    -1,   332,   333,   334,    -1,
3310       -1,   337,    -1,    -1,    -1,   126,    -1,    -1,    -1,    -1,
3311       -1,   132,   133,   134,    -1,    -1,    -1,    -1,    -1,    -1,
3312      356,    -1,    -1,    -1,     3,     4,     5,     6,     7,     8,
3313        9,   367,    -1,    -1,   370,   931,    -1,    -1,    -1,    -1,
3314       -1,    -1,    -1,    -1,    23,    24,    25,    -1,    -1,    -1,
3315       -1,    30,    -1,    -1,   950,    -1,    -1,    -1,    -1,    -1,
3316       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3317       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3318       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3319       -1,    -1,    -1,    72,    -1,    -1,    -1,    -1,    -1,    -1,
3320       -1,    -1,    -1,    -1,   440,    -1,    85,    86,    87,    88,
3321       89,    90,    91,    92,    93,    94,    95,    96,    97,    -1,
3322       -1,    -1,    -1,    -1,   460,     3,     4,     5,     6,     7,
3323        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
3324       18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
3325       -1,    29,    30,   132,    32,    -1,    34,    35,    36,    37,
3326       38,    39,    40,    -1,    42,    43,    44,    45,    46,    47,
3327       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
3328       58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
3329       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
3330       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
3331       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
3332      556,    -1,    26,    27,    28,    29,    30,    31,    32,    33,
3333       34,    -1,    -1,    -1,    -1,    39,    -1,    -1,    -1,    -1,
3334       -1,    -1,   120,   121,   122,   123,   124,   125,   126,    -1,
3335      128,   129,   130,    -1,   132,   133,   134,   135,   136,   137,
3336      138,   139,   140,   141,   142,    -1,    -1,    -1,    -1,    -1,
3337       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
3338       84,    -1,    -1,    -1,    -1,    -1,    -1,   623,    -1,    -1,
3339       -1,    -1,    -1,   629,    -1,    -1,     3,     4,     5,     6,
3340        7,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3341       -1,    -1,    19,    20,    21,    22,   120,    -1,    -1,    26,
3342       27,    28,    29,    30,    31,    32,    -1,    34,    -1,   133,
3343      134,    38,   668,    -1,    -1,    42,    43,    -1,    -1,    -1,
3344      676,    48,    49,    50,    51,    52,    53,    54,    55,    56,
3345       57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
3346       67,    68,    69,    70,    -1,    72,    -1,    74,    75,    76,
3347       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
3348       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
3349       97,     3,     4,     5,     6,     7,     8,     9,    10,    11,
3350       -1,    -1,    -1,    -1,   740,    -1,    -1,    -1,    -1,    -1,
3351       -1,    -1,    -1,    -1,    -1,    -1,   123,    -1,   125,   126,
3352       -1,   128,   129,   130,    -1,   132,   133,   134,   135,   136,
3353      137,   138,   139,   140,   141,    -1,    -1,   773,    -1,    -1,
3354       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   785,
3355       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   794,   795,
3356       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3357      806,    -1,    -1,    85,    86,    87,    88,    89,    90,    91,
3358       92,    93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,
3359       -1,    -1,    -1,    -1,    -1,    -1,   832,    -1,    -1,    -1,
3360      836,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3361       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3362      132,   133,   134,    -1,   860,   861,    -1,    -1,    -1,   865,
3363        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3364       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3365       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3366       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3367       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3368       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3369       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3370       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3371       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3372       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3373       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3374       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,   122,
3375      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3376      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3377        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3378       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3379       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3380       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3381       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3382       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3383       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3384       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3385       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3386       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3387       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3388       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,   122,
3389      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3390      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3391        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3392       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3393       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3394       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3395       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3396       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3397       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3398       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3399       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3400       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3401       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3402       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,    -1,
3403      123,   124,   125,   126,    -1,   128,   129,   130,   131,   132,
3404      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3405        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3406       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3407       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3408       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3409       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3410       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3411       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3412       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3413       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3414       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3415       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3416       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,    -1,
3417      123,   124,   125,   126,   127,   128,   129,   130,    -1,   132,
3418      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3419        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3420       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3421       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3422       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3423       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3424       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3425       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3426       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3427       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3428       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3429       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3430       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,   122,
3431      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3432      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3433        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3434       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3435       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3436       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3437       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3438       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3439       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3440       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3441       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3442       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3443       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3444       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,    -1,
3445      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3446      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3447        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3448       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3449       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3450       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3451       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3452       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3453       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3454       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3455       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3456       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3457       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3458       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3459      123,   124,   125,   126,   127,   128,   129,   130,    -1,   132,
3460      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3461        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3462       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3463       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3464       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3465       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3466       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3467       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3468       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3469       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3470       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3471       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3472       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,    -1,
3473      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3474      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3475        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3476       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3477       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3478       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3479       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3480       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3481       63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
3482       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3483       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3484       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3485       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3486       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,    -1,
3487      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3488      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3489        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3490       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3491       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3492       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3493       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3494       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3495       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3496       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3497       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3498       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3499       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3500       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,   121,   122,
3501      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3502      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3503        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3504       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3505       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3506       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3507       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3508       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3509       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3510       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3511       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3512       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3513       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3514       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3515      123,   124,   125,   126,   127,   128,   129,   130,    -1,   132,
3516      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3517        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3518       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3519       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3520       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3521       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3522       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3523       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3524       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3525       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3526       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3527       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3528       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3529      123,   124,   125,   126,   127,   128,   129,   130,    -1,   132,
3530      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3531        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3532       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3533       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3534       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3535       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3536       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3537       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3538       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3539       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3540       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3541       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3542       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3543      123,   124,   125,   126,   127,   128,   129,   130,    -1,   132,
3544      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3545        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3546       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3547       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3548       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3549       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3550       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3551       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3552       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3553       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3554       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3555       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3556       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3557      123,   124,   125,   126,    -1,   128,   129,   130,   131,   132,
3558      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3559        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3560       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3561       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3562       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3563       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3564       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3565       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3566       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3567       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3568       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3569       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3570       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3571      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3572      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3573        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3574       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3575       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3576       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3577       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3578       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3579       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3580       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3581       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3582       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3583       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3584       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3585      123,   124,   125,   126,    -1,   128,   129,   130,    -1,   132,
3586      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3587        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3588       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3589       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3590       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3591       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3592       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3593       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3594       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3595       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3596       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3597       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3598       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3599       -1,   124,    -1,   126,    -1,   128,   129,   130,    -1,   132,
3600      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3601        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
3602       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
3603       23,    24,    25,    26,    -1,    -1,    29,    30,    -1,    32,
3604       -1,    34,    35,    36,    37,    38,    39,    40,    -1,    42,
3605       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
3606       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
3607       63,    64,    65,    66,    67,    68,    69,    70,    -1,    72,
3608       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3609       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3610       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3611       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3612       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   121,    -1,
3613       -1,   124,    -1,   126,    -1,   128,    -1,   130,    -1,   132,
3614      133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
3615        3,     4,     5,     6,     7,     8,     9,    26,    27,    28,
3616       29,    30,    31,    32,    33,    34,    19,    20,    21,    22,
3617       39,    -1,    -1,    26,    27,    28,    29,    30,    31,    32,
3618       33,    34,    35,    36,    -1,    38,    39,    -1,    41,    -1,
3619       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3620       -1,    -1,    -1,    -1,    -1,    74,    75,    76,    77,    78,
3621       79,    80,    81,    82,    83,    84,    -1,    -1,    -1,    72,
3622       -1,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3623       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3624       93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
3625      103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
3626      113,   114,   115,   116,   117,   118,   119,   120,     3,     4,
3627        5,     6,     7,     8,     9,    -1,    -1,    -1,    -1,   132,
3628       -1,    -1,    -1,    -1,    19,    20,    21,    22,    -1,    -1,
3629       -1,    26,    27,    28,    29,    30,    31,    32,    -1,    34,
3630       35,    36,    -1,    38,    39,    40,    41,    -1,    -1,    -1,
3631       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3632       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3633       -1,    -1,    -1,    -1,    -1,    -1,    -1,    72,    -1,    74,
3634       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
3635       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
3636       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
3637      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
3638      115,   116,   117,   118,    -1,   120,     3,     4,     5,     6,
3639        7,     8,     9,    -1,    -1,    -1,    -1,   132,    -1,    -1,
3640       -1,    -1,    19,    20,    21,    22,    -1,    -1,    -1,    26,
3641       27,    28,    29,    30,    31,    32,    -1,    34,    35,    36,
3642       -1,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3643       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3644       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3645       -1,    -1,    -1,    -1,    -1,    72,    -1,    74,    75,    76,
3646       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
3647       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
3648       97,     3,     4,     5,     6,     7,     8,     9,    -1,    -1,
3649       -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,    20,    21,
3650       22,    -1,    -1,    -1,    26,    27,    28,    29,    30,    31,
3651       32,    -1,    34,    35,    -1,   132,    38,    39,    -1,    -1,
3652       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3653       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3654       -1,    -1,     3,     4,     5,     6,     7,     8,     9,    -1,
3655       72,    -1,    74,    75,    76,    77,    78,    79,    80,    81,
3656       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
3657       92,    93,    94,    95,    96,    97,     3,     4,     5,     6,
3658        7,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3659       -1,    -1,    19,    20,    21,    22,    -1,    -1,    -1,    26,
3660       27,    28,    29,    30,    31,    32,    -1,    34,    35,    -1,
3661      132,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3662       -1,    -1,    -1,    -1,    85,    86,    87,    88,    89,    90,
3663       91,    92,    93,    94,    95,    96,    97,     3,     4,     5,
3664        6,     7,     8,     9,    -1,    72,    -1,    74,    75,    76,
3665       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
3666       87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
3667       97,   132,    38,    -1,    40,    -1,    -1,    -1,    -1,    -1,
3668       -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
3669        8,     9,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
3670       -1,    -1,    -1,    -1,    -1,   132,    72,     3,     4,     5,
3671        6,     7,     8,     9,    10,    11,    -1,    35,    -1,    85,
3672       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
3673       96,    97,    -1,     3,     4,     5,     6,     7,     8,     9,
3674       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3675       -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
3676        8,     9,    -1,    -1,    -1,    -1,   132,    85,    86,    87,
3677       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
3678       -1,    -1,    -1,    -1,    -1,    -1,    -1,    35,    36,    85,
3679       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
3680       96,    97,    72,     3,     4,     5,     6,     7,     8,     9,
3681       10,    11,    -1,    -1,   132,    85,    86,    87,    88,    89,
3682       90,    91,    92,    93,    94,    95,    96,    97,    -1,    -1,
3683      126,    -1,    -1,    -1,    -1,    -1,   132,    85,    86,    87,
3684       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
3685       -1,   121,    -1,    -1,   124,    -1,    -1,    -1,    -1,    -1,
3686       -1,    -1,   132,    -1,     3,     4,     5,     6,     7,     8,
3687        9,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3688       -1,    -1,    -1,    -1,   132,    85,    86,    87,    88,    89,
3689       90,    91,    92,    93,    94,    95,    96,    97,    -1,    38,
3690       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3691       -1,    -1,     3,     4,     5,     6,     7,     8,     9,    -1,
3692       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3693       -1,    -1,   132,    72,     3,     4,     5,     6,     7,     8,
3694        9,    -1,    -1,    -1,    -1,    -1,    85,    86,    87,    88,
3695       89,    90,    91,    92,    93,    94,    95,    96,    97,    -1,
3696        3,     4,     5,     6,     7,     8,     9,    36,    -1,    -1,
3697       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3698       -1,    72,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3699       -1,    -1,    35,   132,    85,    86,    87,    88,    89,    90,
3700       91,    92,    93,    94,    95,    96,    97,    -1,    -1,    -1,
3701       -1,    -1,    -1,    -1,    -1,    -1,    85,    86,    87,    88,
3702       89,    90,    91,    92,    93,    94,    95,    96,    97,    -1,
3703       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3704       -1,   132,    85,    86,    87,    88,    89,    90,    91,    92,
3705       93,    94,    95,    96,    97,    -1,    -1,    -1,    -1,    -1,
3706       -1,    -1,    -1,   132,    26,    27,    28,    29,    30,    31,
3707       32,    33,    34,    -1,    -1,    -1,    -1,    39,    -1,    -1,
3708       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   132,
3709       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3710       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3711       -1,    -1,    74,    75,    76,    77,    78,    79,    80,    81,
3712       82,    83,    84,    42,    43,    -1,    -1,    -1,    -1,    48,
3713       49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
3714       59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
3715       69,    70,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
3716        6,     7,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,
3717       -1,   133,   134,    19,    20,    21,    22,    -1,    -1,    -1,
3718       26,    27,    28,    29,    30,    31,    32,    -1,    34,    35,
3719       36,    -1,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3720       -1,    -1,    -1,    -1,   123,    -1,   125,   126,    -1,   128,
3721      129,   130,    -1,   132,   133,   134,   135,   136,   137,   138,
3722      139,   140,   141,    -1,    -1,    -1,    72,    -1,    74,    75,
3723       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
3724       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
3725       96,    97,     3,     4,     5,     6,     7,     8,     9,    -1,
3726       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,    20,
3727       21,    22,    -1,    -1,    -1,    26,    27,    28,    29,    30,
3728       31,    32,    -1,    34,    35,    -1,    -1,    38,    39,    -1,
3729       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3730       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3731       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3732       -1,    72,    -1,    74,    75,    76,    77,    78,    79,    80,
3733       81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
3734       91,    92,    93,    94,    95,    96,    97,     3,     4,     5,
3735        6,     7,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,
3736       -1,    -1,    -1,    19,    20,    21,    22,    -1,    -1,    -1,
3737       26,    27,    28,    29,    30,    31,    32,    -1,    34,    35,
3738       -1,    -1,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3739       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3740       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3741       -1,    -1,    -1,    -1,    -1,    -1,    72,    -1,    74,    75,
3742       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
3743       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
3744       96,    97,     3,     4,     5,     6,     7,     8,     9,    -1,
3745       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,    20,
3746       21,    22,    -1,    -1,    -1,    26,    27,    28,    29,    30,
3747       31,    32,    -1,    34,    -1,    -1,    -1,    38,    -1,    -1,
3748       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3749       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3750       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3751       -1,    72,    -1,    74,    75,    76,    77,    78,    79,    80,
3752       81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
3753       91,    92,    93,    94,    95,    96,    97,     3,     4,     5,
3754        6,     7,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,
3755       -1,    -1,    -1,    19,    20,    21,    22,    -1,    -1,    -1,
3756       26,    27,    28,    29,    30,    31,    32,    -1,    34,    -1,
3757       -1,    -1,    38,     3,     4,     5,     6,     7,     8,     9,
3758       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,
3759       -1,    21,    22,    -1,    -1,    -1,    26,    27,    28,    29,
3760       30,    31,    32,    -1,    34,    -1,    72,    -1,    74,    75,
3761       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
3762       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
3763       96,    97,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
3764       -1,    -1,    72,    -1,    74,    75,    76,    77,    78,    79,
3765       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
3766       90,    91,    92,    93,    94,    95,    96,    97
3767 };
3768
3769 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
3770    symbol of state STATE-NUM.  */
3771 static const yytype_uint16 yystos[] =
3772 {
3773        0,   144,   145,     0,   146,     3,     4,     5,     6,     7,
3774        8,     9,    19,    20,    21,    22,    26,    27,    28,    29,
3775       30,    31,    32,    34,    35,    36,    38,    39,    40,    41,
3776       72,    74,    75,    76,    77,    78,    79,    80,    81,    82,
3777       83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
3778       93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
3779      103,   104,   105,   106,   107,   108,   109,   110,   111,   112,
3780      113,   114,   115,   116,   117,   118,   120,   132,   147,   148,
3781      149,   150,   152,   153,   154,   155,   156,   158,   161,   175,
3782      176,   178,   186,   187,   196,   198,   199,   216,   217,   218,
3783      219,   222,   223,   226,   232,   259,   289,   290,   291,   292,
3784      294,   295,   296,   298,   299,   302,   303,   304,   305,   306,
3785      308,   309,   312,   319,   320,   321,   327,     3,     4,     5,
3786        6,     7,     8,     9,    85,    86,    87,    88,    89,    90,
3787       91,    92,    93,    94,    95,    96,    97,   289,   291,   292,
3788      296,    12,   128,   313,     3,     4,     5,     6,     7,     8,
3789        9,    34,    85,    86,    87,    88,    89,    90,    91,    92,
3790       93,    94,    95,    96,    97,   156,   161,   176,   291,   296,
3791      302,   308,     3,     4,     5,     6,     7,     8,     9,   121,
3792      299,    38,    40,   197,   289,   292,   295,   126,   126,   126,
3793      126,   126,   126,   126,   126,   126,   126,   126,   126,   126,
3794      126,   126,   126,   126,   126,   126,   126,   126,     3,     4,
3795        5,     6,     7,     8,     9,   300,   157,   160,   289,   300,
3796      121,    22,   148,   154,   155,   183,   199,   216,   302,   308,
3797      120,   121,   237,   237,   237,   237,   126,   161,   302,   308,
3798      120,    36,   223,   240,   241,   244,   290,   294,   296,   298,
3799      295,   290,   291,   295,   128,   156,   161,   176,   187,   223,
3800      292,   303,   312,    10,    11,   227,   229,   231,   232,   233,
3801      238,   240,   260,   268,   271,   279,   292,   296,   298,   133,
3802      134,   265,   322,   323,   324,   326,   310,   296,   121,   129,
3803      200,   289,    12,   300,   289,   300,   156,   176,     3,     4,
3804        5,     6,     7,     8,     9,   191,   192,   195,   268,   279,
3805      298,   375,   123,   151,   289,   289,   120,   226,   231,   232,
3806      292,   298,   329,   332,   333,   298,   298,   337,   298,   298,
3807      298,   298,   298,   298,   298,   298,   298,   298,   298,   298,
3808      298,   298,    33,    39,   261,   264,   265,   301,   303,   321,
3809      121,   124,   168,   169,   120,   159,   261,   177,   289,   302,
3810      292,   298,   375,   224,   289,   293,   126,   242,   295,   295,
3811      297,   300,   289,   300,   223,   241,   311,   228,   126,    42,
3812       43,    48,    49,    50,    51,    52,    53,    54,    55,    56,
3813       57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
3814       67,    68,    69,    70,   123,   125,   126,   128,   129,   130,
3815      132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
3816      351,   352,   234,   126,   262,   123,   256,   257,   268,   277,
3817      322,   281,   282,   283,   227,   233,   296,   124,   325,   323,
3818      324,   300,   145,   201,   203,   204,   206,   208,   188,   190,
3819      265,   188,   300,   300,   189,   126,     3,     4,     5,     6,
3820        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
3821       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
3822       29,    30,    32,    34,    35,    36,    37,    38,    39,    40,
3823       42,    43,    44,    45,    46,    47,    71,    72,    73,   120,
3824      121,   122,   123,   124,   125,   126,   128,   129,   130,   142,
3825      319,   352,   353,   354,   377,   378,   379,   380,   381,   382,
3826      291,   296,   121,   120,   226,   231,   125,   298,   298,   298,
3827      125,   125,   298,   125,   125,   125,   125,   125,   125,   125,
3828      125,   125,   125,   125,   127,   127,   125,   120,   262,   260,
3829      162,    23,    24,    25,    30,   170,   171,   174,   289,   168,
3830      120,   179,   180,   181,   298,   298,   122,   249,   250,   296,
3831      299,   245,   124,   246,   361,   261,   120,   261,   300,   234,
3832      230,   130,   130,   127,   131,    26,    37,   123,   235,   239,
3833      120,   125,   258,   127,   268,   130,   284,   285,    13,    14,
3834       15,   280,   306,   307,   122,   125,   129,    19,    21,    22,
3835      291,   296,   302,   314,   315,   318,   319,    20,    38,   211,
3836      199,   120,   189,   195,   120,   188,   188,   120,   125,   193,
3837      375,   375,   375,   120,   145,   328,   125,   127,   127,   334,
3838      336,   125,   308,   340,   342,   344,   346,   341,   343,   345,
3839      347,   348,   349,   298,    23,    24,    25,   122,   163,   164,
3840      173,   174,   125,    30,   172,   122,   125,   123,   123,   127,
3841      251,   253,   254,   295,   249,   247,   248,   289,   243,    10,
3842       11,    72,   121,   123,   124,   125,   126,   128,   129,   130,
3843      142,   320,   321,   352,   353,   354,   356,   363,   364,   365,
3844      367,   369,   373,   120,   120,   249,   131,   131,   236,    18,
3845      249,   263,   128,   129,   355,   356,   358,   269,   286,   285,
3846      306,   202,   289,   289,   289,   312,    10,    11,   126,   266,
3847      270,   278,   279,   265,   316,   266,    20,   120,   120,   190,
3848      249,   122,   131,   127,   122,   308,   330,   308,   308,   338,
3849      127,   308,   308,   308,   308,   308,   308,   308,   308,   308,
3850      308,   125,   350,    33,    41,   119,   120,   153,   155,   165,
3851      166,   167,   175,   186,   196,   199,   220,   221,   222,   241,
3852      259,   289,   292,   296,   302,   308,   327,   124,   289,   171,
3853      289,   181,   182,   376,   225,   125,   308,   127,   125,   381,
3854      234,   371,   372,   374,   370,   366,   368,   127,   369,   127,
3855      264,   358,   126,   272,   282,   287,   288,   203,   317,   205,
3856      266,   276,   322,   281,   300,   207,   209,   127,   127,   308,
3857      335,   127,   308,   127,   127,   127,   127,   127,   127,   127,
3858      127,   125,   125,   127,   153,   161,   184,   199,   221,   296,
3859      302,   308,   381,   155,   220,   302,   237,   120,   231,   241,
3860      292,   233,   296,   355,   120,   378,   234,    71,   252,   266,
3861      248,   357,   357,   362,   357,   361,   357,   273,   131,   355,
3862      300,   123,   212,   213,   127,   266,   212,   266,   194,   331,
3863      125,   339,    13,    13,   121,   124,   185,   289,   161,   184,
3864      302,   237,   161,   120,   231,   253,   255,   123,   125,   127,
3865      358,   359,   127,   120,   122,   359,   360,   127,   129,   131,
3866      249,   214,   267,   210,   275,   127,   376,   127,   127,   127,
3867      375,   376,   185,   289,   161,   185,   289,   120,   256,   127,
3868      215,   363,   272,   212,    26,    28,    37,   127,   122,   120,
3869      289,   185,   274,   363,   381,   376,   275,   120
3870 };
3871
3872 #define yyerrok                (yyerrstatus = 0)
3873 #define yyclearin        (yychar = YYEMPTY)
3874 #define YYEMPTY                (-2)
3875 #define YYEOF                0
3876
3877 #define YYACCEPT        goto yyacceptlab
3878 #define YYABORT                goto yyabortlab
3879 #define YYERROR                goto yyerrorlab
3880
3881
3882 /* Like YYERROR except do call yyerror.  This remains here temporarily
3883    to ease the transition to the new meaning of YYERROR, for GCC.
3884    Once GCC version 2 has supplanted version 1, this can go.  */
3885
3886 #define YYFAIL                goto yyerrlab
3887
3888 #define YYRECOVERING()  (!!yyerrstatus)
3889
3890 #define YYBACKUP(Token, Value)                                        \
3891 do                                                                \
3892   if (yychar == YYEMPTY && yylen == 1)                                \
3893     {                                                                \
3894       yychar = (Token);                                                \
3895       yylval = (Value);                                                \
3896       yytoken = YYTRANSLATE (yychar);                                \
3897       YYPOPSTACK (1);                                                \
3898       goto yybackup;                                                \
3899     }                                                                \
3900   else                                                                \
3901     {                                                                \
3902       yyerror (YY_("syntax error: cannot back up")); \
3903       YYERROR;                                                        \
3904     }                                                                \
3905 while (YYID (0))
3906
3907
3908 #define YYTERROR        1
3909 #define YYERRCODE        256
3910
3911
3912 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
3913    If N is 0, then set CURRENT to the empty location which ends
3914    the previous symbol: RHS[0] (always defined).  */
3915
3916 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
3917 #ifndef YYLLOC_DEFAULT
3918 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
3919     do                                                                        \
3920       if (YYID (N))                                                    \
3921         {                                                                \
3922           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
3923           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;        \
3924           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;                \
3925           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;        \
3926         }                                                                \
3927       else                                                                \
3928         {                                                                \
3929           (Current).first_line   = (Current).last_line   =                \
3930             YYRHSLOC (Rhs, 0).last_line;                                \
3931           (Current).first_column = (Current).last_column =                \
3932             YYRHSLOC (Rhs, 0).last_column;                                \
3933         }                                                                \
3934     while (YYID (0))
3935 #endif
3936
3937
3938 /* YY_LOCATION_PRINT -- Print the location on the stream.
3939    This macro was not mandated originally: define only if we know
3940    we won't break user code: when these are the locations we know.  */
3941
3942 #ifndef YY_LOCATION_PRINT
3943 # if YYLTYPE_IS_TRIVIAL
3944 #  define YY_LOCATION_PRINT(File, Loc)                        \
3945      fprintf (File, "%d.%d-%d.%d",                        \
3946               (Loc).first_line, (Loc).first_column,        \
3947               (Loc).last_line,  (Loc).last_column)
3948 # else
3949 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3950 # endif
3951 #endif
3952
3953
3954 /* YYLEX -- calling `yylex' with the right arguments.  */
3955
3956 #ifdef YYLEX_PARAM
3957 # define YYLEX yylex (YYLEX_PARAM)
3958 #else
3959 # define YYLEX yylex ()
3960 #endif
3961
3962 /* Enable debugging if requested.  */
3963 #if YYDEBUG
3964
3965 # ifndef YYFPRINTF
3966 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
3967 #  define YYFPRINTF fprintf
3968 # endif
3969
3970 # define YYDPRINTF(Args)                        \
3971 do {                                                \
3972   if (yydebug)                                        \
3973     YYFPRINTF Args;                                \
3974 } while (YYID (0))
3975
3976 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                          \
3977 do {                                                                          \
3978   if (yydebug)                                                                  \
3979     {                                                                          \
3980       YYFPRINTF (stderr, "%s ", Title);                                          \
3981       yy_symbol_print (stderr,                                                  \
3982                   Type, Value); \
3983       YYFPRINTF (stderr, "\n");                                                  \
3984     }                                                                          \
3985 } while (YYID (0))
3986
3987
3988 /*--------------------------------.
3989 | Print this symbol on YYOUTPUT.  |
3990 `--------------------------------*/
3991
3992 /*ARGSUSED*/
3993 #if (defined __STDC__ || defined __C99__FUNC__ \
3994      || defined __cplusplus || defined _MSC_VER)
3995 static void
3996 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
3997 #else
3998 static void
3999 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
4000     FILE *yyoutput;
4001     int yytype;
4002     YYSTYPE const * const yyvaluep;
4003 #endif
4004 {
4005   if (!yyvaluep)
4006     return;
4007 # ifdef YYPRINT
4008   if (yytype < YYNTOKENS)
4009     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4010 # else
4011   YYUSE (yyoutput);
4012 # endif
4013   switch (yytype)
4014     {
4015       default:
4016         break;
4017     }
4018 }
4019
4020
4021 /*--------------------------------.
4022 | Print this symbol on YYOUTPUT.  |
4023 `--------------------------------*/
4024
4025 #if (defined __STDC__ || defined __C99__FUNC__ \
4026      || defined __cplusplus || defined _MSC_VER)
4027 static void
4028 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
4029 #else
4030 static void
4031 yy_symbol_print (yyoutput, yytype, yyvaluep)
4032     FILE *yyoutput;
4033     int yytype;
4034     YYSTYPE const * const yyvaluep;
4035 #endif
4036 {
4037   if (yytype < YYNTOKENS)
4038     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4039   else
4040     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4041
4042   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
4043   YYFPRINTF (yyoutput, ")");
4044 }
4045
4046 /*------------------------------------------------------------------.
4047 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4048 | TOP (included).                                                   |
4049 `------------------------------------------------------------------*/
4050
4051 #if (defined __STDC__ || defined __C99__FUNC__ \
4052      || defined __cplusplus || defined _MSC_VER)
4053 static void
4054 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4055 #else
4056 static void
4057 yy_stack_print (yybottom, yytop)
4058     yytype_int16 *yybottom;
4059     yytype_int16 *yytop;
4060 #endif
4061 {
4062   YYFPRINTF (stderr, "Stack now");
4063   for (; yybottom <= yytop; yybottom++)
4064     {
4065       int yybot = *yybottom;
4066       YYFPRINTF (stderr, " %d", yybot);
4067     }
4068   YYFPRINTF (stderr, "\n");
4069 }
4070
4071 # define YY_STACK_PRINT(Bottom, Top)                                \
4072 do {                                                                \
4073   if (yydebug)                                                        \
4074     yy_stack_print ((Bottom), (Top));                                \
4075 } while (YYID (0))
4076
4077
4078 /*------------------------------------------------.
4079 | Report that the YYRULE is going to be reduced.  |
4080 `------------------------------------------------*/
4081
4082 #if (defined __STDC__ || defined __C99__FUNC__ \
4083      || defined __cplusplus || defined _MSC_VER)
4084 static void
4085 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
4086 #else
4087 static void
4088 yy_reduce_print (yyvsp, yyrule)
4089     YYSTYPE *yyvsp;
4090     int yyrule;
4091 #endif
4092 {
4093   int yynrhs = yyr2[yyrule];
4094   int yyi;
4095   unsigned long int yylno = yyrline[yyrule];
4096   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4097              yyrule - 1, yylno);
4098   /* The symbols being reduced.  */
4099   for (yyi = 0; yyi < yynrhs; yyi++)
4100     {
4101       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
4102       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4103                        &(yyvsp[(yyi + 1) - (yynrhs)])
4104                                               );
4105       YYFPRINTF (stderr, "\n");
4106     }
4107 }
4108
4109 # define YY_REDUCE_PRINT(Rule)                \
4110 do {                                        \
4111   if (yydebug)                                \
4112     yy_reduce_print (yyvsp, Rule); \
4113 } while (YYID (0))
4114
4115 /* Nonzero means print parse trace.  It is left uninitialized so that
4116    multiple parsers can coexist.  */
4117 int yydebug;
4118 #else /* !YYDEBUG */
4119 # define YYDPRINTF(Args)
4120 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4121 # define YY_STACK_PRINT(Bottom, Top)
4122 # define YY_REDUCE_PRINT(Rule)
4123 #endif /* !YYDEBUG */
4124
4125
4126 /* YYINITDEPTH -- initial size of the parser's stacks.  */
4127 #ifndef        YYINITDEPTH
4128 # define YYINITDEPTH 200
4129 #endif
4130
4131 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4132    if the built-in stack extension method is used).
4133
4134    Do not make this value too large; the results are undefined if
4135    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4136    evaluated with infinite-precision integer arithmetic.  */
4137
4138 #ifndef YYMAXDEPTH
4139 # define YYMAXDEPTH 10000
4140 #endif
4141
4142 \f
4143
4144 #if YYERROR_VERBOSE
4145
4146 # ifndef yystrlen
4147 #  if defined __GLIBC__ && defined _STRING_H
4148 #   define yystrlen strlen
4149 #  else
4150 /* Return the length of YYSTR.  */
4151 #if (defined __STDC__ || defined __C99__FUNC__ \
4152      || defined __cplusplus || defined _MSC_VER)
4153 static YYSIZE_T
4154 yystrlen (const char *yystr)
4155 #else
4156 static YYSIZE_T
4157 yystrlen (yystr)
4158     const char *yystr;
4159 #endif
4160 {
4161   YYSIZE_T yylen;
4162   for (yylen = 0; yystr[yylen]; yylen++)
4163     continue;
4164   return yylen;
4165 }
4166 #  endif
4167 # endif
4168
4169 # ifndef yystpcpy
4170 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4171 #   define yystpcpy stpcpy
4172 #  else
4173 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4174    YYDEST.  */
4175 #if (defined __STDC__ || defined __C99__FUNC__ \
4176      || defined __cplusplus || defined _MSC_VER)
4177 static char *
4178 yystpcpy (char *yydest, const char *yysrc)
4179 #else
4180 static char *
4181 yystpcpy (yydest, yysrc)
4182     char *yydest;
4183     const char *yysrc;
4184 #endif
4185 {
4186   char *yyd = yydest;
4187   const char *yys = yysrc;
4188
4189   while ((*yyd++ = *yys++) != '\0')
4190     continue;
4191
4192   return yyd - 1;
4193 }
4194 #  endif
4195 # endif
4196
4197 # ifndef yytnamerr
4198 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4199    quotes and backslashes, so that it's suitable for yyerror.  The
4200    heuristic is that double-quoting is unnecessary unless the string
4201    contains an apostrophe, a comma, or backslash (other than
4202    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
4203    null, do not copy; instead, return the length of what the result
4204    would have been.  */
4205 static YYSIZE_T
4206 yytnamerr (char *yyres, const char *yystr)
4207 {
4208   if (*yystr == '"')
4209     {
4210       YYSIZE_T yyn = 0;
4211       char const *yyp = yystr;
4212
4213       for (;;)
4214         switch (*++yyp)
4215           {
4216           case '\'':
4217           case ',':
4218             goto do_not_strip_quotes;
4219
4220           case '\\':
4221             if (*++yyp != '\\')
4222               goto do_not_strip_quotes;
4223             /* Fall through.  */
4224           default:
4225             if (yyres)
4226               yyres[yyn] = *yyp;
4227             yyn++;
4228             break;
4229
4230           case '"':
4231             if (yyres)
4232               yyres[yyn] = '\0';
4233             return yyn;
4234           }
4235     do_not_strip_quotes: ;
4236     }
4237
4238   if (! yyres)
4239     return yystrlen (yystr);
4240
4241   return yystpcpy (yyres, yystr) - yyres;
4242 }
4243 # endif
4244
4245 /* Copy into YYRESULT an error message about the unexpected token
4246    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
4247    including the terminating null byte.  If YYRESULT is null, do not
4248    copy anything; just return the number of bytes that would be
4249    copied.  As a special case, return 0 if an ordinary "syntax error"
4250    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
4251    size calculation.  */
4252 static YYSIZE_T
4253 yysyntax_error (char *yyresult, int yystate, int yychar)
4254 {
4255   int yyn = yypact[yystate];
4256
4257   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
4258     return 0;
4259   else
4260     {
4261       int yytype = YYTRANSLATE (yychar);
4262       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
4263       YYSIZE_T yysize = yysize0;
4264       YYSIZE_T yysize1;
4265       int yysize_overflow = 0;
4266       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4267       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4268       int yyx;
4269
4270 # if 0
4271       /* This is so xgettext sees the translatable formats that are
4272          constructed on the fly.  */
4273       YY_("syntax error, unexpected %s");
4274       YY_("syntax error, unexpected %s, expecting %s");
4275       YY_("syntax error, unexpected %s, expecting %s or %s");
4276       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
4277       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
4278 # endif
4279       char *yyfmt;
4280       char const *yyf;
4281       static char const yyunexpected[] = "syntax error, unexpected %s";
4282       static char const yyexpecting[] = ", expecting %s";
4283       static char const yyor[] = " or %s";
4284       char yyformat[sizeof yyunexpected
4285                     + sizeof yyexpecting - 1
4286                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
4287                        * (sizeof yyor - 1))];
4288       char const *yyprefix = yyexpecting;
4289
4290       /* Start YYX at -YYN if negative to avoid negative indexes in
4291          YYCHECK.  */
4292       int yyxbegin = yyn < 0 ? -yyn : 0;
4293
4294       /* Stay within bounds of both yycheck and yytname.  */
4295       int yychecklim = YYLAST - yyn + 1;
4296       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4297       int yycount = 1;
4298
4299       yyarg[0] = yytname[yytype];
4300       yyfmt = yystpcpy (yyformat, yyunexpected);
4301
4302       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4303         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
4304           {
4305             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4306               {
4307                 yycount = 1;
4308                 yysize = yysize0;
4309                 yyformat[sizeof yyunexpected - 1] = '\0';
4310                 break;
4311               }
4312             yyarg[yycount++] = yytname[yyx];
4313             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4314             yysize_overflow |= (yysize1 < yysize);
4315             yysize = yysize1;
4316             yyfmt = yystpcpy (yyfmt, yyprefix);
4317             yyprefix = yyor;
4318           }
4319
4320       yyf = YY_(yyformat);
4321       yysize1 = yysize + yystrlen (yyf);
4322       yysize_overflow |= (yysize1 < yysize);
4323       yysize = yysize1;
4324
4325       if (yysize_overflow)
4326         return YYSIZE_MAXIMUM;
4327
4328       if (yyresult)
4329         {
4330           /* Avoid sprintf, as that infringes on the user's name space.
4331              Don't have undefined behavior even if the translation
4332              produced a string with the wrong number of "%s"s.  */
4333           char *yyp = yyresult;
4334           int yyi = 0;
4335           while ((*yyp = *yyf) != '\0')
4336             {
4337               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
4338                 {
4339                   yyp += yytnamerr (yyp, yyarg[yyi++]);
4340                   yyf += 2;
4341                 }
4342               else
4343                 {
4344                   yyp++;
4345                   yyf++;
4346                 }
4347             }
4348         }
4349       return yysize;
4350     }
4351 }
4352 #endif /* YYERROR_VERBOSE */
4353 \f
4354
4355 /*-----------------------------------------------.
4356 | Release the memory associated to this symbol.  |
4357 `-----------------------------------------------*/
4358
4359 /*ARGSUSED*/
4360 #if (defined __STDC__ || defined __C99__FUNC__ \
4361      || defined __cplusplus || defined _MSC_VER)
4362 static void
4363 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
4364 #else
4365 static void
4366 yydestruct (yymsg, yytype, yyvaluep)
4367     const char *yymsg;
4368     int yytype;
4369     YYSTYPE *yyvaluep;
4370 #endif
4371 {
4372   YYUSE (yyvaluep);
4373
4374   if (!yymsg)
4375     yymsg = "Deleting";
4376   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4377
4378   switch (yytype)
4379     {
4380
4381       default:
4382         break;
4383     }
4384 }
4385
4386 /* Prevent warnings from -Wmissing-prototypes.  */
4387 #ifdef YYPARSE_PARAM
4388 #if defined __STDC__ || defined __cplusplus
4389 int yyparse (void *YYPARSE_PARAM);
4390 #else
4391 int yyparse ();
4392 #endif
4393 #else /* ! YYPARSE_PARAM */
4394 #if defined __STDC__ || defined __cplusplus
4395 int yyparse (void);
4396 #else
4397 int yyparse ();
4398 #endif
4399 #endif /* ! YYPARSE_PARAM */
4400
4401
4402 /* The lookahead symbol.  */
4403 int yychar;
4404
4405 /* The semantic value of the lookahead symbol.  */
4406 YYSTYPE yylval;
4407
4408 /* Number of syntax errors so far.  */
4409 int yynerrs;
4410
4411
4412
4413 /*-------------------------.
4414 | yyparse or yypush_parse.  |
4415 `-------------------------*/
4416
4417 #ifdef YYPARSE_PARAM
4418 #if (defined __STDC__ || defined __C99__FUNC__ \
4419      || defined __cplusplus || defined _MSC_VER)
4420 int
4421 yyparse (void *YYPARSE_PARAM)
4422 #else
4423 int
4424 yyparse (YYPARSE_PARAM)
4425     void *YYPARSE_PARAM;
4426 #endif
4427 #else /* ! YYPARSE_PARAM */
4428 #if (defined __STDC__ || defined __C99__FUNC__ \
4429      || defined __cplusplus || defined _MSC_VER)
4430 int
4431 yyparse (void)
4432 #else
4433 int
4434 yyparse ()
4435
4436 #endif
4437 #endif
4438 {
4439
4440
4441     int yystate;
4442     /* Number of tokens to shift before error messages enabled.  */
4443     int yyerrstatus;
4444
4445     /* The stacks and their tools:
4446        `yyss': related to states.
4447        `yyvs': related to semantic values.
4448
4449        Refer to the stacks thru separate pointers, to allow yyoverflow
4450        to reallocate them elsewhere.  */
4451
4452     /* The state stack.  */
4453     yytype_int16 yyssa[YYINITDEPTH];
4454     yytype_int16 *yyss;
4455     yytype_int16 *yyssp;
4456
4457     /* The semantic value stack.  */
4458     YYSTYPE yyvsa[YYINITDEPTH];
4459     YYSTYPE *yyvs;
4460     YYSTYPE *yyvsp;
4461
4462     YYSIZE_T yystacksize;
4463
4464   int yyn;
4465   int yyresult;
4466   /* Lookahead token as an internal (translated) token number.  */
4467   int yytoken;
4468   /* The variables used to return semantic value and location from the
4469      action routines.  */
4470   YYSTYPE yyval;
4471
4472 #if YYERROR_VERBOSE
4473   /* Buffer for error messages, and its allocated size.  */
4474   char yymsgbuf[128];
4475   char *yymsg = yymsgbuf;
4476   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
4477 #endif
4478
4479 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
4480
4481   /* The number of symbols on the RHS of the reduced rule.
4482      Keep to zero when no symbol should be popped.  */
4483   int yylen = 0;
4484
4485   yytoken = 0;
4486   yyss = yyssa;
4487   yyvs = yyvsa;
4488   yystacksize = YYINITDEPTH;
4489
4490   YYDPRINTF ((stderr, "Starting parse\n"));
4491
4492   yystate = 0;
4493   yyerrstatus = 0;
4494   yynerrs = 0;
4495   yychar = YYEMPTY; /* Cause a token to be read.  */
4496
4497   /* Initialize stack pointers.
4498      Waste one element of value and location stack
4499      so that they stay on the same level as the state stack.
4500      The wasted elements are never initialized.  */
4501   yyssp = yyss;
4502   yyvsp = yyvs;
4503
4504   goto yysetstate;
4505
4506 /*------------------------------------------------------------.
4507 | yynewstate -- Push a new state, which is found in yystate.  |
4508 `------------------------------------------------------------*/
4509  yynewstate:
4510   /* In all cases, when you get here, the value and location stacks
4511      have just been pushed.  So pushing a state here evens the stacks.  */
4512   yyssp++;
4513
4514  yysetstate:
4515   *yyssp = yystate;
4516
4517   if (yyss + yystacksize - 1 <= yyssp)
4518     {
4519       /* Get the current used size of the three stacks, in elements.  */
4520       YYSIZE_T yysize = yyssp - yyss + 1;
4521
4522 #ifdef yyoverflow
4523       {
4524         /* Give user a chance to reallocate the stack.  Use copies of
4525            these so that the &'s don't force the real ones into
4526            memory.  */
4527         YYSTYPE *yyvs1 = yyvs;
4528         yytype_int16 *yyss1 = yyss;
4529
4530         /* Each stack pointer address is followed by the size of the
4531            data in use in that stack, in bytes.  This used to be a
4532            conditional around just the two extra args, but that might
4533            be undefined if yyoverflow is a macro.  */
4534         yyoverflow (YY_("memory exhausted"),
4535                     &yyss1, yysize * sizeof (*yyssp),
4536                     &yyvs1, yysize * sizeof (*yyvsp),
4537                     &yystacksize);
4538
4539         yyss = yyss1;
4540         yyvs = yyvs1;
4541       }
4542 #else /* no yyoverflow */
4543 # ifndef YYSTACK_RELOCATE
4544       goto yyexhaustedlab;
4545 # else
4546       /* Extend the stack our own way.  */
4547       if (YYMAXDEPTH <= yystacksize)
4548         goto yyexhaustedlab;
4549       yystacksize *= 2;
4550       if (YYMAXDEPTH < yystacksize)
4551         yystacksize = YYMAXDEPTH;
4552
4553       {
4554         yytype_int16 *yyss1 = yyss;
4555         union yyalloc *yyptr =
4556           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4557         if (! yyptr)
4558           goto yyexhaustedlab;
4559         YYSTACK_RELOCATE (yyss_alloc, yyss);
4560         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4561 #  undef YYSTACK_RELOCATE
4562         if (yyss1 != yyssa)
4563           YYSTACK_FREE (yyss1);
4564       }
4565 # endif
4566 #endif /* no yyoverflow */
4567
4568       yyssp = yyss + yysize - 1;
4569       yyvsp = yyvs + yysize - 1;
4570
4571       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4572                   (unsigned long int) yystacksize));
4573
4574       if (yyss + yystacksize - 1 <= yyssp)
4575         YYABORT;
4576     }
4577
4578   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4579
4580   if (yystate == YYFINAL)
4581     YYACCEPT;
4582
4583   goto yybackup;
4584
4585 /*-----------.
4586 | yybackup.  |
4587 `-----------*/
4588 yybackup:
4589
4590   /* Do appropriate processing given the current state.  Read a
4591      lookahead token if we need one and don't already have one.  */
4592
4593   /* First try to decide what to do without reference to lookahead token.  */
4594   yyn = yypact[yystate];
4595   if (yyn == YYPACT_NINF)
4596     goto yydefault;
4597
4598   /* Not known => get a lookahead token if don't already have one.  */
4599
4600   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
4601   if (yychar == YYEMPTY)
4602     {
4603       YYDPRINTF ((stderr, "Reading a token: "));
4604       yychar = YYLEX;
4605     }
4606
4607   if (yychar <= YYEOF)
4608     {
4609       yychar = yytoken = YYEOF;
4610       YYDPRINTF ((stderr, "Now at end of input.\n"));
4611     }
4612   else
4613     {
4614       yytoken = YYTRANSLATE (yychar);
4615       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4616     }
4617
4618   /* If the proper action on seeing token YYTOKEN is to reduce or to
4619      detect an error, take that action.  */
4620   yyn += yytoken;
4621   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4622     goto yydefault;
4623   yyn = yytable[yyn];
4624   if (yyn <= 0)
4625     {
4626       if (yyn == 0 || yyn == YYTABLE_NINF)
4627         goto yyerrlab;
4628       yyn = -yyn;
4629       goto yyreduce;
4630     }
4631
4632   /* Count tokens shifted since error; after three, turn off error
4633      status.  */
4634   if (yyerrstatus)
4635     yyerrstatus--;
4636
4637   /* Shift the lookahead token.  */
4638   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4639
4640   /* Discard the shifted token.  */
4641   yychar = YYEMPTY;
4642
4643   yystate = yyn;
4644   *++yyvsp = yylval;
4645
4646   goto yynewstate;
4647
4648
4649 /*-----------------------------------------------------------.
4650 | yydefault -- do the default action for the current state.  |
4651 `-----------------------------------------------------------*/
4652 yydefault:
4653   yyn = yydefact[yystate];
4654   if (yyn == 0)
4655     goto yyerrlab;
4656   goto yyreduce;
4657
4658
4659 /*-----------------------------.
4660 | yyreduce -- Do a reduction.  |
4661 `-----------------------------*/
4662 yyreduce:
4663   /* yyn is the number of a rule to reduce with.  */
4664   yylen = yyr2[yyn];
4665
4666   /* If YYLEN is nonzero, implement the default value of the action:
4667      `$$ = $1'.
4668
4669      Otherwise, the following line sets YYVAL to garbage.
4670      This behavior is undocumented and Bison
4671      users should not rely upon it.  Assigning to YYVAL
4672      unconditionally makes the parser a bit smaller, and it avoids a
4673      GCC warning that YYVAL may be used uninitialized.  */
4674   yyval = yyvsp[1-yylen];
4675
4676
4677   YY_REDUCE_PRINT (yyn);
4678   switch (yyn)
4679     {
4680         case 4:
4681
4682 /* Line 1455 of yacc.c  */
4683 #line 1464 "vtkParse.y"
4684     {
4685       startSig();
4686       clearType();
4687       clearTypeId();
4688       clearTemplate();
4689       closeComment();
4690     }
4691     break;
4692
4693   case 27:
4694
4695 /* Line 1455 of yacc.c  */
4696 #line 1509 "vtkParse.y"
4697     { pushNamespace((yyvsp[(2) - (2)].str)); }
4698     break;
4699
4700   case 28:
4701
4702 /* Line 1455 of yacc.c  */
4703 #line 1510 "vtkParse.y"
4704     { popNamespace(); }
4705     break;
4706
4707   case 36:
4708
4709 /* Line 1455 of yacc.c  */
4710 #line 1532 "vtkParse.y"
4711     { pushType(); }
4712     break;
4713
4714   case 37:
4715
4716 /* Line 1455 of yacc.c  */
4717 #line 1533 "vtkParse.y"
4718     {
4719       const char *name = (currentClass ? currentClass->Name : NULL);
4720       popType();
4721       clearTypeId();
4722       if (name)
4723         {
4724         setTypeId(name);
4725         setTypeBase(guess_id_type(name));
4726         }
4727       end_class();
4728     }
4729     break;
4730
4731   case 38:
4732
4733 /* Line 1455 of yacc.c  */
4734 #line 1546 "vtkParse.y"
4735     { start_class((yyvsp[(2) - (2)].str), (yyvsp[(1) - (2)].integer)); }
4736     break;
4737
4738   case 40:
4739
4740 /* Line 1455 of yacc.c  */
4741 #line 1548 "vtkParse.y"
4742     { start_class(NULL, (yyvsp[(1) - (1)].integer)); }
4743     break;
4744
4745   case 42:
4746
4747 /* Line 1455 of yacc.c  */
4748 #line 1552 "vtkParse.y"
4749     { (yyval.integer) = 0; }
4750     break;
4751
4752   case 43:
4753
4754 /* Line 1455 of yacc.c  */
4755 #line 1553 "vtkParse.y"
4756     { (yyval.integer) = 1; }
4757     break;
4758
4759   case 44:
4760
4761 /* Line 1455 of yacc.c  */
4762 #line 1554 "vtkParse.y"
4763     { (yyval.integer) = 2; }
4764     break;
4765
4766   case 46:
4767
4768 /* Line 1455 of yacc.c  */
4769 #line 1558 "vtkParse.y"
4770     {
4771       startSig();
4772       clearType();
4773       clearTypeId();
4774       clearTemplate();
4775       closeComment();
4776     }
4777     break;
4778
4779   case 49:
4780
4781 /* Line 1455 of yacc.c  */
4782 #line 1570 "vtkParse.y"
4783     { access_level = VTK_ACCESS_PUBLIC; }
4784     break;
4785
4786   case 50:
4787
4788 /* Line 1455 of yacc.c  */
4789 #line 1571 "vtkParse.y"
4790     { access_level = VTK_ACCESS_PRIVATE; }
4791     break;
4792
4793   case 51:
4794
4795 /* Line 1455 of yacc.c  */
4796 #line 1572 "vtkParse.y"
4797     { access_level = VTK_ACCESS_PROTECTED; }
4798     break;
4799
4800   case 70:
4801
4802 /* Line 1455 of yacc.c  */
4803 #line 1597 "vtkParse.y"
4804     { output_friend_function(); }
4805     break;
4806
4807   case 76:
4808
4809 /* Line 1455 of yacc.c  */
4810 #line 1611 "vtkParse.y"
4811     { add_base_class(currentClass, (yyvsp[(1) - (1)].str), access_level, 0); }
4812     break;
4813
4814   case 77:
4815
4816 /* Line 1455 of yacc.c  */
4817 #line 1613 "vtkParse.y"
4818     { add_base_class(currentClass, (yyvsp[(3) - (3)].str), (yyvsp[(2) - (3)].integer), 1); }
4819     break;
4820
4821   case 78:
4822
4823 /* Line 1455 of yacc.c  */
4824 #line 1615 "vtkParse.y"
4825     { add_base_class(currentClass, (yyvsp[(3) - (3)].str), (yyvsp[(1) - (3)].integer), (yyvsp[(2) - (3)].integer)); }
4826     break;
4827
4828   case 79:
4829
4830 /* Line 1455 of yacc.c  */
4831 #line 1618 "vtkParse.y"
4832     { (yyval.integer) = 0; }
4833     break;
4834
4835   case 80:
4836
4837 /* Line 1455 of yacc.c  */
4838 #line 1619 "vtkParse.y"
4839     { (yyval.integer) = 1; }
4840     break;
4841
4842   case 81:
4843
4844 /* Line 1455 of yacc.c  */
4845 #line 1622 "vtkParse.y"
4846     { (yyval.integer) = access_level; }
4847     break;
4848
4849   case 83:
4850
4851 /* Line 1455 of yacc.c  */
4852 #line 1626 "vtkParse.y"
4853     { (yyval.integer) = VTK_ACCESS_PUBLIC; }
4854     break;
4855
4856   case 84:
4857
4858 /* Line 1455 of yacc.c  */
4859 #line 1627 "vtkParse.y"
4860     { (yyval.integer) = VTK_ACCESS_PRIVATE; }
4861     break;
4862
4863   case 85:
4864
4865 /* Line 1455 of yacc.c  */
4866 #line 1628 "vtkParse.y"
4867     { (yyval.integer) = VTK_ACCESS_PROTECTED; }
4868     break;
4869
4870   case 88:
4871
4872 /* Line 1455 of yacc.c  */
4873 #line 1644 "vtkParse.y"
4874     { pushType(); start_enum((yyvsp[(1) - (2)].str)); }
4875     break;
4876
4877   case 89:
4878
4879 /* Line 1455 of yacc.c  */
4880 #line 1645 "vtkParse.y"
4881     {
4882       popType();
4883       clearTypeId();
4884       if ((yyvsp[(1) - (5)].str) != NULL)
4885         {
4886         setTypeId((yyvsp[(1) - (5)].str));
4887         setTypeBase(guess_id_type((yyvsp[(1) - (5)].str)));
4888         }
4889       end_enum();
4890     }
4891     break;
4892
4893   case 90:
4894
4895 /* Line 1455 of yacc.c  */
4896 #line 1657 "vtkParse.y"
4897     { (yyval.str) = (yyvsp[(2) - (2)].str); }
4898     break;
4899
4900   case 91:
4901
4902 /* Line 1455 of yacc.c  */
4903 #line 1658 "vtkParse.y"
4904     { (yyval.str) = NULL; }
4905     break;
4906
4907   case 97:
4908
4909 /* Line 1455 of yacc.c  */
4910 #line 1669 "vtkParse.y"
4911     { add_enum((yyvsp[(1) - (1)].str), NULL); }
4912     break;
4913
4914   case 98:
4915
4916 /* Line 1455 of yacc.c  */
4917 #line 1670 "vtkParse.y"
4918     { postSig("="); markSig(); }
4919     break;
4920
4921   case 99:
4922
4923 /* Line 1455 of yacc.c  */
4924 #line 1671 "vtkParse.y"
4925     { chopSig(); add_enum((yyvsp[(1) - (4)].str), copySig()); }
4926     break;
4927
4928   case 120:
4929
4930 /* Line 1455 of yacc.c  */
4931 #line 1724 "vtkParse.y"
4932     { pushFunction(); postSig("("); }
4933     break;
4934
4935   case 121:
4936
4937 /* Line 1455 of yacc.c  */
4938 #line 1725 "vtkParse.y"
4939     { postSig(")"); }
4940     break;
4941
4942   case 122:
4943
4944 /* Line 1455 of yacc.c  */
4945 #line 1726 "vtkParse.y"
4946     { (yyval.integer) = VTK_PARSE_FUNCTION; popFunction(); }
4947     break;
4948
4949   case 123:
4950
4951 /* Line 1455 of yacc.c  */
4952 #line 1730 "vtkParse.y"
4953     {
4954       ValueInfo *item = (ValueInfo *)malloc(sizeof(ValueInfo));
4955       vtkParse_InitValue(item);
4956       item->ItemType = VTK_TYPEDEF_INFO;
4957       item->Access = access_level;
4958
4959       handle_complex_type(item, getType(), (yyvsp[(1) - (1)].integer), getSig());
4960
4961       if (getVarName())
4962         {
4963         item->Name = getVarName();
4964         }
4965
4966       if (item->Class == NULL)
4967         {
4968         vtkParse_FreeValue(item);
4969         }
4970       else if (currentClass)
4971         {
4972         vtkParse_AddTypedefToClass(currentClass, item);
4973         }
4974       else
4975         {
4976         vtkParse_AddTypedefToNamespace(currentNamespace, item);
4977         }
4978     }
4979     break;
4980
4981   case 124:
4982
4983 /* Line 1455 of yacc.c  */
4984 #line 1763 "vtkParse.y"
4985     { add_using((yyvsp[(2) - (3)].str), 0); }
4986     break;
4987
4988   case 126:
4989
4990 /* Line 1455 of yacc.c  */
4991 #line 1767 "vtkParse.y"
4992     { (yyval.str) = (yyvsp[(2) - (2)].str); }
4993     break;
4994
4995   case 127:
4996
4997 /* Line 1455 of yacc.c  */
4998 #line 1769 "vtkParse.y"
4999     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
5000     break;
5001
5002   case 128:
5003
5004 /* Line 1455 of yacc.c  */
5005 #line 1771 "vtkParse.y"
5006     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
5007     break;
5008
5009   case 129:
5010
5011 /* Line 1455 of yacc.c  */
5012 #line 1773 "vtkParse.y"
5013     { (yyval.str) = vtkstrcat3((yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)); }
5014     break;
5015
5016   case 130:
5017
5018 /* Line 1455 of yacc.c  */
5019 #line 1775 "vtkParse.y"
5020     { (yyval.str) = vtkstrcat3((yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)); }
5021     break;
5022
5023   case 131:
5024
5025 /* Line 1455 of yacc.c  */
5026 #line 1778 "vtkParse.y"
5027     { add_using((yyvsp[(3) - (4)].str), 1); }
5028     break;
5029
5030   case 132:
5031
5032 /* Line 1455 of yacc.c  */
5033 #line 1786 "vtkParse.y"
5034     { postSig("template<> "); clearTypeId(); }
5035     break;
5036
5037   case 133:
5038
5039 /* Line 1455 of yacc.c  */
5040 #line 1788 "vtkParse.y"
5041     {
5042       postSig("template<");
5043       pushType();
5044       clearType();
5045       clearTypeId();
5046       startTemplate();
5047     }
5048     break;
5049
5050   case 134:
5051
5052 /* Line 1455 of yacc.c  */
5053 #line 1796 "vtkParse.y"
5054     {
5055       chopSig();
5056       if (getSig()[getSigLength()-1] == '>') { postSig(" "); }
5057       postSig("> ");
5058       clearTypeId();
5059       popType();
5060     }
5061     break;
5062
5063   case 136:
5064
5065 /* Line 1455 of yacc.c  */
5066 #line 1807 "vtkParse.y"
5067     { chopSig(); postSig(", "); clearType(); clearTypeId(); }
5068     break;
5069
5070   case 138:
5071
5072 /* Line 1455 of yacc.c  */
5073 #line 1811 "vtkParse.y"
5074     { markSig(); }
5075     break;
5076
5077   case 139:
5078
5079 /* Line 1455 of yacc.c  */
5080 #line 1813 "vtkParse.y"
5081     { add_template_parameter(getType(), (yyvsp[(3) - (3)].integer), copySig()); }
5082     break;
5083
5084   case 141:
5085
5086 /* Line 1455 of yacc.c  */
5087 #line 1815 "vtkParse.y"
5088     { markSig(); }
5089     break;
5090
5091   case 142:
5092
5093 /* Line 1455 of yacc.c  */
5094 #line 1817 "vtkParse.y"
5095     { add_template_parameter(0, (yyvsp[(3) - (3)].integer), copySig()); }
5096     break;
5097
5098   case 144:
5099
5100 /* Line 1455 of yacc.c  */
5101 #line 1819 "vtkParse.y"
5102     { pushTemplate(); markSig(); }
5103     break;
5104
5105   case 145:
5106
5107 /* Line 1455 of yacc.c  */
5108 #line 1820 "vtkParse.y"
5109     { postSig("class "); }
5110     break;
5111
5112   case 146:
5113
5114 /* Line 1455 of yacc.c  */
5115 #line 1822 "vtkParse.y"
5116     {
5117       int i;
5118       TemplateInfo *newTemplate = currentTemplate;
5119       popTemplate();
5120       add_template_parameter(0, (yyvsp[(5) - (5)].integer), copySig());
5121       i = currentTemplate->NumberOfParameters-1;
5122       currentTemplate->Parameters[i]->Template = newTemplate;
5123     }
5124     break;
5125
5126   case 148:
5127
5128 /* Line 1455 of yacc.c  */
5129 #line 1833 "vtkParse.y"
5130     { postSig("class "); }
5131     break;
5132
5133   case 149:
5134
5135 /* Line 1455 of yacc.c  */
5136 #line 1834 "vtkParse.y"
5137     { postSig("typename "); }
5138     break;
5139
5140   case 152:
5141
5142 /* Line 1455 of yacc.c  */
5143 #line 1840 "vtkParse.y"
5144     { postSig("="); markSig(); }
5145     break;
5146
5147   case 153:
5148
5149 /* Line 1455 of yacc.c  */
5150 #line 1842 "vtkParse.y"
5151     {
5152       int i = currentTemplate->NumberOfParameters-1;
5153       ValueInfo *param = currentTemplate->Parameters[i];
5154       chopSig();
5155       param->Value = copySig();
5156     }
5157     break;
5158
5159   case 156:
5160
5161 /* Line 1455 of yacc.c  */
5162 #line 1859 "vtkParse.y"
5163     { output_function(); }
5164     break;
5165
5166   case 157:
5167
5168 /* Line 1455 of yacc.c  */
5169 #line 1860 "vtkParse.y"
5170     { output_function(); }
5171     break;
5172
5173   case 158:
5174
5175 /* Line 1455 of yacc.c  */
5176 #line 1861 "vtkParse.y"
5177     { reject_function(); }
5178     break;
5179
5180   case 159:
5181
5182 /* Line 1455 of yacc.c  */
5183 #line 1862 "vtkParse.y"
5184     { reject_function(); }
5185     break;
5186
5187   case 167:
5188
5189 /* Line 1455 of yacc.c  */
5190 #line 1878 "vtkParse.y"
5191     { output_function(); }
5192     break;
5193
5194   case 177:
5195
5196 /* Line 1455 of yacc.c  */
5197 #line 1895 "vtkParse.y"
5198     {
5199       postSig("(");
5200       set_return(currentFunction, getType(), getTypeId(), 0);
5201     }
5202     break;
5203
5204   case 178:
5205
5206 /* Line 1455 of yacc.c  */
5207 #line 1899 "vtkParse.y"
5208     { postSig(")"); }
5209     break;
5210
5211   case 179:
5212
5213 /* Line 1455 of yacc.c  */
5214 #line 1901 "vtkParse.y"
5215     {
5216       postSig(";");
5217       closeSig();
5218       currentFunction->IsOperator = 1;
5219       currentFunction->Name = "operator typecast";
5220       currentFunction->Comment = vtkstrdup(getComment());
5221       vtkParseDebug("Parsed operator", "operator typecast");
5222     }
5223     break;
5224
5225   case 180:
5226
5227 /* Line 1455 of yacc.c  */
5228 #line 1912 "vtkParse.y"
5229     { (yyval.str) = copySig(); }
5230     break;
5231
5232   case 181:
5233
5234 /* Line 1455 of yacc.c  */
5235 #line 1915 "vtkParse.y"
5236     { postSig(")"); }
5237     break;
5238
5239   case 182:
5240
5241 /* Line 1455 of yacc.c  */
5242 #line 1916 "vtkParse.y"
5243     {
5244       postSig(";");
5245       closeSig();
5246       currentFunction->Name = (yyvsp[(1) - (3)].str);
5247       currentFunction->Comment = vtkstrdup(getComment());
5248       vtkParseDebug("Parsed operator", currentFunction->Name);
5249     }
5250     break;
5251
5252   case 183:
5253
5254 /* Line 1455 of yacc.c  */
5255 #line 1926 "vtkParse.y"
5256     {
5257       postSig("(");
5258       currentFunction->IsOperator = 1;
5259       set_return(currentFunction, getType(), getTypeId(), 0);
5260     }
5261     break;
5262
5263   case 185:
5264
5265 /* Line 1455 of yacc.c  */
5266 #line 1935 "vtkParse.y"
5267     { chopSig(); (yyval.str) = vtkstrcat(copySig(), (yyvsp[(2) - (2)].str)); postSig((yyvsp[(2) - (2)].str)); }
5268     break;
5269
5270   case 186:
5271
5272 /* Line 1455 of yacc.c  */
5273 #line 1938 "vtkParse.y"
5274     { markSig(); postSig("operator "); }
5275     break;
5276
5277   case 187:
5278
5279 /* Line 1455 of yacc.c  */
5280 #line 1942 "vtkParse.y"
5281     {
5282       postSig(";");
5283       closeSig();
5284       currentFunction->Name = (yyvsp[(1) - (2)].str);
5285       currentFunction->Comment = vtkstrdup(getComment());
5286       vtkParseDebug("Parsed func", currentFunction->Name);
5287     }
5288     break;
5289
5290   case 190:
5291
5292 /* Line 1455 of yacc.c  */
5293 #line 1954 "vtkParse.y"
5294     { postSig(" throw "); }
5295     break;
5296
5297   case 191:
5298
5299 /* Line 1455 of yacc.c  */
5300 #line 1954 "vtkParse.y"
5301     { chopSig(); }
5302     break;
5303
5304   case 192:
5305
5306 /* Line 1455 of yacc.c  */
5307 #line 1955 "vtkParse.y"
5308     { postSig(" const"); currentFunction->IsConst = 1; }
5309     break;
5310
5311   case 193:
5312
5313 /* Line 1455 of yacc.c  */
5314 #line 1957 "vtkParse.y"
5315     {
5316       postSig(" = 0");
5317       currentFunction->IsPureVirtual = 1;
5318       if (currentClass) { currentClass->IsAbstract = 1; }
5319     }
5320     break;
5321
5322   case 196:
5323
5324 /* Line 1455 of yacc.c  */
5325 #line 1969 "vtkParse.y"
5326     {
5327       postSig("(");
5328       set_return(currentFunction, getType(), getTypeId(), 0);
5329     }
5330     break;
5331
5332   case 197:
5333
5334 /* Line 1455 of yacc.c  */
5335 #line 1973 "vtkParse.y"
5336     { postSig(")"); }
5337     break;
5338
5339   case 200:
5340
5341 /* Line 1455 of yacc.c  */
5342 #line 1985 "vtkParse.y"
5343     { closeSig(); }
5344     break;
5345
5346   case 201:
5347
5348 /* Line 1455 of yacc.c  */
5349 #line 1986 "vtkParse.y"
5350     { openSig(); }
5351     break;
5352
5353   case 202:
5354
5355 /* Line 1455 of yacc.c  */
5356 #line 1987 "vtkParse.y"
5357     {
5358       postSig(";");
5359       closeSig();
5360       if (getType() & VTK_PARSE_VIRTUAL)
5361         {
5362         currentFunction->IsVirtual = 1;
5363         }
5364       if (getType() & VTK_PARSE_EXPLICIT)
5365         {
5366         currentFunction->IsExplicit = 1;
5367         }
5368       currentFunction->Name = (yyvsp[(1) - (5)].str);
5369       currentFunction->Comment = vtkstrdup(getComment());
5370       vtkParseDebug("Parsed func", currentFunction->Name);
5371     }
5372     break;
5373
5374   case 203:
5375
5376 /* Line 1455 of yacc.c  */
5377 #line 2004 "vtkParse.y"
5378     { pushType(); postSig("("); }
5379     break;
5380
5381   case 204:
5382
5383 /* Line 1455 of yacc.c  */
5384 #line 2005 "vtkParse.y"
5385     { popType(); postSig(")"); }
5386     break;
5387
5388   case 211:
5389
5390 /* Line 1455 of yacc.c  */
5391 #line 2022 "vtkParse.y"
5392     { clearType(); clearTypeId(); }
5393     break;
5394
5395   case 213:
5396
5397 /* Line 1455 of yacc.c  */
5398 #line 2025 "vtkParse.y"
5399     { clearType(); clearTypeId(); }
5400     break;
5401
5402   case 214:
5403
5404 /* Line 1455 of yacc.c  */
5405 #line 2026 "vtkParse.y"
5406     { clearType(); clearTypeId(); postSig(", "); }
5407     break;
5408
5409   case 216:
5410
5411 /* Line 1455 of yacc.c  */
5412 #line 2029 "vtkParse.y"
5413     { currentFunction->IsVariadic = 1; postSig(", ..."); }
5414     break;
5415
5416   case 217:
5417
5418 /* Line 1455 of yacc.c  */
5419 #line 2032 "vtkParse.y"
5420     { markSig(); }
5421     break;
5422
5423   case 218:
5424
5425 /* Line 1455 of yacc.c  */
5426 #line 2034 "vtkParse.y"
5427     {
5428       ValueInfo *param = (ValueInfo *)malloc(sizeof(ValueInfo));
5429       vtkParse_InitValue(param);
5430
5431       handle_complex_type(param, getType(), (yyvsp[(3) - (3)].integer), copySig());
5432       add_legacy_parameter(currentFunction, param);
5433
5434       if (getVarName())
5435         {
5436         param->Name = getVarName();
5437         }
5438
5439       vtkParse_AddParameterToFunction(currentFunction, param);
5440     }
5441     break;
5442
5443   case 219:
5444
5445 /* Line 1455 of yacc.c  */
5446 #line 2049 "vtkParse.y"
5447     {
5448       int i = currentFunction->NumberOfParameters-1;
5449       if (getVarValue())
5450         {
5451         currentFunction->Parameters[i]->Value = getVarValue();
5452         }
5453     }
5454     break;
5455
5456   case 220:
5457
5458 /* Line 1455 of yacc.c  */
5459 #line 2058 "vtkParse.y"
5460     { clearVarValue(); }
5461     break;
5462
5463   case 222:
5464
5465 /* Line 1455 of yacc.c  */
5466 #line 2062 "vtkParse.y"
5467     { postSig("="); clearVarValue(); markSig(); }
5468     break;
5469
5470   case 223:
5471
5472 /* Line 1455 of yacc.c  */
5473 #line 2063 "vtkParse.y"
5474     { chopSig(); setVarValue(copySig()); }
5475     break;
5476
5477   case 225:
5478
5479 /* Line 1455 of yacc.c  */
5480 #line 2074 "vtkParse.y"
5481     {
5482       unsigned int type = getType();
5483       ValueInfo *var = (ValueInfo *)malloc(sizeof(ValueInfo));
5484       vtkParse_InitValue(var);
5485       var->ItemType = VTK_VARIABLE_INFO;
5486       var->Access = access_level;
5487
5488       handle_complex_type(var, type, (yyvsp[(1) - (2)].integer), getSig());
5489
5490       var->Name = getVarName();
5491
5492       if (getVarValue())
5493         {
5494         var->Value = getVarValue();
5495         }
5496
5497       /* Is this a typedef? */
5498       if ((type & VTK_PARSE_TYPEDEF) != 0)
5499         {
5500         var->ItemType = VTK_TYPEDEF_INFO;
5501         if (currentClass)
5502           {
5503           vtkParse_AddVariableToClass(currentClass, var);
5504           }
5505         else
5506           {
5507           vtkParse_AddVariableToNamespace(currentNamespace, var);
5508           }
5509         }
5510       /* Is this a constant? */
5511       else if (((type & VTK_PARSE_CONST) != 0) && var->Value != NULL &&
5512           (((type & VTK_PARSE_INDIRECT) == 0) ||
5513            ((type & VTK_PARSE_INDIRECT) == VTK_PARSE_ARRAY)))
5514         {
5515         var->ItemType = VTK_CONSTANT_INFO;
5516         if (currentClass)
5517           {
5518           vtkParse_AddConstantToClass(currentClass, var);
5519           }
5520         else
5521           {
5522           vtkParse_AddConstantToNamespace(currentNamespace, var);
5523           }
5524         }
5525       /* This is a true variable i.e. not constant */
5526       else
5527         {
5528         if (currentClass)
5529           {
5530           vtkParse_AddVariableToClass(currentClass, var);
5531           }
5532         else
5533           {
5534           vtkParse_AddVariableToNamespace(currentNamespace, var);
5535           }
5536         }
5537     }
5538     break;
5539
5540   case 229:
5541
5542 /* Line 1455 of yacc.c  */
5543 #line 2136 "vtkParse.y"
5544     { postSig(", "); }
5545     break;
5546
5547   case 232:
5548
5549 /* Line 1455 of yacc.c  */
5550 #line 2142 "vtkParse.y"
5551     { setTypePtr(0); }
5552     break;
5553
5554   case 233:
5555
5556 /* Line 1455 of yacc.c  */
5557 #line 2143 "vtkParse.y"
5558     { setTypePtr((yyvsp[(1) - (1)].integer)); }
5559     break;
5560
5561   case 234:
5562
5563 /* Line 1455 of yacc.c  */
5564 #line 2147 "vtkParse.y"
5565     { (yyval.integer) = 0; }
5566     break;
5567
5568   case 235:
5569
5570 /* Line 1455 of yacc.c  */
5571 #line 2148 "vtkParse.y"
5572     { postSig(")"); }
5573     break;
5574
5575   case 236:
5576
5577 /* Line 1455 of yacc.c  */
5578 #line 2150 "vtkParse.y"
5579     {
5580       const char *scope = getScope();
5581       unsigned int parens = add_indirection((yyvsp[(1) - (5)].integer), (yyvsp[(2) - (5)].integer));
5582       if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_FUNCTION)
5583         {
5584         if (scope) { scope = vtkstrndup(scope, strlen(scope) - 2); }
5585         getFunction()->Class = scope;
5586         (yyval.integer) = (parens | VTK_PARSE_FUNCTION);
5587         }
5588       else if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_ARRAY)
5589         {
5590         (yyval.integer) = add_indirection_to_array(parens);
5591         }
5592     }
5593     break;
5594
5595   case 237:
5596
5597 /* Line 1455 of yacc.c  */
5598 #line 2167 "vtkParse.y"
5599     { (yyval.integer) = 0; }
5600     break;
5601
5602   case 238:
5603
5604 /* Line 1455 of yacc.c  */
5605 #line 2168 "vtkParse.y"
5606     { postSig(")"); }
5607     break;
5608
5609   case 239:
5610
5611 /* Line 1455 of yacc.c  */
5612 #line 2170 "vtkParse.y"
5613     {
5614       const char *scope = getScope();
5615       unsigned int parens = add_indirection((yyvsp[(1) - (5)].integer), (yyvsp[(2) - (5)].integer));
5616       if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_FUNCTION)
5617         {
5618         if (scope) { scope = vtkstrndup(scope, strlen(scope) - 2); }
5619         getFunction()->Class = scope;
5620         (yyval.integer) = (parens | VTK_PARSE_FUNCTION);
5621         }
5622       else if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_ARRAY)
5623         {
5624         (yyval.integer) = add_indirection_to_array(parens);
5625         }
5626     }
5627     break;
5628
5629   case 240:
5630
5631 /* Line 1455 of yacc.c  */
5632 #line 2186 "vtkParse.y"
5633     { postSig("("); scopeSig(""); (yyval.integer) = 0; }
5634     break;
5635
5636   case 241:
5637
5638 /* Line 1455 of yacc.c  */
5639 #line 2187 "vtkParse.y"
5640     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("*");
5641          (yyval.integer) = VTK_PARSE_POINTER; }
5642     break;
5643
5644   case 242:
5645
5646 /* Line 1455 of yacc.c  */
5647 #line 2189 "vtkParse.y"
5648     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("&");
5649          (yyval.integer) = VTK_PARSE_REF; }
5650     break;
5651
5652   case 243:
5653
5654 /* Line 1455 of yacc.c  */
5655 #line 2193 "vtkParse.y"
5656     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("*");
5657          (yyval.integer) = VTK_PARSE_POINTER; }
5658     break;
5659
5660   case 244:
5661
5662 /* Line 1455 of yacc.c  */
5663 #line 2195 "vtkParse.y"
5664     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("&");
5665          (yyval.integer) = VTK_PARSE_REF; }
5666     break;
5667
5668   case 245:
5669
5670 /* Line 1455 of yacc.c  */
5671 #line 2198 "vtkParse.y"
5672     { (yyval.integer) = 0; }
5673     break;
5674
5675   case 246:
5676
5677 /* Line 1455 of yacc.c  */
5678 #line 2199 "vtkParse.y"
5679     { pushFunction(); postSig("("); }
5680     break;
5681
5682   case 247:
5683
5684 /* Line 1455 of yacc.c  */
5685 #line 2200 "vtkParse.y"
5686     { postSig(")"); }
5687     break;
5688
5689   case 248:
5690
5691 /* Line 1455 of yacc.c  */
5692 #line 2201 "vtkParse.y"
5693     {
5694       (yyval.integer) = VTK_PARSE_FUNCTION;
5695       popFunction();
5696     }
5697     break;
5698
5699   case 249:
5700
5701 /* Line 1455 of yacc.c  */
5702 #line 2205 "vtkParse.y"
5703     { (yyval.integer) = VTK_PARSE_ARRAY; }
5704     break;
5705
5706   case 252:
5707
5708 /* Line 1455 of yacc.c  */
5709 #line 2209 "vtkParse.y"
5710     { currentFunction->IsConst = 1; }
5711     break;
5712
5713   case 255:
5714
5715 /* Line 1455 of yacc.c  */
5716 #line 2215 "vtkParse.y"
5717     { (yyval.integer) = add_indirection((yyvsp[(1) - (2)].integer), (yyvsp[(2) - (2)].integer)); }
5718     break;
5719
5720   case 257:
5721
5722 /* Line 1455 of yacc.c  */
5723 #line 2220 "vtkParse.y"
5724     { (yyval.integer) = add_indirection((yyvsp[(1) - (2)].integer), (yyvsp[(2) - (2)].integer)); }
5725     break;
5726
5727   case 258:
5728
5729 /* Line 1455 of yacc.c  */
5730 #line 2223 "vtkParse.y"
5731     { clearVarName(); chopSig(); }
5732     break;
5733
5734   case 260:
5735
5736 /* Line 1455 of yacc.c  */
5737 #line 2227 "vtkParse.y"
5738     { setVarName((yyvsp[(1) - (1)].str)); }
5739     break;
5740
5741   case 261:
5742
5743 /* Line 1455 of yacc.c  */
5744 #line 2228 "vtkParse.y"
5745     { setVarName((yyvsp[(1) - (3)].str)); }
5746     break;
5747
5748   case 265:
5749
5750 /* Line 1455 of yacc.c  */
5751 #line 2236 "vtkParse.y"
5752     { clearArray(); }
5753     break;
5754
5755   case 267:
5756
5757 /* Line 1455 of yacc.c  */
5758 #line 2240 "vtkParse.y"
5759     { clearArray(); }
5760     break;
5761
5762   case 271:
5763
5764 /* Line 1455 of yacc.c  */
5765 #line 2247 "vtkParse.y"
5766     { postSig("["); }
5767     break;
5768
5769   case 272:
5770
5771 /* Line 1455 of yacc.c  */
5772 #line 2247 "vtkParse.y"
5773     { postSig("]"); }
5774     break;
5775
5776   case 273:
5777
5778 /* Line 1455 of yacc.c  */
5779 #line 2250 "vtkParse.y"
5780     { pushArraySize(""); }
5781     break;
5782
5783   case 274:
5784
5785 /* Line 1455 of yacc.c  */
5786 #line 2251 "vtkParse.y"
5787     { markSig(); }
5788     break;
5789
5790   case 275:
5791
5792 /* Line 1455 of yacc.c  */
5793 #line 2251 "vtkParse.y"
5794     { chopSig(); pushArraySize(copySig()); }
5795     break;
5796
5797   case 280:
5798
5799 /* Line 1455 of yacc.c  */
5800 #line 2267 "vtkParse.y"
5801     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
5802     break;
5803
5804   case 281:
5805
5806 /* Line 1455 of yacc.c  */
5807 #line 2269 "vtkParse.y"
5808     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
5809     break;
5810
5811   case 282:
5812
5813 /* Line 1455 of yacc.c  */
5814 #line 2271 "vtkParse.y"
5815     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
5816     break;
5817
5818   case 283:
5819
5820 /* Line 1455 of yacc.c  */
5821 #line 2275 "vtkParse.y"
5822     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
5823     break;
5824
5825   case 284:
5826
5827 /* Line 1455 of yacc.c  */
5828 #line 2277 "vtkParse.y"
5829     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
5830     break;
5831
5832   case 285:
5833
5834 /* Line 1455 of yacc.c  */
5835 #line 2279 "vtkParse.y"
5836     { (yyval.str) = vtkstrcat3((yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)); }
5837     break;
5838
5839   case 286:
5840
5841 /* Line 1455 of yacc.c  */
5842 #line 2281 "vtkParse.y"
5843     { (yyval.str) = vtkstrcat3((yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)); }
5844     break;
5845
5846   case 287:
5847
5848 /* Line 1455 of yacc.c  */
5849 #line 2282 "vtkParse.y"
5850     { postSig("template "); }
5851     break;
5852
5853   case 288:
5854
5855 /* Line 1455 of yacc.c  */
5856 #line 2284 "vtkParse.y"
5857     { (yyval.str) = vtkstrcat4((yyvsp[(1) - (5)].str), "template ", (yyvsp[(4) - (5)].str), (yyvsp[(5) - (5)].str)); }
5858     break;
5859
5860   case 289:
5861
5862 /* Line 1455 of yacc.c  */
5863 #line 2287 "vtkParse.y"
5864     { postSig((yyvsp[(1) - (1)].str)); }
5865     break;
5866
5867   case 290:
5868
5869 /* Line 1455 of yacc.c  */
5870 #line 2290 "vtkParse.y"
5871     { (yyval.str) = "::"; postSig((yyval.str)); }
5872     break;
5873
5874   case 291:
5875
5876 /* Line 1455 of yacc.c  */
5877 #line 2293 "vtkParse.y"
5878     { markSig(); postSig((yyvsp[(1) - (2)].str)); postSig("<"); }
5879     break;
5880
5881   case 292:
5882
5883 /* Line 1455 of yacc.c  */
5884 #line 2295 "vtkParse.y"
5885     {
5886       chopSig(); if (getSig()[getSigLength()-1] == '>') { postSig(" "); }
5887       postSig(">"); (yyval.str) = copySig(); clearTypeId();
5888     }
5889     break;
5890
5891   case 293:
5892
5893 /* Line 1455 of yacc.c  */
5894 #line 2308 "vtkParse.y"
5895     { postSig((yyvsp[(1) - (1)].str)); }
5896     break;
5897
5898   case 294:
5899
5900 /* Line 1455 of yacc.c  */
5901 #line 2309 "vtkParse.y"
5902     { postSig((yyvsp[(1) - (1)].str)); }
5903     break;
5904
5905   case 295:
5906
5907 /* Line 1455 of yacc.c  */
5908 #line 2310 "vtkParse.y"
5909     { postSig((yyvsp[(1) - (1)].str)); }
5910     break;
5911
5912   case 296:
5913
5914 /* Line 1455 of yacc.c  */
5915 #line 2311 "vtkParse.y"
5916     { postSig((yyvsp[(1) - (1)].str)); }
5917     break;
5918
5919   case 297:
5920
5921 /* Line 1455 of yacc.c  */
5922 #line 2312 "vtkParse.y"
5923     { postSig((yyvsp[(1) - (1)].str)); }
5924     break;
5925
5926   case 298:
5927
5928 /* Line 1455 of yacc.c  */
5929 #line 2313 "vtkParse.y"
5930     { postSig((yyvsp[(1) - (1)].str)); }
5931     break;
5932
5933   case 299:
5934
5935 /* Line 1455 of yacc.c  */
5936 #line 2314 "vtkParse.y"
5937     { postSig((yyvsp[(1) - (1)].str)); }
5938     break;
5939
5940   case 300:
5941
5942 /* Line 1455 of yacc.c  */
5943 #line 2315 "vtkParse.y"
5944     { (yyval.str) = vtkstrcat("~",(yyvsp[(2) - (2)].str)); postSig((yyval.str)); }
5945     break;
5946
5947   case 301:
5948
5949 /* Line 1455 of yacc.c  */
5950 #line 2316 "vtkParse.y"
5951     { (yyval.str) = vtkstrcat("~",(yyvsp[(2) - (2)].str)); postSig((yyval.str)); }
5952     break;
5953
5954   case 302:
5955
5956 /* Line 1455 of yacc.c  */
5957 #line 2317 "vtkParse.y"
5958     { (yyval.str) = vtkstrcat("~",(yyvsp[(2) - (2)].str)); postSig((yyval.str)); }
5959     break;
5960
5961   case 303:
5962
5963 /* Line 1455 of yacc.c  */
5964 #line 2318 "vtkParse.y"
5965     { (yyval.str) = vtkstrcat("~",(yyvsp[(2) - (2)].str)); postSig((yyval.str)); }
5966     break;
5967
5968   case 304:
5969
5970 /* Line 1455 of yacc.c  */
5971 #line 2319 "vtkParse.y"
5972     { (yyval.str) = vtkstrcat("~",(yyvsp[(2) - (2)].str)); postSig((yyval.str)); }
5973     break;
5974
5975   case 305:
5976
5977 /* Line 1455 of yacc.c  */
5978 #line 2320 "vtkParse.y"
5979     { (yyval.str) = vtkstrcat("~",(yyvsp[(2) - (2)].str)); postSig((yyval.str)); }
5980     break;
5981
5982   case 306:
5983
5984 /* Line 1455 of yacc.c  */
5985 #line 2321 "vtkParse.y"
5986     { (yyval.str) = vtkstrcat("~",(yyvsp[(2) - (2)].str)); postSig((yyval.str)); }
5987     break;
5988
5989   case 307:
5990
5991 /* Line 1455 of yacc.c  */
5992 #line 2322 "vtkParse.y"
5993     { (yyval.str) = "size_t"; postSig((yyval.str)); }
5994     break;
5995
5996   case 308:
5997
5998 /* Line 1455 of yacc.c  */
5999 #line 2323 "vtkParse.y"
6000     { (yyval.str) = "ssize_t"; postSig((yyval.str)); }
6001     break;
6002
6003   case 309:
6004
6005 /* Line 1455 of yacc.c  */
6006 #line 2324 "vtkParse.y"
6007     { (yyval.str) = "vtkTypeInt8"; postSig((yyval.str)); }
6008     break;
6009
6010   case 310:
6011
6012 /* Line 1455 of yacc.c  */
6013 #line 2325 "vtkParse.y"
6014     { (yyval.str) = "vtkTypeUInt8"; postSig((yyval.str)); }
6015     break;
6016
6017   case 311:
6018
6019 /* Line 1455 of yacc.c  */
6020 #line 2326 "vtkParse.y"
6021     { (yyval.str) = "vtkTypeInt16"; postSig((yyval.str)); }
6022     break;
6023
6024   case 312:
6025
6026 /* Line 1455 of yacc.c  */
6027 #line 2327 "vtkParse.y"
6028     { (yyval.str) = "vtkTypeUInt16"; postSig((yyval.str)); }
6029     break;
6030
6031   case 313:
6032
6033 /* Line 1455 of yacc.c  */
6034 #line 2328 "vtkParse.y"
6035     { (yyval.str) = "vtkTypeInt32"; postSig((yyval.str)); }
6036     break;
6037
6038   case 314:
6039
6040 /* Line 1455 of yacc.c  */
6041 #line 2329 "vtkParse.y"
6042     { (yyval.str) = "vtkTypeUInt32"; postSig((yyval.str)); }
6043     break;
6044
6045   case 315:
6046
6047 /* Line 1455 of yacc.c  */
6048 #line 2330 "vtkParse.y"
6049     { (yyval.str) = "vtkTypeInt64"; postSig((yyval.str)); }
6050     break;
6051
6052   case 316:
6053
6054 /* Line 1455 of yacc.c  */
6055 #line 2331 "vtkParse.y"
6056     { (yyval.str) = "vtkTypeUInt64"; postSig((yyval.str)); }
6057     break;
6058
6059   case 317:
6060
6061 /* Line 1455 of yacc.c  */
6062 #line 2332 "vtkParse.y"
6063     { (yyval.str) = "vtkTypeFloat32"; postSig((yyval.str)); }
6064     break;
6065
6066   case 318:
6067
6068 /* Line 1455 of yacc.c  */
6069 #line 2333 "vtkParse.y"
6070     { (yyval.str) = "vtkTypeFloat64"; postSig((yyval.str)); }
6071     break;
6072
6073   case 319:
6074
6075 /* Line 1455 of yacc.c  */
6076 #line 2334 "vtkParse.y"
6077     { (yyval.str) = "vtkIdType"; postSig((yyval.str)); }
6078     break;
6079
6080   case 330:
6081
6082 /* Line 1455 of yacc.c  */
6083 #line 2360 "vtkParse.y"
6084     { setTypeBase(buildTypeBase(getType(), (yyvsp[(1) - (1)].integer))); }
6085     break;
6086
6087   case 331:
6088
6089 /* Line 1455 of yacc.c  */
6090 #line 2361 "vtkParse.y"
6091     { setTypeMod(VTK_PARSE_TYPEDEF); }
6092     break;
6093
6094   case 332:
6095
6096 /* Line 1455 of yacc.c  */
6097 #line 2362 "vtkParse.y"
6098     { setTypeMod(VTK_PARSE_FRIEND); }
6099     break;
6100
6101   case 335:
6102
6103 /* Line 1455 of yacc.c  */
6104 #line 2369 "vtkParse.y"
6105     { setTypeMod((yyvsp[(1) - (1)].integer)); }
6106     break;
6107
6108   case 336:
6109
6110 /* Line 1455 of yacc.c  */
6111 #line 2370 "vtkParse.y"
6112     { setTypeMod((yyvsp[(1) - (1)].integer)); }
6113     break;
6114
6115   case 337:
6116
6117 /* Line 1455 of yacc.c  */
6118 #line 2371 "vtkParse.y"
6119     { setTypeMod((yyvsp[(1) - (1)].integer)); }
6120     break;
6121
6122   case 338:
6123
6124 /* Line 1455 of yacc.c  */
6125 #line 2374 "vtkParse.y"
6126     { postSig("mutable "); (yyval.integer) = VTK_PARSE_MUTABLE; }
6127     break;
6128
6129   case 339:
6130
6131 /* Line 1455 of yacc.c  */
6132 #line 2375 "vtkParse.y"
6133     { (yyval.integer) = 0; }
6134     break;
6135
6136   case 340:
6137
6138 /* Line 1455 of yacc.c  */
6139 #line 2376 "vtkParse.y"
6140     { (yyval.integer) = 0; }
6141     break;
6142
6143   case 341:
6144
6145 /* Line 1455 of yacc.c  */
6146 #line 2377 "vtkParse.y"
6147     { postSig("static "); (yyval.integer) = VTK_PARSE_STATIC; }
6148     break;
6149
6150   case 342:
6151
6152 /* Line 1455 of yacc.c  */
6153 #line 2380 "vtkParse.y"
6154     { (yyval.integer) = 0; }
6155     break;
6156
6157   case 343:
6158
6159 /* Line 1455 of yacc.c  */
6160 #line 2381 "vtkParse.y"
6161     { postSig("virtual "); (yyval.integer) = VTK_PARSE_VIRTUAL; }
6162     break;
6163
6164   case 344:
6165
6166 /* Line 1455 of yacc.c  */
6167 #line 2382 "vtkParse.y"
6168     { postSig("explicit "); (yyval.integer) = VTK_PARSE_EXPLICIT; }
6169     break;
6170
6171   case 345:
6172
6173 /* Line 1455 of yacc.c  */
6174 #line 2385 "vtkParse.y"
6175     { postSig("const "); (yyval.integer) = VTK_PARSE_CONST; }
6176     break;
6177
6178   case 346:
6179
6180 /* Line 1455 of yacc.c  */
6181 #line 2386 "vtkParse.y"
6182     { postSig("volatile "); (yyval.integer) = VTK_PARSE_VOLATILE; }
6183     break;
6184
6185   case 348:
6186
6187 /* Line 1455 of yacc.c  */
6188 #line 2391 "vtkParse.y"
6189     { (yyval.integer) = ((yyvsp[(1) - (2)].integer) | (yyvsp[(2) - (2)].integer)); }
6190     break;
6191
6192   case 350:
6193
6194 /* Line 1455 of yacc.c  */
6195 #line 2402 "vtkParse.y"
6196     { setTypeBase((yyvsp[(1) - (1)].integer)); }
6197     break;
6198
6199   case 352:
6200
6201 /* Line 1455 of yacc.c  */
6202 #line 2404 "vtkParse.y"
6203     { setTypeBase((yyvsp[(2) - (2)].integer)); }
6204     break;
6205
6206   case 355:
6207
6208 /* Line 1455 of yacc.c  */
6209 #line 2409 "vtkParse.y"
6210     { postSig("typename "); }
6211     break;
6212
6213   case 356:
6214
6215 /* Line 1455 of yacc.c  */
6216 #line 2410 "vtkParse.y"
6217     { postSig(" "); setTypeId((yyvsp[(3) - (3)].str)); (yyval.integer) = guess_id_type((yyvsp[(3) - (3)].str)); }
6218     break;
6219
6220   case 357:
6221
6222 /* Line 1455 of yacc.c  */
6223 #line 2412 "vtkParse.y"
6224     { postSig(" "); setTypeId((yyvsp[(1) - (1)].str)); (yyval.integer) = guess_id_type((yyvsp[(1) - (1)].str)); }
6225     break;
6226
6227   case 358:
6228
6229 /* Line 1455 of yacc.c  */
6230 #line 2414 "vtkParse.y"
6231     { postSig(" "); setTypeId((yyvsp[(1) - (1)].str)); (yyval.integer) = guess_id_type((yyvsp[(1) - (1)].str)); }
6232     break;
6233
6234   case 359:
6235
6236 /* Line 1455 of yacc.c  */
6237 #line 2416 "vtkParse.y"
6238     { postSig(" "); setTypeId((yyvsp[(2) - (2)].str)); (yyval.integer) = guess_id_type((yyvsp[(2) - (2)].str)); }
6239     break;
6240
6241   case 360:
6242
6243 /* Line 1455 of yacc.c  */
6244 #line 2418 "vtkParse.y"
6245     { postSig(" "); setTypeId((yyvsp[(2) - (2)].str)); (yyval.integer) = guess_id_type((yyvsp[(2) - (2)].str)); }
6246     break;
6247
6248   case 362:
6249
6250 /* Line 1455 of yacc.c  */
6251 #line 2424 "vtkParse.y"
6252     { setTypeBase((yyvsp[(1) - (1)].integer)); }
6253     break;
6254
6255   case 364:
6256
6257 /* Line 1455 of yacc.c  */
6258 #line 2426 "vtkParse.y"
6259     { setTypeBase((yyvsp[(2) - (2)].integer)); }
6260     break;
6261
6262   case 367:
6263
6264 /* Line 1455 of yacc.c  */
6265 #line 2432 "vtkParse.y"
6266     { postSig(" "); setTypeId((yyvsp[(1) - (1)].str)); (yyval.integer) = guess_id_type((yyvsp[(1) - (1)].str)); }
6267     break;
6268
6269   case 368:
6270
6271 /* Line 1455 of yacc.c  */
6272 #line 2434 "vtkParse.y"
6273     { postSig(" "); setTypeId((yyvsp[(1) - (1)].str)); (yyval.integer) = guess_id_type((yyvsp[(1) - (1)].str)); }
6274     break;
6275
6276   case 369:
6277
6278 /* Line 1455 of yacc.c  */
6279 #line 2436 "vtkParse.y"
6280     { postSig(" "); setTypeId((yyvsp[(2) - (2)].str)); (yyval.integer) = guess_id_type((yyvsp[(2) - (2)].str)); }
6281     break;
6282
6283   case 370:
6284
6285 /* Line 1455 of yacc.c  */
6286 #line 2438 "vtkParse.y"
6287     { postSig(" "); setTypeId((yyvsp[(2) - (2)].str)); (yyval.integer) = guess_id_type((yyvsp[(2) - (2)].str)); }
6288     break;
6289
6290   case 371:
6291
6292 /* Line 1455 of yacc.c  */
6293 #line 2440 "vtkParse.y"
6294     { postSig(" "); setTypeId((yyvsp[(2) - (2)].str)); (yyval.integer) = guess_id_type((yyvsp[(2) - (2)].str)); }
6295     break;
6296
6297   case 372:
6298
6299 /* Line 1455 of yacc.c  */
6300 #line 2443 "vtkParse.y"
6301     { setTypeId(""); }
6302     break;
6303
6304   case 374:
6305
6306 /* Line 1455 of yacc.c  */
6307 #line 2447 "vtkParse.y"
6308     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_STRING; }
6309     break;
6310
6311   case 375:
6312
6313 /* Line 1455 of yacc.c  */
6314 #line 2448 "vtkParse.y"
6315     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_UNICODE_STRING;}
6316     break;
6317
6318   case 376:
6319
6320 /* Line 1455 of yacc.c  */
6321 #line 2449 "vtkParse.y"
6322     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_OSTREAM; }
6323     break;
6324
6325   case 377:
6326
6327 /* Line 1455 of yacc.c  */
6328 #line 2450 "vtkParse.y"
6329     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_ISTREAM; }
6330     break;
6331
6332   case 378:
6333
6334 /* Line 1455 of yacc.c  */
6335 #line 2451 "vtkParse.y"
6336     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_UNKNOWN; }
6337     break;
6338
6339   case 379:
6340
6341 /* Line 1455 of yacc.c  */
6342 #line 2452 "vtkParse.y"
6343     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_OBJECT; }
6344     break;
6345
6346   case 380:
6347
6348 /* Line 1455 of yacc.c  */
6349 #line 2453 "vtkParse.y"
6350     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_QOBJECT; }
6351     break;
6352
6353   case 381:
6354
6355 /* Line 1455 of yacc.c  */
6356 #line 2454 "vtkParse.y"
6357     { typeSig("ssize_t"); (yyval.integer) = VTK_PARSE_SSIZE_T; }
6358     break;
6359
6360   case 382:
6361
6362 /* Line 1455 of yacc.c  */
6363 #line 2455 "vtkParse.y"
6364     { typeSig("size_t"); (yyval.integer) = VTK_PARSE_SIZE_T; }
6365     break;
6366
6367   case 383:
6368
6369 /* Line 1455 of yacc.c  */
6370 #line 2456 "vtkParse.y"
6371     { typeSig("vtkTypeInt8"); (yyval.integer) = VTK_PARSE_INT8; }
6372     break;
6373
6374   case 384:
6375
6376 /* Line 1455 of yacc.c  */
6377 #line 2457 "vtkParse.y"
6378     { typeSig("vtkTypeUInt8"); (yyval.integer) = VTK_PARSE_UINT8; }
6379     break;
6380
6381   case 385:
6382
6383 /* Line 1455 of yacc.c  */
6384 #line 2458 "vtkParse.y"
6385     { typeSig("vtkTypeInt16"); (yyval.integer) = VTK_PARSE_INT16; }
6386     break;
6387
6388   case 386:
6389
6390 /* Line 1455 of yacc.c  */
6391 #line 2459 "vtkParse.y"
6392     { typeSig("vtkTypeUInt16"); (yyval.integer) = VTK_PARSE_UINT16; }
6393     break;
6394
6395   case 387:
6396
6397 /* Line 1455 of yacc.c  */
6398 #line 2460 "vtkParse.y"
6399     { typeSig("vtkTypeInt32"); (yyval.integer) = VTK_PARSE_INT32; }
6400     break;
6401
6402   case 388:
6403
6404 /* Line 1455 of yacc.c  */
6405 #line 2461 "vtkParse.y"
6406     { typeSig("vtkTypeUInt32"); (yyval.integer) = VTK_PARSE_UINT32; }
6407     break;
6408
6409   case 389:
6410
6411 /* Line 1455 of yacc.c  */
6412 #line 2462 "vtkParse.y"
6413     { typeSig("vtkTypeInt64"); (yyval.integer) = VTK_PARSE_INT64; }
6414     break;
6415
6416   case 390:
6417
6418 /* Line 1455 of yacc.c  */
6419 #line 2463 "vtkParse.y"
6420     { typeSig("vtkTypeUInt64"); (yyval.integer) = VTK_PARSE_UINT64; }
6421     break;
6422
6423   case 391:
6424
6425 /* Line 1455 of yacc.c  */
6426 #line 2464 "vtkParse.y"
6427     { typeSig("vtkTypeFloat32"); (yyval.integer) = VTK_PARSE_FLOAT32; }
6428     break;
6429
6430   case 392:
6431
6432 /* Line 1455 of yacc.c  */
6433 #line 2465 "vtkParse.y"
6434     { typeSig("vtkTypeFloat64"); (yyval.integer) = VTK_PARSE_FLOAT64; }
6435     break;
6436
6437   case 393:
6438
6439 /* Line 1455 of yacc.c  */
6440 #line 2466 "vtkParse.y"
6441     { typeSig("vtkIdType"); (yyval.integer) = VTK_PARSE_ID_TYPE; }
6442     break;
6443
6444   case 394:
6445
6446 /* Line 1455 of yacc.c  */
6447 #line 2469 "vtkParse.y"
6448     { postSig("void "); (yyval.integer) = VTK_PARSE_VOID; }
6449     break;
6450
6451   case 395:
6452
6453 /* Line 1455 of yacc.c  */
6454 #line 2470 "vtkParse.y"
6455     { postSig("bool "); (yyval.integer) = VTK_PARSE_BOOL; }
6456     break;
6457
6458   case 396:
6459
6460 /* Line 1455 of yacc.c  */
6461 #line 2471 "vtkParse.y"
6462     { postSig("float "); (yyval.integer) = VTK_PARSE_FLOAT; }
6463     break;
6464
6465   case 397:
6466
6467 /* Line 1455 of yacc.c  */
6468 #line 2472 "vtkParse.y"
6469     { postSig("double "); (yyval.integer) = VTK_PARSE_DOUBLE; }
6470     break;
6471
6472   case 398:
6473
6474 /* Line 1455 of yacc.c  */
6475 #line 2473 "vtkParse.y"
6476     { postSig("char "); (yyval.integer) = VTK_PARSE_CHAR; }
6477     break;
6478
6479   case 399:
6480
6481 /* Line 1455 of yacc.c  */
6482 #line 2474 "vtkParse.y"
6483     { postSig("int "); (yyval.integer) = VTK_PARSE_INT; }
6484     break;
6485
6486   case 400:
6487
6488 /* Line 1455 of yacc.c  */
6489 #line 2475 "vtkParse.y"
6490     { postSig("short "); (yyval.integer) = VTK_PARSE_SHORT; }
6491     break;
6492
6493   case 401:
6494
6495 /* Line 1455 of yacc.c  */
6496 #line 2476 "vtkParse.y"
6497     { postSig("long "); (yyval.integer) = VTK_PARSE_LONG; }
6498     break;
6499
6500   case 402:
6501
6502 /* Line 1455 of yacc.c  */
6503 #line 2477 "vtkParse.y"
6504     { postSig("__int64 "); (yyval.integer) = VTK_PARSE___INT64; }
6505     break;
6506
6507   case 403:
6508
6509 /* Line 1455 of yacc.c  */
6510 #line 2478 "vtkParse.y"
6511     { postSig("signed "); (yyval.integer) = VTK_PARSE_INT; }
6512     break;
6513
6514   case 404:
6515
6516 /* Line 1455 of yacc.c  */
6517 #line 2479 "vtkParse.y"
6518     { postSig("unsigned "); (yyval.integer) = VTK_PARSE_UNSIGNED_INT; }
6519     break;
6520
6521   case 407:
6522
6523 /* Line 1455 of yacc.c  */
6524 #line 2501 "vtkParse.y"
6525     { (yyval.integer) = ((yyvsp[(1) - (2)].integer) | (yyvsp[(2) - (2)].integer)); }
6526     break;
6527
6528   case 408:
6529
6530 /* Line 1455 of yacc.c  */
6531 #line 2504 "vtkParse.y"
6532     { postSig("&"); (yyval.integer) = VTK_PARSE_REF; }
6533     break;
6534
6535   case 409:
6536
6537 /* Line 1455 of yacc.c  */
6538 #line 2507 "vtkParse.y"
6539     { postSig("*"); (yyval.integer) = VTK_PARSE_POINTER; }
6540     break;
6541
6542   case 410:
6543
6544 /* Line 1455 of yacc.c  */
6545 #line 2508 "vtkParse.y"
6546     { postSig("*"); }
6547     break;
6548
6549   case 411:
6550
6551 /* Line 1455 of yacc.c  */
6552 #line 2509 "vtkParse.y"
6553     {
6554       if (((yyvsp[(3) - (3)].integer) & VTK_PARSE_CONST) != 0)
6555         {
6556         (yyval.integer) = VTK_PARSE_CONST_POINTER;
6557         }
6558       if (((yyvsp[(3) - (3)].integer) & VTK_PARSE_VOLATILE) != 0)
6559         {
6560         (yyval.integer) = VTK_PARSE_BAD_INDIRECT;
6561         }
6562     }
6563     break;
6564
6565   case 413:
6566
6567 /* Line 1455 of yacc.c  */
6568 #line 2525 "vtkParse.y"
6569     {
6570       unsigned int n;
6571       n = (((yyvsp[(1) - (2)].integer) << 2) | (yyvsp[(2) - (2)].integer));
6572       if ((n & VTK_PARSE_INDIRECT) != n)
6573         {
6574         n = VTK_PARSE_BAD_INDIRECT;
6575         }
6576       (yyval.integer) = n;
6577     }
6578     break;
6579
6580   case 414:
6581
6582 /* Line 1455 of yacc.c  */
6583 #line 2541 "vtkParse.y"
6584     {preSig("void Set"); postSig("(");}
6585     break;
6586
6587   case 415:
6588
6589 /* Line 1455 of yacc.c  */
6590 #line 2542 "vtkParse.y"
6591     {
6592    postSig("a);");
6593    currentFunction->Macro = "vtkSetMacro";
6594    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (7)].str));
6595    currentFunction->Comment = vtkstrdup(getComment());
6596    add_parameter(currentFunction, getType(), getTypeId(), 0);
6597    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
6598    output_function();
6599    }
6600     break;
6601
6602   case 416:
6603
6604 /* Line 1455 of yacc.c  */
6605 #line 2551 "vtkParse.y"
6606     {postSig("Get");}
6607     break;
6608
6609   case 417:
6610
6611 /* Line 1455 of yacc.c  */
6612 #line 2552 "vtkParse.y"
6613     {markSig();}
6614     break;
6615
6616   case 418:
6617
6618 /* Line 1455 of yacc.c  */
6619 #line 2552 "vtkParse.y"
6620     {swapSig();}
6621     break;
6622
6623   case 419:
6624
6625 /* Line 1455 of yacc.c  */
6626 #line 2553 "vtkParse.y"
6627     {
6628    postSig("();");
6629    currentFunction->Macro = "vtkGetMacro";
6630    currentFunction->Name = vtkstrcat("Get", (yyvsp[(4) - (9)].str));
6631    currentFunction->Comment = vtkstrdup(getComment());
6632    set_return(currentFunction, getType(), getTypeId(), 0);
6633    output_function();
6634    }
6635     break;
6636
6637   case 420:
6638
6639 /* Line 1455 of yacc.c  */
6640 #line 2561 "vtkParse.y"
6641     {preSig("void Set");}
6642     break;
6643
6644   case 421:
6645
6646 /* Line 1455 of yacc.c  */
6647 #line 2562 "vtkParse.y"
6648     {
6649    postSig("(char *);");
6650    currentFunction->Macro = "vtkSetStringMacro";
6651    currentFunction->Name = vtkstrcat("Set", (yyvsp[(4) - (5)].str));
6652    currentFunction->Comment = vtkstrdup(getComment());
6653    add_parameter(currentFunction, VTK_PARSE_CHAR_PTR, "char", 0);
6654    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
6655    output_function();
6656    }
6657     break;
6658
6659   case 422:
6660
6661 /* Line 1455 of yacc.c  */
6662 #line 2571 "vtkParse.y"
6663     {preSig("char *Get");}
6664     break;
6665
6666   case 423:
6667
6668 /* Line 1455 of yacc.c  */
6669 #line 2572 "vtkParse.y"
6670     {
6671    postSig("();");
6672    currentFunction->Macro = "vtkGetStringMacro";
6673    currentFunction->Name = vtkstrcat("Get", (yyvsp[(4) - (5)].str));
6674    currentFunction->Comment = vtkstrdup(getComment());
6675    set_return(currentFunction, VTK_PARSE_CHAR_PTR, "char", 0);
6676    output_function();
6677    }
6678     break;
6679
6680   case 424:
6681
6682 /* Line 1455 of yacc.c  */
6683 #line 2580 "vtkParse.y"
6684     {startSig(); markSig();}
6685     break;
6686
6687   case 425:
6688
6689 /* Line 1455 of yacc.c  */
6690 #line 2580 "vtkParse.y"
6691     {closeSig();}
6692     break;
6693
6694   case 426:
6695
6696 /* Line 1455 of yacc.c  */
6697 #line 2582 "vtkParse.y"
6698     {
6699    const char *typeText;
6700    chopSig();
6701    typeText = copySig();
6702
6703    currentFunction->Macro = "vtkSetClampMacro";
6704    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (10)].str));
6705    currentFunction->Signature =
6706      vtkstrcat5("void ", currentFunction->Name, "(", typeText, ");");
6707    currentFunction->Comment = vtkstrdup(getComment());
6708    add_parameter(currentFunction, getType(), getTypeId(), 0);
6709    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
6710    output_function();
6711
6712    currentFunction->Macro = "vtkSetClampMacro";
6713    currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (10)].str), "MinValue");
6714    currentFunction->Signature =
6715      vtkstrcat4(typeText, " ", currentFunction->Name, "();");
6716    currentFunction->Comment = vtkstrdup(getComment());
6717    set_return(currentFunction, getType(), getTypeId(), 0);
6718    output_function();
6719
6720    currentFunction->Macro = "vtkSetClampMacro";
6721    currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (10)].str), "MaxValue");
6722    currentFunction->Signature =
6723      vtkstrcat4(typeText, " ", currentFunction->Name, "();");
6724    currentFunction->Comment = vtkstrdup(getComment());
6725    set_return(currentFunction, getType(), getTypeId(), 0);
6726    output_function();
6727    }
6728     break;
6729
6730   case 427:
6731
6732 /* Line 1455 of yacc.c  */
6733 #line 2613 "vtkParse.y"
6734     {preSig("void Set"); postSig("("); }
6735     break;
6736
6737   case 428:
6738
6739 /* Line 1455 of yacc.c  */
6740 #line 2614 "vtkParse.y"
6741     {
6742    postSig("*);");
6743    currentFunction->Macro = "vtkSetObjectMacro";
6744    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (7)].str));
6745    currentFunction->Comment = vtkstrdup(getComment());
6746    add_parameter(currentFunction, VTK_PARSE_OBJECT_PTR, getTypeId(), 0);
6747    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
6748    output_function();
6749    }
6750     break;
6751
6752   case 429:
6753
6754 /* Line 1455 of yacc.c  */
6755 #line 2623 "vtkParse.y"
6756     {postSig("*Get");}
6757     break;
6758
6759   case 430:
6760
6761 /* Line 1455 of yacc.c  */
6762 #line 2624 "vtkParse.y"
6763     {markSig();}
6764     break;
6765
6766   case 431:
6767
6768 /* Line 1455 of yacc.c  */
6769 #line 2624 "vtkParse.y"
6770     {swapSig();}
6771     break;
6772
6773   case 432:
6774
6775 /* Line 1455 of yacc.c  */
6776 #line 2625 "vtkParse.y"
6777     {
6778    postSig("();");
6779    currentFunction->Macro = "vtkGetObjectMacro";
6780    currentFunction->Name = vtkstrcat("Get", (yyvsp[(4) - (9)].str));
6781    currentFunction->Comment = vtkstrdup(getComment());
6782    set_return(currentFunction, VTK_PARSE_OBJECT_PTR, getTypeId(), 0);
6783    output_function();
6784    }
6785     break;
6786
6787   case 433:
6788
6789 /* Line 1455 of yacc.c  */
6790 #line 2634 "vtkParse.y"
6791     {
6792    currentFunction->Macro = "vtkBooleanMacro";
6793    currentFunction->Name = vtkstrcat((yyvsp[(3) - (6)].str), "On");
6794    currentFunction->Comment = vtkstrdup(getComment());
6795    currentFunction->Signature =
6796      vtkstrcat3("void ", currentFunction->Name, "();");
6797    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
6798    output_function();
6799
6800    currentFunction->Macro = "vtkBooleanMacro";
6801    currentFunction->Name = vtkstrcat((yyvsp[(3) - (6)].str), "Off");
6802    currentFunction->Comment = vtkstrdup(getComment());
6803    currentFunction->Signature =
6804      vtkstrcat3("void ", currentFunction->Name, "();");
6805    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
6806    output_function();
6807    }
6808     break;
6809
6810   case 434:
6811
6812 /* Line 1455 of yacc.c  */
6813 #line 2651 "vtkParse.y"
6814     {startSig(); markSig();}
6815     break;
6816
6817   case 435:
6818
6819 /* Line 1455 of yacc.c  */
6820 #line 2652 "vtkParse.y"
6821     {
6822    chopSig();
6823    outputSetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 2);
6824    }
6825     break;
6826
6827   case 436:
6828
6829 /* Line 1455 of yacc.c  */
6830 #line 2656 "vtkParse.y"
6831     {startSig(); markSig();}
6832     break;
6833
6834   case 437:
6835
6836 /* Line 1455 of yacc.c  */
6837 #line 2657 "vtkParse.y"
6838     {
6839    chopSig();
6840    outputGetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 2);
6841    }
6842     break;
6843
6844   case 438:
6845
6846 /* Line 1455 of yacc.c  */
6847 #line 2661 "vtkParse.y"
6848     {startSig(); markSig();}
6849     break;
6850
6851   case 439:
6852
6853 /* Line 1455 of yacc.c  */
6854 #line 2662 "vtkParse.y"
6855     {
6856    chopSig();
6857    outputSetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 3);
6858    }
6859     break;
6860
6861   case 440:
6862
6863 /* Line 1455 of yacc.c  */
6864 #line 2666 "vtkParse.y"
6865     {startSig(); markSig();}
6866     break;
6867
6868   case 441:
6869
6870 /* Line 1455 of yacc.c  */
6871 #line 2667 "vtkParse.y"
6872     {
6873    chopSig();
6874    outputGetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 3);
6875    }
6876     break;
6877
6878   case 442:
6879
6880 /* Line 1455 of yacc.c  */
6881 #line 2671 "vtkParse.y"
6882     {startSig(); markSig();}
6883     break;
6884
6885   case 443:
6886
6887 /* Line 1455 of yacc.c  */
6888 #line 2672 "vtkParse.y"
6889     {
6890    chopSig();
6891    outputSetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 4);
6892    }
6893     break;
6894
6895   case 444:
6896
6897 /* Line 1455 of yacc.c  */
6898 #line 2676 "vtkParse.y"
6899     {startSig(); markSig();}
6900     break;
6901
6902   case 445:
6903
6904 /* Line 1455 of yacc.c  */
6905 #line 2677 "vtkParse.y"
6906     {
6907    chopSig();
6908    outputGetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 4);
6909    }
6910     break;
6911
6912   case 446:
6913
6914 /* Line 1455 of yacc.c  */
6915 #line 2681 "vtkParse.y"
6916     {startSig(); markSig();}
6917     break;
6918
6919   case 447:
6920
6921 /* Line 1455 of yacc.c  */
6922 #line 2682 "vtkParse.y"
6923     {
6924    chopSig();
6925    outputSetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 6);
6926    }
6927     break;
6928
6929   case 448:
6930
6931 /* Line 1455 of yacc.c  */
6932 #line 2686 "vtkParse.y"
6933     {startSig(); markSig();}
6934     break;
6935
6936   case 449:
6937
6938 /* Line 1455 of yacc.c  */
6939 #line 2687 "vtkParse.y"
6940     {
6941    chopSig();
6942    outputGetVectorMacro((yyvsp[(3) - (7)].str), getType(), copySig(), 6);
6943    }
6944     break;
6945
6946   case 450:
6947
6948 /* Line 1455 of yacc.c  */
6949 #line 2691 "vtkParse.y"
6950     {startSig(); markSig();}
6951     break;
6952
6953   case 451:
6954
6955 /* Line 1455 of yacc.c  */
6956 #line 2693 "vtkParse.y"
6957     {
6958    const char *typeText;
6959    chopSig();
6960    typeText = copySig();
6961    currentFunction->Macro = "vtkSetVectorMacro";
6962    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (9)].str));
6963    currentFunction->Signature =
6964      vtkstrcat7("void ", currentFunction->Name, "(", typeText,
6965                 " a[", (yyvsp[(8) - (9)].str), "]);");
6966    currentFunction->Comment = vtkstrdup(getComment());
6967    add_parameter(currentFunction, (VTK_PARSE_POINTER | getType()),
6968                  getTypeId(), (int)strtol((yyvsp[(8) - (9)].str), NULL, 0));
6969    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
6970    output_function();
6971    }
6972     break;
6973
6974   case 452:
6975
6976 /* Line 1455 of yacc.c  */
6977 #line 2708 "vtkParse.y"
6978     {startSig();}
6979     break;
6980
6981   case 453:
6982
6983 /* Line 1455 of yacc.c  */
6984 #line 2710 "vtkParse.y"
6985     {
6986    chopSig();
6987    currentFunction->Macro = "vtkGetVectorMacro";
6988    currentFunction->Name = vtkstrcat("Get", (yyvsp[(3) - (9)].str));
6989    postSig(" *");
6990    postSig(currentFunction->Name);
6991    postSig("();");
6992    currentFunction->Comment = vtkstrdup(getComment());
6993    set_return(currentFunction, (VTK_PARSE_POINTER | getType()),
6994               getTypeId(), (int)strtol((yyvsp[(8) - (9)].str), NULL, 0));
6995    output_function();
6996    }
6997     break;
6998
6999   case 454:
7000
7001 /* Line 1455 of yacc.c  */
7002 #line 2723 "vtkParse.y"
7003     {
7004      currentFunction->Macro = "vtkViewportCoordinateMacro";
7005      currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (4)].str), "Coordinate");
7006      currentFunction->Signature =
7007        vtkstrcat3("vtkCoordinate *", currentFunction->Name, "();");
7008      currentFunction->Comment = vtkstrdup(getComment());
7009      set_return(currentFunction, VTK_PARSE_OBJECT_PTR, "vtkCoordinate", 0);
7010      output_function();
7011
7012      currentFunction->Macro = "vtkViewportCoordinateMacro";
7013      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
7014      currentFunction->Signature =
7015        vtkstrcat3("void ", currentFunction->Name, "(double, double);");
7016      currentFunction->Comment = vtkstrdup(getComment());
7017      add_parameter(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
7018      add_parameter(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
7019      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
7020      output_function();
7021
7022      currentFunction->Macro = "vtkViewportCoordinateMacro";
7023      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
7024      currentFunction->Signature =
7025        vtkstrcat3("void ", currentFunction->Name, "(double a[2]);");
7026      currentFunction->Comment = vtkstrdup(getComment());
7027      add_parameter(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 2);
7028      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
7029      output_function();
7030
7031      currentFunction->Macro = "vtkViewportCoordinateMacro";
7032      currentFunction->Name = vtkstrcat("Get", (yyvsp[(3) - (4)].str));
7033      currentFunction->Signature =
7034        vtkstrcat3("double *", currentFunction->Name, "();");
7035      currentFunction->Comment = vtkstrdup(getComment());
7036      set_return(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 2);
7037      output_function();
7038    }
7039     break;
7040
7041   case 455:
7042
7043 /* Line 1455 of yacc.c  */
7044 #line 2760 "vtkParse.y"
7045     {
7046      currentFunction->Macro = "vtkWorldCoordinateMacro";
7047      currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (4)].str), "Coordinate");
7048      currentFunction->Signature =
7049        vtkstrcat3("vtkCoordinate *", currentFunction->Name, "();");
7050      currentFunction->Comment = vtkstrdup(getComment());
7051      set_return(currentFunction, VTK_PARSE_OBJECT_PTR, "vtkCoordinate", 0);
7052      output_function();
7053
7054      currentFunction->Macro = "vtkWorldCoordinateMacro";
7055      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
7056      currentFunction->Signature =
7057        vtkstrcat3("void ", currentFunction->Name, "(double, double, double);");
7058      currentFunction->Comment = vtkstrdup(getComment());
7059      add_parameter(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
7060      add_parameter(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
7061      add_parameter(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
7062      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
7063      output_function();
7064
7065      currentFunction->Macro = "vtkWorldCoordinateMacro";
7066      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
7067      currentFunction->Signature =
7068        vtkstrcat3("void ", currentFunction->Name, "(double a[3]);");
7069      currentFunction->Comment = vtkstrdup(getComment());
7070      add_parameter(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 3);
7071      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
7072      output_function();
7073
7074      currentFunction->Macro = "vtkWorldCoordinateMacro";
7075      currentFunction->Name = vtkstrcat("Get", (yyvsp[(3) - (4)].str));
7076      currentFunction->Signature =
7077        vtkstrcat3("double *", currentFunction->Name, "();");
7078      currentFunction->Comment = vtkstrdup(getComment());
7079      set_return(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 3);
7080      output_function();
7081    }
7082     break;
7083
7084   case 456:
7085
7086 /* Line 1455 of yacc.c  */
7087 #line 2798 "vtkParse.y"
7088     {
7089    currentFunction->Macro = "vtkTypeMacro";
7090    currentFunction->Name = "GetClassName";
7091    currentFunction->Signature = "const char *GetClassName();";
7092    currentFunction->Comment = vtkstrdup(getComment());
7093    set_return(currentFunction, (VTK_PARSE_CONST | VTK_PARSE_CHAR_PTR),
7094               "char", 0);
7095    output_function();
7096
7097    currentFunction->Macro = "vtkTypeMacro";
7098    currentFunction->Name = "IsA";
7099    currentFunction->Signature = "int IsA(const char *name);";
7100    currentFunction->Comment = vtkstrdup(getComment());
7101    add_parameter(currentFunction, (VTK_PARSE_CONST | VTK_PARSE_CHAR_PTR),
7102                 "char", 0);
7103    set_return(currentFunction, VTK_PARSE_INT, "int", 0);
7104    output_function();
7105
7106    currentFunction->Macro = "vtkTypeMacro";
7107    currentFunction->Name = "NewInstance";
7108    currentFunction->Signature = vtkstrcat((yyvsp[(3) - (7)].str), " *NewInstance();");
7109    currentFunction->Comment = vtkstrdup(getComment());
7110    set_return(currentFunction, VTK_PARSE_OBJECT_PTR, (yyvsp[(3) - (7)].str), 0);
7111    output_function();
7112
7113    currentFunction->Macro = "vtkTypeMacro";
7114    currentFunction->Name = "SafeDownCast";
7115    currentFunction->Signature =
7116      vtkstrcat((yyvsp[(3) - (7)].str), " *SafeDownCast(vtkObject* o);");
7117    currentFunction->Comment = vtkstrdup(getComment());
7118    add_parameter(currentFunction, VTK_PARSE_OBJECT_PTR, "vtkObject", 0);
7119    set_return(currentFunction, (VTK_PARSE_STATIC | VTK_PARSE_OBJECT_PTR),
7120               (yyvsp[(3) - (7)].str), 0);
7121    output_function();
7122    }
7123     break;
7124
7125   case 459:
7126
7127 /* Line 1455 of yacc.c  */
7128 #line 2842 "vtkParse.y"
7129     { (yyval.str) = "()"; }
7130     break;
7131
7132   case 460:
7133
7134 /* Line 1455 of yacc.c  */
7135 #line 2843 "vtkParse.y"
7136     { (yyval.str) = "[]"; }
7137     break;
7138
7139   case 461:
7140
7141 /* Line 1455 of yacc.c  */
7142 #line 2844 "vtkParse.y"
7143     { (yyval.str) = " new[]"; }
7144     break;
7145
7146   case 462:
7147
7148 /* Line 1455 of yacc.c  */
7149 #line 2845 "vtkParse.y"
7150     { (yyval.str) = " delete[]"; }
7151     break;
7152
7153   case 463:
7154
7155 /* Line 1455 of yacc.c  */
7156 #line 2846 "vtkParse.y"
7157     { (yyval.str) = "<"; }
7158     break;
7159
7160   case 464:
7161
7162 /* Line 1455 of yacc.c  */
7163 #line 2847 "vtkParse.y"
7164     { (yyval.str) = ">"; }
7165     break;
7166
7167   case 465:
7168
7169 /* Line 1455 of yacc.c  */
7170 #line 2848 "vtkParse.y"
7171     { (yyval.str) = ","; }
7172     break;
7173
7174   case 466:
7175
7176 /* Line 1455 of yacc.c  */
7177 #line 2849 "vtkParse.y"
7178     { (yyval.str) = "="; }
7179     break;
7180
7181   case 468:
7182
7183 /* Line 1455 of yacc.c  */
7184 #line 2853 "vtkParse.y"
7185     { (yyval.str) = "%"; }
7186     break;
7187
7188   case 469:
7189
7190 /* Line 1455 of yacc.c  */
7191 #line 2854 "vtkParse.y"
7192     { (yyval.str) = "*"; }
7193     break;
7194
7195   case 470:
7196
7197 /* Line 1455 of yacc.c  */
7198 #line 2855 "vtkParse.y"
7199     { (yyval.str) = "/"; }
7200     break;
7201
7202   case 471:
7203
7204 /* Line 1455 of yacc.c  */
7205 #line 2856 "vtkParse.y"
7206     { (yyval.str) = "-"; }
7207     break;
7208
7209   case 472:
7210
7211 /* Line 1455 of yacc.c  */
7212 #line 2857 "vtkParse.y"
7213     { (yyval.str) = "+"; }
7214     break;
7215
7216   case 473:
7217
7218 /* Line 1455 of yacc.c  */
7219 #line 2858 "vtkParse.y"
7220     { (yyval.str) = "!"; }
7221     break;
7222
7223   case 474:
7224
7225 /* Line 1455 of yacc.c  */
7226 #line 2859 "vtkParse.y"
7227     { (yyval.str) = "~"; }
7228     break;
7229
7230   case 475:
7231
7232 /* Line 1455 of yacc.c  */
7233 #line 2860 "vtkParse.y"
7234     { (yyval.str) = "&"; }
7235     break;
7236
7237   case 476:
7238
7239 /* Line 1455 of yacc.c  */
7240 #line 2861 "vtkParse.y"
7241     { (yyval.str) = "|"; }
7242     break;
7243
7244   case 477:
7245
7246 /* Line 1455 of yacc.c  */
7247 #line 2862 "vtkParse.y"
7248     { (yyval.str) = "^"; }
7249     break;
7250
7251   case 478:
7252
7253 /* Line 1455 of yacc.c  */
7254 #line 2863 "vtkParse.y"
7255     { (yyval.str) = " new"; }
7256     break;
7257
7258   case 479:
7259
7260 /* Line 1455 of yacc.c  */
7261 #line 2864 "vtkParse.y"
7262     { (yyval.str) = " delete"; }
7263     break;
7264
7265   case 480:
7266
7267 /* Line 1455 of yacc.c  */
7268 #line 2865 "vtkParse.y"
7269     { (yyval.str) = "<<="; }
7270     break;
7271
7272   case 481:
7273
7274 /* Line 1455 of yacc.c  */
7275 #line 2866 "vtkParse.y"
7276     { (yyval.str) = ">>="; }
7277     break;
7278
7279   case 482:
7280
7281 /* Line 1455 of yacc.c  */
7282 #line 2867 "vtkParse.y"
7283     { (yyval.str) = "<<"; }
7284     break;
7285
7286   case 483:
7287
7288 /* Line 1455 of yacc.c  */
7289 #line 2868 "vtkParse.y"
7290     { (yyval.str) = ">>"; }
7291     break;
7292
7293   case 484:
7294
7295 /* Line 1455 of yacc.c  */
7296 #line 2869 "vtkParse.y"
7297     { (yyval.str) = ".*"; }
7298     break;
7299
7300   case 485:
7301
7302 /* Line 1455 of yacc.c  */
7303 #line 2870 "vtkParse.y"
7304     { (yyval.str) = "->*"; }
7305     break;
7306
7307   case 486:
7308
7309 /* Line 1455 of yacc.c  */
7310 #line 2871 "vtkParse.y"
7311     { (yyval.str) = "->"; }
7312     break;
7313
7314   case 487:
7315
7316 /* Line 1455 of yacc.c  */
7317 #line 2872 "vtkParse.y"
7318     { (yyval.str) = "+="; }
7319     break;
7320
7321   case 488:
7322
7323 /* Line 1455 of yacc.c  */
7324 #line 2873 "vtkParse.y"
7325     { (yyval.str) = "-="; }
7326     break;
7327
7328   case 489:
7329
7330 /* Line 1455 of yacc.c  */
7331 #line 2874 "vtkParse.y"
7332     { (yyval.str) = "*="; }
7333     break;
7334
7335   case 490:
7336
7337 /* Line 1455 of yacc.c  */
7338 #line 2875 "vtkParse.y"
7339     { (yyval.str) = "/="; }
7340     break;
7341
7342   case 491:
7343
7344 /* Line 1455 of yacc.c  */
7345 #line 2876 "vtkParse.y"
7346     { (yyval.str) = "%="; }
7347     break;
7348
7349   case 492:
7350
7351 /* Line 1455 of yacc.c  */
7352 #line 2877 "vtkParse.y"
7353     { (yyval.str) = "++"; }
7354     break;
7355
7356   case 493:
7357
7358 /* Line 1455 of yacc.c  */
7359 #line 2878 "vtkParse.y"
7360     { (yyval.str) = "--"; }
7361     break;
7362
7363   case 494:
7364
7365 /* Line 1455 of yacc.c  */
7366 #line 2879 "vtkParse.y"
7367     { (yyval.str) = "&="; }
7368     break;
7369
7370   case 495:
7371
7372 /* Line 1455 of yacc.c  */
7373 #line 2880 "vtkParse.y"
7374     { (yyval.str) = "|="; }
7375     break;
7376
7377   case 496:
7378
7379 /* Line 1455 of yacc.c  */
7380 #line 2881 "vtkParse.y"
7381     { (yyval.str) = "^="; }
7382     break;
7383
7384   case 497:
7385
7386 /* Line 1455 of yacc.c  */
7387 #line 2882 "vtkParse.y"
7388     { (yyval.str) = "&&"; }
7389     break;
7390
7391   case 498:
7392
7393 /* Line 1455 of yacc.c  */
7394 #line 2883 "vtkParse.y"
7395     { (yyval.str) = "||"; }
7396     break;
7397
7398   case 499:
7399
7400 /* Line 1455 of yacc.c  */
7401 #line 2884 "vtkParse.y"
7402     { (yyval.str) = "=="; }
7403     break;
7404
7405   case 500:
7406
7407 /* Line 1455 of yacc.c  */
7408 #line 2885 "vtkParse.y"
7409     { (yyval.str) = "!="; }
7410     break;
7411
7412   case 501:
7413
7414 /* Line 1455 of yacc.c  */
7415 #line 2886 "vtkParse.y"
7416     { (yyval.str) = "<="; }
7417     break;
7418
7419   case 502:
7420
7421 /* Line 1455 of yacc.c  */
7422 #line 2887 "vtkParse.y"
7423     { (yyval.str) = ">="; }
7424     break;
7425
7426   case 503:
7427
7428 /* Line 1455 of yacc.c  */
7429 #line 2890 "vtkParse.y"
7430     { (yyval.str) = "typedef"; }
7431     break;
7432
7433   case 504:
7434
7435 /* Line 1455 of yacc.c  */
7436 #line 2891 "vtkParse.y"
7437     { (yyval.str) = "typename"; }
7438     break;
7439
7440   case 505:
7441
7442 /* Line 1455 of yacc.c  */
7443 #line 2892 "vtkParse.y"
7444     { (yyval.str) = "class"; }
7445     break;
7446
7447   case 506:
7448
7449 /* Line 1455 of yacc.c  */
7450 #line 2893 "vtkParse.y"
7451     { (yyval.str) = "struct"; }
7452     break;
7453
7454   case 507:
7455
7456 /* Line 1455 of yacc.c  */
7457 #line 2894 "vtkParse.y"
7458     { (yyval.str) = "union"; }
7459     break;
7460
7461   case 508:
7462
7463 /* Line 1455 of yacc.c  */
7464 #line 2895 "vtkParse.y"
7465     { (yyval.str) = "template"; }
7466     break;
7467
7468   case 509:
7469
7470 /* Line 1455 of yacc.c  */
7471 #line 2896 "vtkParse.y"
7472     { (yyval.str) = "public"; }
7473     break;
7474
7475   case 510:
7476
7477 /* Line 1455 of yacc.c  */
7478 #line 2897 "vtkParse.y"
7479     { (yyval.str) = "protected"; }
7480     break;
7481
7482   case 511:
7483
7484 /* Line 1455 of yacc.c  */
7485 #line 2898 "vtkParse.y"
7486     { (yyval.str) = "private"; }
7487     break;
7488
7489   case 512:
7490
7491 /* Line 1455 of yacc.c  */
7492 #line 2899 "vtkParse.y"
7493     { (yyval.str) = "const"; }
7494     break;
7495
7496   case 513:
7497
7498 /* Line 1455 of yacc.c  */
7499 #line 2900 "vtkParse.y"
7500     { (yyval.str) = "static"; }
7501     break;
7502
7503   case 514:
7504
7505 /* Line 1455 of yacc.c  */
7506 #line 2901 "vtkParse.y"
7507     { (yyval.str) = "inline"; }
7508     break;
7509
7510   case 515:
7511
7512 /* Line 1455 of yacc.c  */
7513 #line 2902 "vtkParse.y"
7514     { (yyval.str) = "virtual"; }
7515     break;
7516
7517   case 516:
7518
7519 /* Line 1455 of yacc.c  */
7520 #line 2903 "vtkParse.y"
7521     { (yyval.str) = "extern"; }
7522     break;
7523
7524   case 517:
7525
7526 /* Line 1455 of yacc.c  */
7527 #line 2904 "vtkParse.y"
7528     { (yyval.str) = "namespace"; }
7529     break;
7530
7531   case 518:
7532
7533 /* Line 1455 of yacc.c  */
7534 #line 2905 "vtkParse.y"
7535     { (yyval.str) = "operator"; }
7536     break;
7537
7538   case 519:
7539
7540 /* Line 1455 of yacc.c  */
7541 #line 2906 "vtkParse.y"
7542     { (yyval.str) = "enum"; }
7543     break;
7544
7545   case 520:
7546
7547 /* Line 1455 of yacc.c  */
7548 #line 2907 "vtkParse.y"
7549     { (yyval.str) = "throw"; }
7550     break;
7551
7552   case 521:
7553
7554 /* Line 1455 of yacc.c  */
7555 #line 2908 "vtkParse.y"
7556     { (yyval.str) = "const_cast"; }
7557     break;
7558
7559   case 522:
7560
7561 /* Line 1455 of yacc.c  */
7562 #line 2909 "vtkParse.y"
7563     { (yyval.str) = "dynamic_cast"; }
7564     break;
7565
7566   case 523:
7567
7568 /* Line 1455 of yacc.c  */
7569 #line 2910 "vtkParse.y"
7570     { (yyval.str) = "static_cast"; }
7571     break;
7572
7573   case 524:
7574
7575 /* Line 1455 of yacc.c  */
7576 #line 2911 "vtkParse.y"
7577     { (yyval.str) = "reinterpret_cast"; }
7578     break;
7579
7580   case 537:
7581
7582 /* Line 1455 of yacc.c  */
7583 #line 2935 "vtkParse.y"
7584     {
7585       if ((((yyvsp[(1) - (1)].str))[0] == '+' || ((yyvsp[(1) - (1)].str))[0] == '-' ||
7586            ((yyvsp[(1) - (1)].str))[0] == '*' || ((yyvsp[(1) - (1)].str))[0] == '&') &&
7587           ((yyvsp[(1) - (1)].str))[1] == '\0')
7588         {
7589         int c1 = 0;
7590         size_t l;
7591         const char *cp;
7592         chopSig();
7593         cp = getSig();
7594         l = getSigLength();
7595         if (l != 0) { c1 = cp[l-1]; }
7596         if (c1 != 0 && c1 != '(' && c1 != '[' && c1 != '=')
7597           {
7598           postSig(" ");
7599           }
7600         postSig((yyvsp[(1) - (1)].str));
7601         if ((c1 >= 'A' && c1 <= 'Z') || (c1 >= 'a' && c1 <= 'z') ||
7602             (c1 >= '0' && c1 <= '9') || c1 == '_' || c1 == '\'' ||
7603             c1 == '\"' || c1 == ')' || c1 == ']')
7604           {
7605           postSig(" ");
7606           }
7607         }
7608        else
7609         {
7610         postSig((yyvsp[(1) - (1)].str));
7611         postSig(" ");
7612         }
7613     }
7614     break;
7615
7616   case 538:
7617
7618 /* Line 1455 of yacc.c  */
7619 #line 2965 "vtkParse.y"
7620     { postSig(":"); postSig(" "); }
7621     break;
7622
7623   case 539:
7624
7625 /* Line 1455 of yacc.c  */
7626 #line 2965 "vtkParse.y"
7627     { postSig("."); }
7628     break;
7629
7630   case 540:
7631
7632 /* Line 1455 of yacc.c  */
7633 #line 2966 "vtkParse.y"
7634     { chopSig(); postSig("::"); }
7635     break;
7636
7637   case 541:
7638
7639 /* Line 1455 of yacc.c  */
7640 #line 2967 "vtkParse.y"
7641     { postSig((yyvsp[(1) - (1)].str)); postSig(" "); }
7642     break;
7643
7644   case 542:
7645
7646 /* Line 1455 of yacc.c  */
7647 #line 2968 "vtkParse.y"
7648     { postSig((yyvsp[(1) - (1)].str)); postSig(" "); }
7649     break;
7650
7651   case 544:
7652
7653 /* Line 1455 of yacc.c  */
7654 #line 2971 "vtkParse.y"
7655     {
7656       int c1 = 0;
7657       size_t l;
7658       const char *cp;
7659       chopSig();
7660       cp = getSig();
7661       l = getSigLength();
7662       if (l != 0) { c1 = cp[l-1]; }
7663       while (((c1 >= 'A' && c1 <= 'Z') || (c1 >= 'a' && c1 <= 'z') ||
7664               (c1 >= '0' && c1 <= '9') || c1 == '_') && l != 0)
7665         {
7666         --l;
7667         c1 = cp[l-1];
7668         }
7669       if (l < 2 || cp[l-1] != ':' || cp[l-2] != ':')
7670         {
7671         cp = add_const_scope(&cp[l]);
7672         resetSig(l);
7673         postSig(cp);
7674         }
7675     }
7676     break;
7677
7678   case 548:
7679
7680 /* Line 1455 of yacc.c  */
7681 #line 2997 "vtkParse.y"
7682     { postSig("< "); }
7683     break;
7684
7685   case 549:
7686
7687 /* Line 1455 of yacc.c  */
7688 #line 2998 "vtkParse.y"
7689     { postSig("> "); }
7690     break;
7691
7692   case 551:
7693
7694 /* Line 1455 of yacc.c  */
7695 #line 3001 "vtkParse.y"
7696     { postSig("= "); }
7697     break;
7698
7699   case 552:
7700
7701 /* Line 1455 of yacc.c  */
7702 #line 3002 "vtkParse.y"
7703     { chopSig(); postSig(", "); }
7704     break;
7705
7706   case 554:
7707
7708 /* Line 1455 of yacc.c  */
7709 #line 3005 "vtkParse.y"
7710     { chopSig(); postSig(";"); }
7711     break;
7712
7713   case 562:
7714
7715 /* Line 1455 of yacc.c  */
7716 #line 3019 "vtkParse.y"
7717     { postSig("= "); }
7718     break;
7719
7720   case 563:
7721
7722 /* Line 1455 of yacc.c  */
7723 #line 3020 "vtkParse.y"
7724     { chopSig(); postSig(", "); }
7725     break;
7726
7727   case 564:
7728
7729 /* Line 1455 of yacc.c  */
7730 #line 3024 "vtkParse.y"
7731     {
7732       chopSig();
7733       if (getSig()[getSigLength()-1] == '<') { postSig(" "); }
7734       postSig("<");
7735     }
7736     break;
7737
7738   case 565:
7739
7740 /* Line 1455 of yacc.c  */
7741 #line 3030 "vtkParse.y"
7742     {
7743       chopSig();
7744       if (getSig()[getSigLength()-1] == '>') { postSig(" "); }
7745       postSig("> ");
7746     }
7747     break;
7748
7749   case 566:
7750
7751 /* Line 1455 of yacc.c  */
7752 #line 3037 "vtkParse.y"
7753     { postSig("["); }
7754     break;
7755
7756   case 567:
7757
7758 /* Line 1455 of yacc.c  */
7759 #line 3038 "vtkParse.y"
7760     { chopSig(); postSig("] "); }
7761     break;
7762
7763   case 568:
7764
7765 /* Line 1455 of yacc.c  */
7766 #line 3041 "vtkParse.y"
7767     { postSig("("); }
7768     break;
7769
7770   case 569:
7771
7772 /* Line 1455 of yacc.c  */
7773 #line 3042 "vtkParse.y"
7774     { chopSig(); postSig(") "); }
7775     break;
7776
7777   case 570:
7778
7779 /* Line 1455 of yacc.c  */
7780 #line 3043 "vtkParse.y"
7781     { postSig("("); postSig((yyvsp[(1) - (1)].str)); postSig("*"); }
7782     break;
7783
7784   case 571:
7785
7786 /* Line 1455 of yacc.c  */
7787 #line 3044 "vtkParse.y"
7788     { chopSig(); postSig(") "); }
7789     break;
7790
7791   case 572:
7792
7793 /* Line 1455 of yacc.c  */
7794 #line 3045 "vtkParse.y"
7795     { postSig("("); postSig((yyvsp[(1) - (1)].str)); postSig("&"); }
7796     break;
7797
7798   case 573:
7799
7800 /* Line 1455 of yacc.c  */
7801 #line 3046 "vtkParse.y"
7802     { chopSig(); postSig(") "); }
7803     break;
7804
7805   case 574:
7806
7807 /* Line 1455 of yacc.c  */
7808 #line 3049 "vtkParse.y"
7809     { postSig("{ "); }
7810     break;
7811
7812   case 575:
7813
7814 /* Line 1455 of yacc.c  */
7815 #line 3049 "vtkParse.y"
7816     { postSig("} "); }
7817     break;
7818
7819
7820
7821 /* Line 1455 of yacc.c  */
7822 #line 7941 "vtkParse.tab.c"
7823       default: break;
7824     }
7825   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
7826
7827   YYPOPSTACK (yylen);
7828   yylen = 0;
7829   YY_STACK_PRINT (yyss, yyssp);
7830
7831   *++yyvsp = yyval;
7832
7833   /* Now `shift' the result of the reduction.  Determine what state
7834      that goes to, based on the state we popped back to and the rule
7835      number reduced by.  */
7836
7837   yyn = yyr1[yyn];
7838
7839   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
7840   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
7841     yystate = yytable[yystate];
7842   else
7843     yystate = yydefgoto[yyn - YYNTOKENS];
7844
7845   goto yynewstate;
7846
7847
7848 /*------------------------------------.
7849 | yyerrlab -- here on detecting error |
7850 `------------------------------------*/
7851 yyerrlab:
7852   /* If not already recovering from an error, report this error.  */
7853   if (!yyerrstatus)
7854     {
7855       ++yynerrs;
7856 #if ! YYERROR_VERBOSE
7857       yyerror (YY_("syntax error"));
7858 #else
7859       {
7860         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
7861         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
7862           {
7863             YYSIZE_T yyalloc = 2 * yysize;
7864             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
7865               yyalloc = YYSTACK_ALLOC_MAXIMUM;
7866             if (yymsg != yymsgbuf)
7867               YYSTACK_FREE (yymsg);
7868             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
7869             if (yymsg)
7870               yymsg_alloc = yyalloc;
7871             else
7872               {
7873                 yymsg = yymsgbuf;
7874                 yymsg_alloc = sizeof yymsgbuf;
7875               }
7876           }
7877
7878         if (0 < yysize && yysize <= yymsg_alloc)
7879           {
7880             (void) yysyntax_error (yymsg, yystate, yychar);
7881             yyerror (yymsg);
7882           }
7883         else
7884           {
7885             yyerror (YY_("syntax error"));
7886             if (yysize != 0)
7887               goto yyexhaustedlab;
7888           }
7889       }
7890 #endif
7891     }
7892
7893
7894
7895   if (yyerrstatus == 3)
7896     {
7897       /* If just tried and failed to reuse lookahead token after an
7898          error, discard it.  */
7899
7900       if (yychar <= YYEOF)
7901         {
7902           /* Return failure if at end of input.  */
7903           if (yychar == YYEOF)
7904             YYABORT;
7905         }
7906       else
7907         {
7908           yydestruct ("Error: discarding",
7909                       yytoken, &yylval);
7910           yychar = YYEMPTY;
7911         }
7912     }
7913
7914   /* Else will try to reuse lookahead token after shifting the error
7915      token.  */
7916   goto yyerrlab1;
7917
7918
7919 /*---------------------------------------------------.
7920 | yyerrorlab -- error raised explicitly by YYERROR.  |
7921 `---------------------------------------------------*/
7922 yyerrorlab:
7923
7924   /* Pacify compilers like GCC when the user code never invokes
7925      YYERROR and the label yyerrorlab therefore never appears in user
7926      code.  */
7927   if (/*CONSTCOND*/ 0)
7928      goto yyerrorlab;
7929
7930   /* Do not reclaim the symbols of the rule which action triggered
7931      this YYERROR.  */
7932   YYPOPSTACK (yylen);
7933   yylen = 0;
7934   YY_STACK_PRINT (yyss, yyssp);
7935   yystate = *yyssp;
7936
7937
7938 /*-------------------------------------------------------------.
7939 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
7940 `-------------------------------------------------------------*/
7941 yyerrlab1:
7942   yyerrstatus = 3;        /* Each real token shifted decrements this.  */
7943
7944   for (;;)
7945     {
7946       yyn = yypact[yystate];
7947       if (yyn != YYPACT_NINF)
7948         {
7949           yyn += YYTERROR;
7950           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
7951             {
7952               yyn = yytable[yyn];
7953               if (0 < yyn)
7954                 break;
7955             }
7956         }
7957
7958       /* Pop the current state because it cannot handle the error token.  */
7959       if (yyssp == yyss)
7960         YYABORT;
7961
7962
7963       yydestruct ("Error: popping",
7964                   yystos[yystate], yyvsp);
7965       YYPOPSTACK (1);
7966       yystate = *yyssp;
7967       YY_STACK_PRINT (yyss, yyssp);
7968     }
7969
7970   *++yyvsp = yylval;
7971
7972
7973   /* Shift the error token.  */
7974   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7975
7976   yystate = yyn;
7977   goto yynewstate;
7978
7979
7980 /*-------------------------------------.
7981 | yyacceptlab -- YYACCEPT comes here.  |
7982 `-------------------------------------*/
7983 yyacceptlab:
7984   yyresult = 0;
7985   goto yyreturn;
7986
7987 /*-----------------------------------.
7988 | yyabortlab -- YYABORT comes here.  |
7989 `-----------------------------------*/
7990 yyabortlab:
7991   yyresult = 1;
7992   goto yyreturn;
7993
7994 #if !defined(yyoverflow) || YYERROR_VERBOSE
7995 /*-------------------------------------------------.
7996 | yyexhaustedlab -- memory exhaustion comes here.  |
7997 `-------------------------------------------------*/
7998 yyexhaustedlab:
7999   yyerror (YY_("memory exhausted"));
8000   yyresult = 2;
8001   /* Fall through.  */
8002 #endif
8003
8004 yyreturn:
8005   if (yychar != YYEMPTY)
8006      yydestruct ("Cleanup: discarding lookahead",
8007                  yytoken, &yylval);
8008   /* Do not reclaim the symbols of the rule which action triggered
8009      this YYABORT or YYACCEPT.  */
8010   YYPOPSTACK (yylen);
8011   YY_STACK_PRINT (yyss, yyssp);
8012   while (yyssp != yyss)
8013     {
8014       yydestruct ("Cleanup: popping",
8015                   yystos[*yyssp], yyvsp);
8016       YYPOPSTACK (1);
8017     }
8018 #ifndef yyoverflow
8019   if (yyss != yyssa)
8020     YYSTACK_FREE (yyss);
8021 #endif
8022 #if YYERROR_VERBOSE
8023   if (yymsg != yymsgbuf)
8024     YYSTACK_FREE (yymsg);
8025 #endif
8026   /* Make sure YYID is used.  */
8027   return YYID (yyresult);
8028 }
8029
8030
8031
8032 /* Line 1675 of yacc.c  */
8033 #line 3088 "vtkParse.y"
8034
8035 #include <string.h>
8036 #include "lex.yy.c"
8037
8038 /* fill in the type name if none given */
8039 const char *type_class(unsigned int type, const char *classname)
8040 {
8041   if (classname)
8042     {
8043     if (classname[0] == '\0')
8044       {
8045       switch ((type & VTK_PARSE_BASE_TYPE))
8046         {
8047         case VTK_PARSE_VOID:
8048           classname = "void";
8049           break;
8050         case VTK_PARSE_BOOL:
8051           classname = "bool";
8052           break;
8053         case VTK_PARSE_FLOAT:
8054           classname = "float";
8055           break;
8056         case VTK_PARSE_DOUBLE:
8057           classname = "double";
8058           break;
8059         case VTK_PARSE_LONG_DOUBLE:
8060           classname = "long double";
8061           break;
8062         case VTK_PARSE_CHAR:
8063           classname = "char";
8064           break;
8065         case VTK_PARSE_UNSIGNED_CHAR:
8066           classname = "unsigned char";
8067           break;
8068         case VTK_PARSE_SIGNED_CHAR:
8069           classname = "signed char";
8070           break;
8071         case VTK_PARSE_SHORT:
8072           classname = "short";
8073           break;
8074         case VTK_PARSE_UNSIGNED_SHORT:
8075           classname = "unsigned short";
8076           break;
8077         case VTK_PARSE_INT:
8078           classname = "int";
8079           break;
8080         case VTK_PARSE_UNSIGNED_INT:
8081           classname = "unsigned int";
8082           break;
8083         case VTK_PARSE_LONG:
8084           classname = "long";
8085           break;
8086         case VTK_PARSE_UNSIGNED_LONG:
8087           classname = "unsigned long";
8088           break;
8089         case VTK_PARSE_LONG_LONG:
8090           classname = "long long";
8091           break;
8092         case VTK_PARSE_UNSIGNED_LONG_LONG:
8093           classname = "unsigned long long";
8094           break;
8095         case VTK_PARSE___INT64:
8096           classname = "__int64";
8097           break;
8098         case VTK_PARSE_UNSIGNED___INT64:
8099           classname = "unsigned __int64";
8100           break;
8101         }
8102       }
8103     }
8104
8105   return classname;
8106 }
8107
8108 /* check whether this is the class we are looking for */
8109 void start_class(const char *classname, int is_struct_or_union)
8110 {
8111   ClassInfo *outerClass = currentClass;
8112   pushClass();
8113   currentClass = (ClassInfo *)malloc(sizeof(ClassInfo));
8114   vtkParse_InitClass(currentClass);
8115   currentClass->Name = classname;
8116   if (is_struct_or_union == 1)
8117     {
8118     currentClass->ItemType = VTK_STRUCT_INFO;
8119     }
8120   if (is_struct_or_union == 2)
8121     {
8122     currentClass->ItemType = VTK_UNION_INFO;
8123     }
8124
8125   if (classname && classname[strlen(classname)-1] != '>')
8126     {
8127     if (outerClass)
8128       {
8129       vtkParse_AddClassToClass(outerClass, currentClass);
8130       }
8131     else
8132       {
8133       vtkParse_AddClassToNamespace(currentNamespace, currentClass);
8134       }
8135     }
8136
8137   /* template information */
8138   if (currentTemplate)
8139     {
8140     currentClass->Template = currentTemplate;
8141     currentTemplate = NULL;
8142     }
8143
8144   /* comment, if any */
8145   currentClass->Comment = vtkstrdup(getComment());
8146
8147   access_level = VTK_ACCESS_PRIVATE;
8148   if (is_struct_or_union)
8149     {
8150     access_level = VTK_ACCESS_PUBLIC;
8151     }
8152
8153   vtkParse_InitFunction(currentFunction);
8154   startSig();
8155   clearComment();
8156 }
8157
8158 /* reject the class */
8159 void reject_class(const char *classname, int is_struct_or_union)
8160 {
8161   static ClassInfo static_class;
8162
8163   pushClass();
8164   currentClass = &static_class;
8165   currentClass->Name = classname;
8166   vtkParse_InitClass(currentClass);
8167
8168   access_level = VTK_ACCESS_PRIVATE;
8169   if (is_struct_or_union)
8170     {
8171     access_level = VTK_ACCESS_PUBLIC;
8172     }
8173
8174   vtkParse_InitFunction(currentFunction);
8175   startSig();
8176   clearComment();
8177 }
8178
8179 /* reached the end of a class definition */
8180 void end_class()
8181 {
8182   /* add default constructors */
8183   vtkParse_AddDefaultConstructors(currentClass, data->Strings);
8184
8185   popClass();
8186 }
8187
8188 /* add a base class to the specified class */
8189 void add_base_class(ClassInfo *cls, const char *name, int al, int virt)
8190 {
8191   if (cls && al == VTK_ACCESS_PUBLIC && virt == 0)
8192     {
8193     vtkParse_AddStringToArray(&cls->SuperClasses,
8194                               &cls->NumberOfSuperClasses,
8195                               name);
8196     }
8197 }
8198
8199 /* add a using declaration or directive */
8200 void add_using(const char *name, int is_namespace)
8201 {
8202   size_t i;
8203   UsingInfo *item;
8204
8205   item = (UsingInfo *)malloc(sizeof(UsingInfo));
8206   vtkParse_InitUsing(item);
8207   if (is_namespace)
8208     {
8209     item->Name = NULL;
8210     item->Scope = name;
8211     }
8212   else
8213     {
8214     i = strlen(name);
8215     while (i > 0 && name[i-1] != ':') { i--; }
8216     item->Name = vtkstrdup(&name[i]);
8217     while (i > 0 && name[i-1] == ':') { i--; }
8218     item->Scope = vtkstrndup(name, i);
8219     }
8220
8221   if (currentClass)
8222     {
8223     vtkParse_AddUsingToClass(currentClass, item);
8224     }
8225   else
8226     {
8227     vtkParse_AddUsingToNamespace(currentNamespace, item);
8228     }
8229 }
8230
8231 /* start a new enum */
8232 void start_enum(const char *name)
8233 {
8234   EnumInfo *item;
8235
8236   currentEnumName = "int";
8237   currentEnumValue = NULL;
8238   if (name)
8239     {
8240     currentEnumName = name;
8241     item = (EnumInfo *)malloc(sizeof(EnumInfo));
8242     vtkParse_InitEnum(item);
8243     item->Name = name;
8244     item->Access = access_level;
8245     if (currentClass)
8246       {
8247       vtkParse_AddEnumToClass(currentClass, item);
8248       }
8249     else
8250       {
8251       vtkParse_AddEnumToNamespace(currentNamespace, item);
8252       }
8253     }
8254 }
8255
8256 /* finish the enum */
8257 void end_enum()
8258 {
8259   currentEnumName = NULL;
8260   currentEnumValue = NULL;
8261 }
8262
8263 /* add a constant to the enum */
8264 void add_enum(const char *name, const char *value)
8265 {
8266   static char text[2048];
8267   int i;
8268   long j;
8269
8270   if (value)
8271     {
8272     strcpy(text, value);
8273     currentEnumValue = value;
8274     }
8275   else if (currentEnumValue)
8276     {
8277     i = strlen(text);
8278     while (i > 0 && text[i-1] >= '0' &&
8279            text[i-1] <= '9') { i--; }
8280
8281     if (i == 0 || text[i-1] == ' ' ||
8282         (i > 1 && text[i-2] == ' ' &&
8283          (text[i-1] == '-' || text[i-1] == '+')))
8284       {
8285       if (i > 0 && text[i-1] != ' ')
8286         {
8287         i--;
8288         }
8289       j = (int)strtol(&text[i], NULL, 10);
8290       sprintf(&text[i], "%li", j+1);
8291       }
8292     else
8293       {
8294       i = strlen(text);
8295       strcpy(&text[i], " + 1");
8296       }
8297     currentEnumValue = vtkstrdup(text);
8298     }
8299   else
8300     {
8301     strcpy(text, "0");
8302     currentEnumValue = "0";
8303     }
8304
8305   add_constant(name, currentEnumValue, VTK_PARSE_INT, currentEnumName, 2);
8306 }
8307
8308 /* for a macro constant, guess the constant type, doesn't do any math */
8309 unsigned int guess_constant_type(const char *valstring)
8310 {
8311   unsigned int valtype = 0;
8312   size_t k;
8313   int i;
8314   int is_name = 0;
8315
8316   if (valstring == NULL || valstring[0] == '\0')
8317     {
8318     return 0;
8319     }
8320
8321   if (valstring[0] < '0' || valstring[0] > '9')
8322     {
8323     k = 0;
8324     while ((valstring[k] >= '0' && valstring[k] <= '9') ||
8325            (valstring[k] >= 'a' && valstring[k] <= 'z') ||
8326            (valstring[k] >= 'A' && valstring[k] <= 'Z') ||
8327            valstring[k] == '_') { k++; }
8328
8329     if (valstring[k] == '\0')
8330       {
8331       is_name = 1;
8332       }
8333     }
8334
8335   if (strcmp(valstring, "true") == 0 || strcmp(valstring, "false") == 0)
8336     {
8337     return VTK_PARSE_BOOL;
8338     }
8339
8340   if (valstring[0] == '\'')
8341     {
8342     return VTK_PARSE_CHAR;
8343     }
8344
8345   if (strncmp(valstring, "VTK_TYPE_CAST(", 14) == 0 ||
8346       strncmp(valstring, "static_cast<", 12) == 0 ||
8347       strncmp(valstring, "const_cast<", 11) == 0 ||
8348       strncmp(valstring, "(", 1) == 0)
8349     {
8350     const char *cp;
8351     size_t n;
8352     int is_unsigned = 0;
8353
8354     cp = &valstring[1];
8355     if (valstring[0] == 'c')
8356       {
8357       cp = &valstring[11];
8358       }
8359     else if (valstring[0] == 's')
8360       {
8361       cp = &valstring[12];
8362       }
8363     else if (valstring[0] == 'V')
8364       {
8365       cp = &valstring[14];
8366       }
8367
8368     if (strncmp(cp, "unsigned ", 9) == 0)
8369       {
8370       is_unsigned = 1;
8371       cp += 9;
8372       }
8373
8374     n = strlen(cp);
8375     for (k = 0; k < n && cp[k] != ',' &&
8376          cp[k] != '>' && cp[k] != ')'; k++) { ; };
8377
8378     if (strncmp(cp, "long long", k) == 0)
8379       { valtype = VTK_PARSE_LONG_LONG; }
8380     else if (strncmp(cp, "__int64", k) == 0)
8381       { valtype = VTK_PARSE___INT64; }
8382     else if (strncmp(cp, "long", k) == 0)
8383       { valtype = VTK_PARSE_LONG; }
8384     else if (strncmp(cp, "short", k) == 0)
8385       { valtype = VTK_PARSE_SHORT; }
8386     else if (strncmp(cp, "signed char", k) == 0)
8387       { valtype = VTK_PARSE_SIGNED_CHAR; }
8388     else if (strncmp(cp, "char", k) == 0)
8389       { valtype = VTK_PARSE_CHAR; }
8390     else if (strncmp(cp, "int", k) == 0 ||
8391              strncmp(cp, "signed", k) == 0)
8392       { valtype = VTK_PARSE_INT; }
8393     else if (strncmp(cp, "float", k) == 0)
8394       { valtype = VTK_PARSE_FLOAT; }
8395     else if (strncmp(cp, "double", k) == 0)
8396       { valtype = VTK_PARSE_DOUBLE; }
8397     else if (strncmp(cp, "char *", k) == 0)
8398       { valtype = VTK_PARSE_CHAR_PTR; }
8399
8400     if (is_unsigned)
8401       {
8402       if (valtype == 0) { valtype = VTK_PARSE_INT; }
8403       valtype = (valtype | VTK_PARSE_UNSIGNED);
8404       }
8405
8406     if (valtype != 0)
8407       {
8408       return valtype;
8409       }
8410     }
8411
8412   /* check the current scope */
8413   if (is_name)
8414     {
8415     NamespaceInfo *scope = currentNamespace;
8416     if (namespaceDepth > 0)
8417       {
8418       scope = namespaceStack[0];
8419       }
8420
8421     for (i = 0; i < scope->NumberOfConstants; i++)
8422       {
8423       if (strcmp(scope->Constants[i]->Name, valstring) == 0)
8424         {
8425         return scope->Constants[i]->Type;
8426         }
8427       }
8428     }
8429
8430   /* check for preprocessor macros */
8431   if (is_name)
8432     {
8433     MacroInfo *macro = vtkParsePreprocess_GetMacro(
8434       preprocessor, valstring);
8435
8436     if (macro && !macro->IsFunction)
8437       {
8438       return guess_constant_type(macro->Definition);
8439       }
8440     }
8441
8442   /* fall back to the preprocessor to evaluate the constant */
8443     {
8444     preproc_int_t val;
8445     int is_unsigned;
8446     int result = vtkParsePreprocess_EvaluateExpression(
8447       preprocessor, valstring, &val, &is_unsigned);
8448
8449     if (result == VTK_PARSE_PREPROC_DOUBLE)
8450       {
8451       return VTK_PARSE_DOUBLE;
8452       }
8453     else if (result == VTK_PARSE_PREPROC_FLOAT)
8454       {
8455       return VTK_PARSE_FLOAT;
8456       }
8457     else if (result == VTK_PARSE_PREPROC_STRING)
8458       {
8459       return VTK_PARSE_CHAR_PTR;
8460       }
8461     else if (result == VTK_PARSE_OK)
8462       {
8463       if (is_unsigned)
8464         {
8465         if ((preproc_uint_t)val <= VTK_UNSIGNED_INT_MAX)
8466           {
8467           return VTK_PARSE_UNSIGNED_INT;
8468           }
8469         else
8470           {
8471 #if defined(VTK_TYPE_USE_LONG_LONG)
8472           return VTK_PARSE_UNSIGNED_LONG_LONG;
8473 #elif defined(VTK_TYPE_USE___INT64)
8474           return VTK_PARSE_UNSIGNED___INT64;
8475 #else
8476           return VTK_PARSE_UNSIGNED_LONG;
8477 #endif
8478           }
8479         }
8480       else
8481         {
8482         if (val >= VTK_INT_MIN && val <= VTK_INT_MAX)
8483           {
8484           return VTK_PARSE_INT;
8485           }
8486         else
8487           {
8488 #if defined(VTK_TYPE_USE_LONG_LONG)
8489           return VTK_PARSE_LONG_LONG;
8490 #elif defined(VTK_TYPE_USE___INT64)
8491           return VTK_PARSE___INT64;
8492 #else
8493           return VTK_PARSE_LONG;
8494 #endif
8495           }
8496         }
8497       }
8498     }
8499
8500   return 0;
8501 }
8502
8503 /* add a constant to the current class or namespace */
8504 void add_constant(const char *name, const char *value,
8505                   unsigned int type, const char *typeclass, int flag)
8506 {
8507   ValueInfo *con = (ValueInfo *)malloc(sizeof(ValueInfo));
8508   vtkParse_InitValue(con);
8509   con->ItemType = VTK_CONSTANT_INFO;
8510   con->Name = name;
8511   con->Value = value;
8512   con->Type = type;
8513   con->Class = type_class(type, typeclass);
8514
8515   if (flag == 2)
8516     {
8517     con->IsEnum = 1;
8518     }
8519
8520   if (flag == 1)
8521     {
8522     /* actually a macro, need to guess the type */
8523     ValueInfo **cptr = data->Contents->Constants;
8524     int n = data->Contents->NumberOfConstants;
8525     int i;
8526
8527     con->Access = VTK_ACCESS_PUBLIC;
8528     if (con->Type == 0)
8529       {
8530       con->Type = guess_constant_type(con->Value);
8531       }
8532
8533     for (i = 0; i < n; i++)
8534       {
8535       if (strcmp(cptr[i]->Name, con->Name) == 0)
8536         {
8537         break;
8538         }
8539       }
8540
8541     if (i == n)
8542       {
8543       vtkParse_AddConstantToNamespace(data->Contents, con);
8544       }
8545     else
8546       {
8547       vtkParse_FreeValue(con);
8548       }
8549     }
8550   else if (currentClass)
8551     {
8552     con->Access = access_level;
8553     vtkParse_AddConstantToClass(currentClass, con);
8554     }
8555   else
8556     {
8557     con->Access = VTK_ACCESS_PUBLIC;
8558     vtkParse_AddConstantToNamespace(currentNamespace, con);
8559     }
8560 }
8561
8562 /* if the name is a const in this namespace, the scope it */
8563 const char *add_const_scope(const char *name)
8564 {
8565   static char text[256];
8566   NamespaceInfo *scope = currentNamespace;
8567   int i, j;
8568   int addscope = 0;
8569
8570   strcpy(text, name);
8571
8572   if (currentClass)
8573     {
8574     for (j = 0; j < currentClass->NumberOfConstants; j++)
8575       {
8576       if (strcmp(currentClass->Constants[j]->Name, text) == 0)
8577         {
8578         prepend_scope(text, currentClass->Name);
8579         addscope = 1;
8580         }
8581       }
8582     }
8583   i = namespaceDepth;
8584   while (scope && scope->Name)
8585     {
8586     if (addscope)
8587       {
8588       prepend_scope(text, scope->Name);
8589       }
8590     else
8591       {
8592       for (j = 0; j < scope->NumberOfConstants; j++)
8593         {
8594         if (strcmp(scope->Constants[j]->Name, text) == 0)
8595           {
8596           prepend_scope(text, scope->Name);
8597           addscope = 1;
8598           }
8599         }
8600       }
8601
8602     scope = 0;
8603     if (i > 0)
8604       {
8605       scope = namespaceStack[--i];
8606       }
8607     }
8608
8609   return text;
8610 }
8611
8612 /* guess the type from the ID */
8613 unsigned int guess_id_type(const char *cp)
8614 {
8615   unsigned int t = 0;
8616
8617   if (cp)
8618     {
8619     size_t i;
8620     const char *dp;
8621
8622     i = strlen(cp);
8623     while (i > 0 && cp[i-1] != ':') { i--; }
8624     dp = &cp[i];
8625
8626     if (strcmp(dp, "vtkStdString") == 0 ||
8627         strcmp(cp, "std::string") == 0)
8628       {
8629       t = VTK_PARSE_STRING;
8630       }
8631     else if (strcmp(dp, "vtkUnicodeString") == 0)
8632       {
8633       t = VTK_PARSE_UNICODE_STRING;
8634       }
8635     else if (strncmp(dp, "vtk", 3) == 0)
8636       {
8637       t = VTK_PARSE_OBJECT;
8638       }
8639     else if (strncmp(dp, "Q", 1) == 0 ||
8640              strncmp(cp, "Qt::", 4) == 0)
8641       {
8642       t = VTK_PARSE_QOBJECT;
8643       }
8644     else
8645       {
8646       t = VTK_PARSE_UNKNOWN;
8647       }
8648     }
8649
8650   return t;
8651 }
8652
8653 /* add a template parameter to the current template */
8654 void add_template_parameter(
8655   unsigned int datatype, unsigned int extra, const char *funcSig)
8656 {
8657   ValueInfo *param = (ValueInfo *)malloc(sizeof(ValueInfo));
8658   vtkParse_InitValue(param);
8659   handle_complex_type(param, datatype, extra, funcSig);
8660   param->Name = getVarName();
8661   vtkParse_AddParameterToTemplate(currentTemplate, param);
8662 }
8663
8664 /* add a parameter to a function */
8665 void add_parameter(FunctionInfo *func, unsigned int type,
8666                    const char *typeclass, int count)
8667 {
8668   char text[64];
8669   ValueInfo *param = (ValueInfo *)malloc(sizeof(ValueInfo));
8670   vtkParse_InitValue(param);
8671
8672   param->Type = type;
8673   param->Class = type_class(type, typeclass);
8674
8675   if (count)
8676     {
8677     param->Count = count;
8678     sprintf(text, "%i", count);
8679     vtkParse_AddStringToArray(&param->Dimensions, &param->NumberOfDimensions,
8680                               vtkstrdup(text));
8681     }
8682
8683   add_legacy_parameter(func, param);
8684
8685   vtkParse_AddParameterToFunction(func, param);
8686 }
8687
8688 /* set the return type for the current function */
8689 void set_return(FunctionInfo *func, unsigned int type,
8690                 const char *typeclass, int count)
8691 {
8692   char text[64];
8693   ValueInfo *val = (ValueInfo *)malloc(sizeof(ValueInfo));
8694
8695   vtkParse_InitValue(val);
8696   val->Type = type;
8697   val->Class = type_class(type, typeclass);
8698
8699   if (count)
8700     {
8701     val->Count = count;
8702     sprintf(text, "%i", count);
8703     vtkParse_AddStringToArray(&val->Dimensions, &val->NumberOfDimensions,
8704                               vtkstrdup(text));
8705     }
8706
8707   func->ReturnValue = val;
8708
8709 #ifndef VTK_PARSE_LEGACY_REMOVE
8710   func->ReturnType = val->Type;
8711   func->ReturnClass = val->Class;
8712   func->HaveHint = (count > 0);
8713   func->HintSize = count;
8714 #endif
8715 }
8716
8717 int count_from_dimensions(ValueInfo *val)
8718 {
8719   int count, i, n;
8720   const char *cp;
8721
8722   /* count is the product of the dimensions */
8723   count = 0;
8724   if (val->NumberOfDimensions)
8725     {
8726     count = 1;
8727     for (i = 0; i < val->NumberOfDimensions; i++)
8728       {
8729       n = 0;
8730       cp = val->Dimensions[i];
8731       if (cp[0] != '\0')
8732         {
8733         while (*cp != '\0' && *cp >= '0' && *cp <= '9') { cp++; }
8734         while (*cp != '\0' && (*cp == 'u' || *cp == 'l' ||
8735                                *cp == 'U' || *cp == 'L')) { cp++; }
8736         if (*cp == '\0')
8737           {
8738           n = (int)strtol(val->Dimensions[i], NULL, 0);
8739           }
8740         }
8741       count *= n;
8742       }
8743     }
8744
8745   return count;
8746 }
8747
8748 /* deal with types that include function pointers or arrays */
8749 void handle_complex_type(
8750   ValueInfo *val, unsigned int datatype, unsigned int extra,
8751   const char *funcSig)
8752 {
8753   FunctionInfo *func = 0;
8754
8755   /* remove specifiers like "friend" and "typedef" */
8756   datatype &= VTK_PARSE_QUALIFIED_TYPE;
8757
8758   /* if "extra" was set, parentheses were involved */
8759   if ((extra & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION)
8760     {
8761     /* the current type becomes the function return type */
8762     func = getFunction();
8763     func->ReturnValue = (ValueInfo *)malloc(sizeof(ValueInfo));
8764     vtkParse_InitValue(func->ReturnValue);
8765     func->ReturnValue->Type = datatype;
8766     func->ReturnValue->Class = type_class(datatype, getTypeId());
8767     if (funcSig) { func->Signature = vtkstrdup(funcSig); }
8768     val->Function = func;
8769
8770 #ifndef VTK_PARSE_LEGACY_REMOVE
8771     func->ReturnType = func->ReturnValue->Type;
8772     func->ReturnClass = func->ReturnValue->Class;
8773 #endif
8774
8775     /* the val type is whatever was inside the parentheses */
8776     clearTypeId();
8777     setTypeId(func->Class ? "method" : "function");
8778     datatype = (extra & VTK_PARSE_UNQUALIFIED_TYPE);
8779     }
8780   else if ((extra & VTK_PARSE_INDIRECT) == VTK_PARSE_BAD_INDIRECT)
8781     {
8782     datatype = (datatype | VTK_PARSE_BAD_INDIRECT);
8783     }
8784   else if ((extra & VTK_PARSE_INDIRECT) != 0)
8785     {
8786     extra = (extra & VTK_PARSE_INDIRECT);
8787
8788     if ((extra & VTK_PARSE_REF) != 0)
8789       {
8790       datatype = (datatype | VTK_PARSE_REF);
8791       extra = (extra & ~VTK_PARSE_REF);
8792       }
8793
8794     if (extra != 0 && getArrayNDims() > 0)
8795       {
8796       /* pointer represents an unsized array bracket */
8797       datatype = add_indirection(datatype, VTK_PARSE_ARRAY);
8798       extra = ((extra >> 2) & VTK_PARSE_POINTER_MASK);
8799       }
8800
8801     datatype = add_indirection(datatype, extra);
8802     }
8803
8804   if (getArrayNDims() == 1)
8805     {
8806     if ((datatype & VTK_PARSE_POINTER_LOWMASK) != VTK_PARSE_ARRAY)
8807       {
8808       /* turn the first set of brackets into a pointer */
8809       datatype = add_indirection(datatype, VTK_PARSE_POINTER);
8810       }
8811     else
8812       {
8813       pushArrayFront("");
8814       }
8815     }
8816   else if (getArrayNDims() > 1)
8817     {
8818     if ((datatype & VTK_PARSE_POINTER_LOWMASK) != VTK_PARSE_ARRAY)
8819       {
8820       /* turn the first set of brackets into a pointer */
8821       datatype = add_indirection(datatype, VTK_PARSE_ARRAY);
8822       }
8823     else
8824       {
8825       pushArrayFront("");
8826       }
8827     }
8828
8829   /* get the data type */
8830   val->Type = datatype;
8831   val->Class = type_class(datatype, getTypeId());
8832
8833   /* copy contents of all brackets to the ArgDimensions */
8834   val->NumberOfDimensions = getArrayNDims();
8835   val->Dimensions = getArray();
8836   clearArray();
8837
8838   /* count is the product of the dimensions */
8839   val->Count = count_from_dimensions(val);
8840 }
8841
8842 /* add a parameter to the legacy part of the FunctionInfo struct */
8843 void add_legacy_parameter(FunctionInfo *func, ValueInfo *param)
8844 {
8845 #ifndef VTK_PARSE_LEGACY_REMOVE
8846   int i = func->NumberOfArguments;
8847
8848   if (i < MAX_ARGS)
8849     {
8850     func->NumberOfArguments = i + 1;
8851     func->ArgTypes[i] = param->Type;
8852     func->ArgClasses[i] = param->Class;
8853     func->ArgCounts[i] = param->Count;
8854
8855     /* legacy wrappers need VTK_PARSE_FUNCTION without POINTER */
8856     if (param->Type == VTK_PARSE_FUNCTION_PTR)
8857       {
8858       /* check for signature "void (*func)(void *)" */
8859       if (param->Function->NumberOfParameters == 1 &&
8860           param->Function->Parameters[0]->Type == VTK_PARSE_VOID_PTR &&
8861           param->Function->Parameters[0]->NumberOfDimensions == 0 &&
8862           param->Function->ReturnValue->Type == VTK_PARSE_VOID)
8863         {
8864         func->ArgTypes[i] = VTK_PARSE_FUNCTION;
8865         }
8866       }
8867     }
8868   else
8869     {
8870     func->ArrayFailure = 1;
8871     }
8872 #endif
8873 }
8874
8875
8876 /* reject the function, do not output it */
8877 void reject_function()
8878 {
8879   vtkParse_InitFunction(currentFunction);
8880   startSig();
8881   getMacro();
8882 }
8883
8884 /* a simple routine that updates a few variables */
8885 void output_function()
8886 {
8887   const char *macro = getMacro();
8888   size_t n;
8889   int i, j;
8890   int match;
8891
8892   /* reject template specializations */
8893   n = strlen(currentFunction->Name);
8894   if (currentFunction->Name[n-1] == '>')
8895     {
8896     /* make sure there is a matching angle bracket */
8897     while (n > 0 && currentFunction->Name[n-1] != '<') { n--; }
8898     if (n > 0)
8899       {
8900       reject_function();
8901       return;
8902       }
8903     }
8904
8905   /* static */
8906   if (currentFunction->ReturnValue &&
8907       currentFunction->ReturnValue->Type & VTK_PARSE_STATIC)
8908     {
8909     currentFunction->IsStatic = 1;
8910     }
8911
8912   /* virtual */
8913   if (currentFunction->ReturnValue &&
8914       currentFunction->ReturnValue->Type & VTK_PARSE_VIRTUAL)
8915     {
8916     currentFunction->IsVirtual = 1;
8917     }
8918
8919   /* the signature */
8920   if (!currentFunction->Signature)
8921     {
8922     currentFunction->Signature = getSig();
8923     }
8924
8925   /* template information */
8926   if (currentTemplate)
8927     {
8928     currentFunction->Template = currentTemplate;
8929     currentTemplate = NULL;
8930     }
8931
8932   /* a void argument is the same as no parameters */
8933   if (currentFunction->NumberOfParameters == 1 &&
8934       (currentFunction->Parameters[0]->Type & VTK_PARSE_UNQUALIFIED_TYPE) ==
8935       VTK_PARSE_VOID)
8936     {
8937     currentFunction->NumberOfParameters = 0;
8938     }
8939
8940   /* is it defined in a legacy macro? */
8941   if (macro && strcmp(macro, "VTK_LEGACY") == 0)
8942     {
8943     currentFunction->IsLegacy = 1;
8944     }
8945
8946   /* set public, protected */
8947   if (currentClass)
8948     {
8949     currentFunction->Access = access_level;
8950     }
8951   else
8952     {
8953     currentFunction->Access = VTK_ACCESS_PUBLIC;
8954     }
8955
8956 #ifndef VTK_PARSE_LEGACY_REMOVE
8957   /* a void argument is the same as no parameters */
8958   if (currentFunction->NumberOfArguments == 1 &&
8959       (currentFunction->ArgTypes[0] & VTK_PARSE_UNQUALIFIED_TYPE) ==
8960       VTK_PARSE_VOID)
8961     {
8962     currentFunction->NumberOfArguments = 0;
8963     }
8964
8965   /* if return type is void, set return class to void */
8966   if (currentFunction->ReturnClass == NULL &&
8967       (currentFunction->ReturnType & VTK_PARSE_UNQUALIFIED_TYPE) ==
8968        VTK_PARSE_VOID)
8969     {
8970     currentFunction->ReturnClass = "void";
8971     }
8972
8973   /* set legacy flags */
8974   if (currentClass)
8975     {
8976     currentFunction->IsPublic = (access_level == VTK_ACCESS_PUBLIC);
8977     currentFunction->IsProtected = (access_level == VTK_ACCESS_PROTECTED);
8978     }
8979   else
8980     {
8981     currentFunction->IsPublic = 1;
8982     currentFunction->IsProtected = 0;
8983     }
8984
8985   /* check for too many parameters */
8986   if (currentFunction->NumberOfParameters > MAX_ARGS)
8987     {
8988     currentFunction->ArrayFailure = 1;
8989     }
8990
8991   for (i = 0; i < currentFunction->NumberOfParameters; i++)
8992     {
8993     ValueInfo *param = currentFunction->Parameters[i];
8994     /* tell old wrappers that multi-dimensional arrays are bad */
8995     if ((param->Type & VTK_PARSE_POINTER_MASK) != 0)
8996       {
8997       if (((param->Type & VTK_PARSE_INDIRECT) == VTK_PARSE_BAD_INDIRECT) ||
8998           ((param->Type & VTK_PARSE_POINTER_LOWMASK) != VTK_PARSE_POINTER))
8999         {
9000         currentFunction->ArrayFailure = 1;
9001         }
9002       }
9003
9004     /* allow only "void (*func)(void *)" as a valid function pointer */
9005     if ((param->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION)
9006       {
9007       if (i != 0 || param->Type != VTK_PARSE_FUNCTION_PTR ||
9008           currentFunction->NumberOfParameters != 2 ||
9009           currentFunction->Parameters[1]->Type != VTK_PARSE_VOID_PTR ||
9010           param->Function->NumberOfParameters != 1 ||
9011           param->Function->Parameters[0]->Type != VTK_PARSE_VOID_PTR ||
9012           param->Function->Parameters[0]->NumberOfDimensions != 0 ||
9013           param->Function->ReturnValue->Type != VTK_PARSE_VOID)
9014         {
9015         currentFunction->ArrayFailure = 1;
9016         }
9017       }
9018     }
9019 #endif /* VTK_PARSE_LEGACY_REMOVE */
9020
9021   if (currentClass)
9022     {
9023     /* is it a delete function */
9024     if (currentFunction->Name && !strcmp("Delete",currentFunction->Name))
9025       {
9026       currentClass->HasDelete = 1;
9027       }
9028
9029     currentFunction->Class = currentClass->Name;
9030     vtkParse_AddFunctionToClass(currentClass, currentFunction);
9031
9032     currentFunction = (FunctionInfo *)malloc(sizeof(FunctionInfo));
9033     }
9034   else
9035     {
9036     /* make sure this function isn't a repeat */
9037     match = 0;
9038     for (i = 0; i < currentNamespace->NumberOfFunctions; i++)
9039       {
9040       if (currentNamespace->Functions[i]->Name &&
9041           strcmp(currentNamespace->Functions[i]->Name,
9042                  currentFunction->Name) == 0)
9043         {
9044         if (currentNamespace->Functions[i]->NumberOfParameters ==
9045             currentFunction->NumberOfParameters)
9046           {
9047           for (j = 0; j < currentFunction->NumberOfParameters; j++)
9048             {
9049             if (currentNamespace->Functions[i]->Parameters[j]->Type ==
9050                 currentFunction->Parameters[j]->Type)
9051               {
9052               if (currentFunction->Parameters[j]->Type == VTK_PARSE_OBJECT &&
9053                   strcmp(currentNamespace->Functions[i]->Parameters[j]->Class,
9054                          currentFunction->Parameters[j]->Class) == 0)
9055                 {
9056                 break;
9057                 }
9058               }
9059             }
9060           if (j == currentFunction->NumberOfParameters)
9061             {
9062             match = 1;
9063             break;
9064             }
9065           }
9066         }
9067       }
9068
9069     if (!match)
9070       {
9071       vtkParse_AddFunctionToNamespace(currentNamespace, currentFunction);
9072
9073       currentFunction = (FunctionInfo *)malloc(sizeof(FunctionInfo));
9074       }
9075     }
9076
9077   vtkParse_InitFunction(currentFunction);
9078   startSig();
9079 }
9080
9081 /* output a function that is not a method of the current class */
9082 void output_friend_function()
9083 {
9084   ClassInfo *tmpc = currentClass;
9085   currentClass = NULL;
9086   output_function();
9087   currentClass = tmpc;
9088 }
9089
9090 void outputSetVectorMacro(const char *var, unsigned int paramType,
9091                           const char *typeText, int n)
9092 {
9093   static const char *mnames[] = {
9094     NULL, NULL,
9095     "vtkSetVector2Macro", "vtkSetVector3Macro", "vtkSetVector4Macro",
9096     NULL,
9097     "vtkSetVector6Macro",
9098     NULL };
9099   char ntext[32];
9100   int i, m;
9101   m = (n > 7 ? 0 : n);
9102
9103   sprintf(ntext, "%i", n);
9104
9105   currentFunction->Macro = mnames[m];
9106   currentFunction->Name = vtkstrcat("Set", var);
9107   startSig();
9108   postSig("void ");
9109   postSig(currentFunction->Name);
9110   postSig("(");
9111   postSig(typeText);
9112   for (i = 1; i < n; i++)
9113     {
9114     postSig(", ");
9115     postSig(typeText);
9116     }
9117   postSig(");");
9118   for (i = 0; i < n; i++)
9119     {
9120     add_parameter(currentFunction, paramType, getTypeId(), 0);
9121     }
9122   set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
9123   output_function();
9124
9125   currentFunction->Macro = mnames[m];
9126   currentFunction->Name = vtkstrcat("Set", var);
9127   currentFunction->Signature =
9128     vtkstrcat7("void ", currentFunction->Name, "(", typeText,
9129                " a[", ntext, "]);");
9130   add_parameter(currentFunction, (VTK_PARSE_POINTER | paramType),
9131                 getTypeId(), n);
9132   set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
9133   output_function();
9134 }
9135
9136 void outputGetVectorMacro(const char *var, unsigned int paramType,
9137                           const char *typeText, int n)
9138 {
9139   static const char *mnames[] = {
9140     NULL, NULL,
9141     "vtkGetVector2Macro", "vtkGetVector3Macro", "vtkGetVector4Macro",
9142     NULL,
9143     "vtkGetVector6Macro",
9144     NULL };
9145   int m;
9146   m = (n > 7 ? 0 : n);
9147
9148   currentFunction->Macro = mnames[m];
9149   currentFunction->Name = vtkstrcat("Get", var);
9150   currentFunction->Signature =
9151     vtkstrcat4(typeText, " *", currentFunction->Name, "();");
9152   set_return(currentFunction, (VTK_PARSE_POINTER | paramType), getTypeId(), n);
9153   output_function();
9154 }
9155
9156 /* Set a flag to ignore BTX/ETX markers in the files */
9157 void vtkParse_SetIgnoreBTX(int option)
9158 {
9159   if (option)
9160     {
9161     IgnoreBTX = 1;
9162     }
9163   else
9164     {
9165     IgnoreBTX = 0;
9166     }
9167 }
9168
9169 /* Set a flag to recurse into included files */
9170 void vtkParse_SetRecursive(int option)
9171 {
9172   if (option)
9173     {
9174     Recursive = 1;
9175     }
9176   else
9177     {
9178     Recursive = 0;
9179     }
9180 }
9181
9182 /* Parse a header file and return a FileInfo struct */
9183 FileInfo *vtkParse_ParseFile(
9184   const char *filename, FILE *ifile, FILE *errfile)
9185 {
9186   int i, j;
9187   int ret;
9188   FileInfo *file_info;
9189   char *main_class;
9190
9191   /* "data" is a global variable used by the parser */
9192   data = (FileInfo *)malloc(sizeof(FileInfo));
9193   vtkParse_InitFile(data);
9194   data->Strings = (StringCache *)malloc(sizeof(StringCache));
9195   vtkParse_InitStringCache(data->Strings);
9196
9197   /* "preprocessor" is a global struct used by the parser */
9198   preprocessor = (PreprocessInfo *)malloc(sizeof(PreprocessInfo));
9199   vtkParsePreprocess_Init(preprocessor, filename);
9200   vtkParsePreprocess_AddStandardMacros(preprocessor, VTK_PARSE_NATIVE);
9201
9202   /* add include files specified on the command line */
9203   for (i = 0; i < NumberOfIncludeDirectories; i++)
9204     {
9205     vtkParsePreprocess_IncludeDirectory(preprocessor, IncludeDirectories[i]);
9206     }
9207
9208   /* add macros specified on the command line */
9209   for (i = 0; i < NumberOfDefinitions; i++)
9210     {
9211     const char *cp = Definitions[i];
9212
9213     if (*cp == 'U')
9214       {
9215       vtkParsePreprocess_RemoveMacro(preprocessor, &cp[1]);
9216       }
9217     else if (*cp == 'D')
9218       {
9219       const char *definition = &cp[1];
9220       while (*definition != '=' && *definition != '\0')
9221         {
9222         definition++;
9223         }
9224       if (*definition == '=')
9225         {
9226         definition++;
9227         }
9228       else
9229         {
9230         definition = NULL;
9231         }
9232       vtkParsePreprocess_AddMacro(preprocessor, &cp[1], definition);
9233       }
9234     }
9235
9236   /* should explicitly check for vtkConfigure.h, or even explicitly load it */
9237 #ifdef VTK_USE_64BIT_IDS
9238   vtkParsePreprocess_AddMacro(preprocessor, "VTK_USE_64BIT_IDS", NULL);
9239 #endif
9240
9241   data->FileName = vtkstrdup(filename);
9242
9243   clearComment();
9244
9245   namespaceDepth = 0;
9246   currentNamespace = (NamespaceInfo *)malloc(sizeof(NamespaceInfo));
9247   vtkParse_InitNamespace(currentNamespace);
9248   data->Contents = currentNamespace;
9249
9250   templateDepth = 0;
9251   currentTemplate = NULL;
9252
9253   currentFunction = (FunctionInfo *)malloc(sizeof(FunctionInfo));
9254   vtkParse_InitFunction(currentFunction);
9255   startSig();
9256
9257   parseDebug = 0;
9258   if (getenv("DEBUG") != NULL)
9259     {
9260     parseDebug = 1;
9261     }
9262
9263   yyset_in(ifile);
9264   yyset_out(errfile);
9265   ret = yyparse();
9266
9267   if (ret)
9268     {
9269     print_parser_error("syntax error", NULL, 0);
9270     return NULL;
9271     }
9272
9273   free(currentFunction);
9274   yylex_destroy();
9275
9276   /* The main class name should match the file name */
9277   i = strlen(filename);
9278   j = i;
9279   while (i > 0)
9280     {
9281     --i;
9282     if (filename[i] == '.')
9283       {
9284       j = i;
9285       }
9286     if (filename[i] == '/' || filename[i] == '\\')
9287       {
9288       i++;
9289       break;
9290       }
9291     }
9292   main_class = (char *)malloc(j-i+1);
9293   strncpy(main_class, &filename[i], j-i);
9294   main_class[j-i] = '\0';
9295
9296   /* special treatment of the main class in the file */
9297   for (i = 0; i < currentNamespace->NumberOfClasses; i++)
9298     {
9299     if (strcmp(currentNamespace->Classes[i]->Name, main_class) == 0)
9300       {
9301       data->MainClass = currentNamespace->Classes[i];
9302       break;
9303       }
9304     }
9305   free(main_class);
9306
9307   vtkParsePreprocess_Free(preprocessor);
9308   preprocessor = NULL;
9309   macroName = NULL;
9310
9311   file_info = data;
9312   data = NULL;
9313
9314   return file_info;
9315 }
9316
9317 /* Read a hints file and update the FileInfo */
9318 int vtkParse_ReadHints(FileInfo *file_info, FILE *hfile, FILE *errfile)
9319 {
9320   char h_cls[512];
9321   char h_func[512];
9322   unsigned int h_type, type;
9323   int h_value;
9324   FunctionInfo *func_info;
9325   ClassInfo *class_info;
9326   NamespaceInfo *contents;
9327   int i, j;
9328   int lineno = 0;
9329   int n;
9330
9331   contents = file_info->Contents;
9332
9333   /* read each hint line in succession */
9334   while ((n = fscanf(hfile,"%s %s %x %i", h_cls, h_func, &h_type, &h_value))
9335          != EOF)
9336     {
9337     lineno++;
9338     if (n < 4)
9339       {
9340       fprintf(errfile, "Wrapping: error parsing hints file line %i\n", lineno);
9341       exit(1);
9342       }
9343
9344     /* erase "ref" and qualifiers from hint type */
9345     type = ((h_type & VTK_PARSE_BASE_TYPE) |
9346             (h_type & VTK_PARSE_POINTER_LOWMASK));
9347
9348     /* find the matching class */
9349     for (i = 0; i < contents->NumberOfClasses; i++)
9350       {
9351       class_info = contents->Classes[i];
9352
9353       if (strcmp(h_cls, class_info->Name) == 0)
9354         {
9355         /* find the matching function */
9356         for (j = 0; j < class_info->NumberOfFunctions; j++)
9357           {
9358           func_info = class_info->Functions[j];
9359
9360           if ((strcmp(h_func, func_info->Name) == 0) &&
9361               func_info->ReturnValue &&
9362               (type == ((func_info->ReturnValue->Type & ~VTK_PARSE_REF) &
9363                         VTK_PARSE_UNQUALIFIED_TYPE)))
9364             {
9365             /* types that hints are accepted for */
9366             switch (func_info->ReturnValue->Type & VTK_PARSE_UNQUALIFIED_TYPE)
9367               {
9368               case VTK_PARSE_FLOAT_PTR:
9369               case VTK_PARSE_VOID_PTR:
9370               case VTK_PARSE_DOUBLE_PTR:
9371               case VTK_PARSE_ID_TYPE_PTR:
9372               case VTK_PARSE_LONG_LONG_PTR:
9373               case VTK_PARSE_UNSIGNED_LONG_LONG_PTR:
9374               case VTK_PARSE___INT64_PTR:
9375               case VTK_PARSE_UNSIGNED___INT64_PTR:
9376               case VTK_PARSE_INT_PTR:
9377               case VTK_PARSE_UNSIGNED_INT_PTR:
9378               case VTK_PARSE_SHORT_PTR:
9379               case VTK_PARSE_UNSIGNED_SHORT_PTR:
9380               case VTK_PARSE_LONG_PTR:
9381               case VTK_PARSE_UNSIGNED_LONG_PTR:
9382               case VTK_PARSE_SIGNED_CHAR_PTR:
9383               case VTK_PARSE_UNSIGNED_CHAR_PTR:
9384               case VTK_PARSE_CHAR_PTR:
9385                 {
9386                 if (func_info->ReturnValue->NumberOfDimensions == 0)
9387                   {
9388                   char text[64];
9389                   sprintf(text, "%i", h_value);
9390                   func_info->ReturnValue->Count = h_value;
9391                   vtkParse_AddStringToArray(
9392                     &func_info->ReturnValue->Dimensions,
9393                     &func_info->ReturnValue->NumberOfDimensions,
9394                     vtkParse_CacheString(
9395                       file_info->Strings, text, strlen(text)));
9396 #ifndef VTK_PARSE_LEGACY_REMOVE
9397                   func_info->HaveHint = 1;
9398                   func_info->HintSize = h_value;
9399 #endif
9400                   }
9401                 break;
9402                 }
9403               default:
9404                 {
9405                 fprintf(errfile,
9406                         "Wrapping: unhandled hint type %#x\n", h_type);
9407                 }
9408               }
9409             }
9410           }
9411         }
9412       }
9413     }
9414
9415   return 1;
9416 }
9417
9418 /* Free the FileInfo struct returned by vtkParse_ParseFile() */
9419 void vtkParse_Free(FileInfo *file_info)
9420 {
9421   vtkParse_FreeFile(file_info);
9422   vtkParse_FreeStringCache(file_info->Strings);
9423   free(file_info->Strings);
9424   free(file_info);
9425 }
9426
9427 /** Define a preprocessor macro. Function macros are not supported.  */
9428 void vtkParse_DefineMacro(const char *name, const char *definition)
9429 {
9430   size_t n = vtkidlen(name);
9431   size_t l;
9432   char *cp;
9433
9434   if (definition == NULL)
9435     {
9436     definition = "";
9437     }
9438
9439   l = n + strlen(definition) + 3;
9440   cp = (char *)malloc(l);
9441   cp[0] = 'D';
9442   strncpy(&cp[1], name, n);
9443   cp[n+1] = '\0';
9444   if (definition[0] != '\0')
9445     {
9446     cp[n+1] = '=';
9447     strcpy(&cp[n+2], definition);
9448     }
9449   cp[l] = '\0';
9450
9451   vtkParse_AddStringToArray(&Definitions, &NumberOfDefinitions, cp);
9452 }
9453
9454 /** Undefine a preprocessor macro.  */
9455 void vtkParse_UndefineMacro(const char *name)
9456 {
9457   size_t n = vtkidlen(name);
9458   char *cp;
9459
9460   cp = (char *)malloc(n+2);
9461   cp[0] = 'U';
9462   strncpy(&cp[1], name, n);
9463   cp[n+1] = '\0';
9464
9465   vtkParse_AddStringToArray(&Definitions, &NumberOfDefinitions, cp);
9466 }
9467
9468 /** Add an include directory, for use with the "-I" option.  */
9469 void vtkParse_IncludeDirectory(const char *dirname)
9470 {
9471   size_t n = strlen(dirname);
9472   char *cp;
9473   int i;
9474
9475   for (i = 0; i < NumberOfIncludeDirectories; i++)
9476     {
9477     if (strncmp(IncludeDirectories[i], dirname, n) == 0 &&
9478         IncludeDirectories[i][n] == '\0')
9479       {
9480       return;
9481       }
9482     }
9483
9484   cp = (char *)malloc(n+1);
9485   strcpy(cp, dirname);
9486
9487   vtkParse_AddStringToArray(
9488     &IncludeDirectories, &NumberOfIncludeDirectories, cp);
9489 }
9490
9491 /** Return the full path to a header file.  */
9492 const char *vtkParse_FindIncludeFile(const char *filename)
9493 {
9494   static PreprocessInfo info = {0, 0, 0, 0, 0, 0, 0, 0, 0};
9495   int val;
9496   int i;
9497
9498   /* add include files specified on the command line */
9499   for (i = 0; i < NumberOfIncludeDirectories; i++)
9500     {
9501     vtkParsePreprocess_IncludeDirectory(&info, IncludeDirectories[i]);
9502     }
9503
9504   return vtkParsePreprocess_FindIncludeFile(&info, filename, 0, &val);
9505 }