diff --git a/Source/CParse/parser.c b/Source/CParse/parser.c
new file mode 100644
--- /dev/null
+++ b/Source/CParse/parser.c
@@ -0,0 +1,13120 @@
+/* A Bison parser, made by GNU Bison 2.3.  */
+
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.3"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Using locations.  */
+#define YYLSP_NEEDED 0
+
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     END = 0,
+     ID = 258,
+     HBLOCK = 259,
+     POUND = 260,
+     STRING = 261,
+     WSTRING = 262,
+     INCLUDE = 263,
+     IMPORT = 264,
+     INSERT = 265,
+     CHARCONST = 266,
+     WCHARCONST = 267,
+     NUM_INT = 268,
+     NUM_FLOAT = 269,
+     NUM_UNSIGNED = 270,
+     NUM_LONG = 271,
+     NUM_ULONG = 272,
+     NUM_LONGLONG = 273,
+     NUM_ULONGLONG = 274,
+     NUM_BOOL = 275,
+     TYPEDEF = 276,
+     TYPE_INT = 277,
+     TYPE_UNSIGNED = 278,
+     TYPE_SHORT = 279,
+     TYPE_LONG = 280,
+     TYPE_FLOAT = 281,
+     TYPE_DOUBLE = 282,
+     TYPE_CHAR = 283,
+     TYPE_WCHAR = 284,
+     TYPE_VOID = 285,
+     TYPE_SIGNED = 286,
+     TYPE_BOOL = 287,
+     TYPE_COMPLEX = 288,
+     TYPE_TYPEDEF = 289,
+     TYPE_RAW = 290,
+     TYPE_NON_ISO_INT8 = 291,
+     TYPE_NON_ISO_INT16 = 292,
+     TYPE_NON_ISO_INT32 = 293,
+     TYPE_NON_ISO_INT64 = 294,
+     LPAREN = 295,
+     RPAREN = 296,
+     COMMA = 297,
+     SEMI = 298,
+     EXTERN = 299,
+     INIT = 300,
+     LBRACE = 301,
+     RBRACE = 302,
+     PERIOD = 303,
+     ELLIPSIS = 304,
+     CONST_QUAL = 305,
+     VOLATILE = 306,
+     REGISTER = 307,
+     STRUCT = 308,
+     UNION = 309,
+     EQUAL = 310,
+     SIZEOF = 311,
+     MODULE = 312,
+     LBRACKET = 313,
+     RBRACKET = 314,
+     BEGINFILE = 315,
+     ENDOFFILE = 316,
+     ILLEGAL = 317,
+     CONSTANT = 318,
+     NAME = 319,
+     RENAME = 320,
+     NAMEWARN = 321,
+     EXTEND = 322,
+     PRAGMA = 323,
+     FEATURE = 324,
+     VARARGS = 325,
+     ENUM = 326,
+     CLASS = 327,
+     TYPENAME = 328,
+     PRIVATE = 329,
+     PUBLIC = 330,
+     PROTECTED = 331,
+     COLON = 332,
+     STATIC = 333,
+     VIRTUAL = 334,
+     FRIEND = 335,
+     THROW = 336,
+     CATCH = 337,
+     EXPLICIT = 338,
+     STATIC_ASSERT = 339,
+     CONSTEXPR = 340,
+     THREAD_LOCAL = 341,
+     DECLTYPE = 342,
+     AUTO = 343,
+     NOEXCEPT = 344,
+     OVERRIDE = 345,
+     FINAL = 346,
+     USING = 347,
+     NAMESPACE = 348,
+     NATIVE = 349,
+     INLINE = 350,
+     TYPEMAP = 351,
+     EXCEPT = 352,
+     ECHO = 353,
+     APPLY = 354,
+     CLEAR = 355,
+     SWIGTEMPLATE = 356,
+     FRAGMENT = 357,
+     WARN = 358,
+     LESSTHAN = 359,
+     GREATERTHAN = 360,
+     DELETE_KW = 361,
+     DEFAULT = 362,
+     LESSTHANOREQUALTO = 363,
+     GREATERTHANOREQUALTO = 364,
+     EQUALTO = 365,
+     NOTEQUALTO = 366,
+     LESSEQUALGREATER = 367,
+     ARROW = 368,
+     QUESTIONMARK = 369,
+     TYPES = 370,
+     PARMS = 371,
+     NONID = 372,
+     DSTAR = 373,
+     DCNOT = 374,
+     TEMPLATE = 375,
+     OPERATOR = 376,
+     CONVERSIONOPERATOR = 377,
+     PARSETYPE = 378,
+     PARSEPARM = 379,
+     PARSEPARMS = 380,
+     DOXYGENSTRING = 381,
+     DOXYGENPOSTSTRING = 382,
+     CAST = 383,
+     LOR = 384,
+     LAND = 385,
+     OR = 386,
+     XOR = 387,
+     AND = 388,
+     RSHIFT = 389,
+     LSHIFT = 390,
+     MINUS = 391,
+     PLUS = 392,
+     MODULO = 393,
+     SLASH = 394,
+     STAR = 395,
+     LNOT = 396,
+     NOT = 397,
+     UMINUS = 398,
+     DCOLON = 399
+   };
+#endif
+/* Tokens.  */
+#define END 0
+#define ID 258
+#define HBLOCK 259
+#define POUND 260
+#define STRING 261
+#define WSTRING 262
+#define INCLUDE 263
+#define IMPORT 264
+#define INSERT 265
+#define CHARCONST 266
+#define WCHARCONST 267
+#define NUM_INT 268
+#define NUM_FLOAT 269
+#define NUM_UNSIGNED 270
+#define NUM_LONG 271
+#define NUM_ULONG 272
+#define NUM_LONGLONG 273
+#define NUM_ULONGLONG 274
+#define NUM_BOOL 275
+#define TYPEDEF 276
+#define TYPE_INT 277
+#define TYPE_UNSIGNED 278
+#define TYPE_SHORT 279
+#define TYPE_LONG 280
+#define TYPE_FLOAT 281
+#define TYPE_DOUBLE 282
+#define TYPE_CHAR 283
+#define TYPE_WCHAR 284
+#define TYPE_VOID 285
+#define TYPE_SIGNED 286
+#define TYPE_BOOL 287
+#define TYPE_COMPLEX 288
+#define TYPE_TYPEDEF 289
+#define TYPE_RAW 290
+#define TYPE_NON_ISO_INT8 291
+#define TYPE_NON_ISO_INT16 292
+#define TYPE_NON_ISO_INT32 293
+#define TYPE_NON_ISO_INT64 294
+#define LPAREN 295
+#define RPAREN 296
+#define COMMA 297
+#define SEMI 298
+#define EXTERN 299
+#define INIT 300
+#define LBRACE 301
+#define RBRACE 302
+#define PERIOD 303
+#define ELLIPSIS 304
+#define CONST_QUAL 305
+#define VOLATILE 306
+#define REGISTER 307
+#define STRUCT 308
+#define UNION 309
+#define EQUAL 310
+#define SIZEOF 311
+#define MODULE 312
+#define LBRACKET 313
+#define RBRACKET 314
+#define BEGINFILE 315
+#define ENDOFFILE 316
+#define ILLEGAL 317
+#define CONSTANT 318
+#define NAME 319
+#define RENAME 320
+#define NAMEWARN 321
+#define EXTEND 322
+#define PRAGMA 323
+#define FEATURE 324
+#define VARARGS 325
+#define ENUM 326
+#define CLASS 327
+#define TYPENAME 328
+#define PRIVATE 329
+#define PUBLIC 330
+#define PROTECTED 331
+#define COLON 332
+#define STATIC 333
+#define VIRTUAL 334
+#define FRIEND 335
+#define THROW 336
+#define CATCH 337
+#define EXPLICIT 338
+#define STATIC_ASSERT 339
+#define CONSTEXPR 340
+#define THREAD_LOCAL 341
+#define DECLTYPE 342
+#define AUTO 343
+#define NOEXCEPT 344
+#define OVERRIDE 345
+#define FINAL 346
+#define USING 347
+#define NAMESPACE 348
+#define NATIVE 349
+#define INLINE 350
+#define TYPEMAP 351
+#define EXCEPT 352
+#define ECHO 353
+#define APPLY 354
+#define CLEAR 355
+#define SWIGTEMPLATE 356
+#define FRAGMENT 357
+#define WARN 358
+#define LESSTHAN 359
+#define GREATERTHAN 360
+#define DELETE_KW 361
+#define DEFAULT 362
+#define LESSTHANOREQUALTO 363
+#define GREATERTHANOREQUALTO 364
+#define EQUALTO 365
+#define NOTEQUALTO 366
+#define LESSEQUALGREATER 367
+#define ARROW 368
+#define QUESTIONMARK 369
+#define TYPES 370
+#define PARMS 371
+#define NONID 372
+#define DSTAR 373
+#define DCNOT 374
+#define TEMPLATE 375
+#define OPERATOR 376
+#define CONVERSIONOPERATOR 377
+#define PARSETYPE 378
+#define PARSEPARM 379
+#define PARSEPARMS 380
+#define DOXYGENSTRING 381
+#define DOXYGENPOSTSTRING 382
+#define CAST 383
+#define LOR 384
+#define LAND 385
+#define OR 386
+#define XOR 387
+#define AND 388
+#define RSHIFT 389
+#define LSHIFT 390
+#define MINUS 391
+#define PLUS 392
+#define MODULO 393
+#define SLASH 394
+#define STAR 395
+#define LNOT 396
+#define NOT 397
+#define UMINUS 398
+#define DCOLON 399
+
+
+
+
+/* Copy the first part of user declarations.  */
+#line 25 "parser.y"
+
+#define yylex yylex
+
+/* doh.h uses #pragma GCC poison with GCC to prevent direct calls to certain
+ * standard C library functions being introduced, but those cause errors due
+ * to checks like `#if defined YYMALLOC || defined malloc` in the bison
+ * template code.  We can't easily arrange to include headers after that
+ * template code, so instead we disable the problematic poisoning for this
+ * file.
+ */
+#define DOH_NO_POISON_MALLOC_FREE
+
+#include "swig.h"
+#include "cparse.h"
+#include "preprocessor.h"
+#include <ctype.h>
+
+/* We do this for portability */
+#undef alloca
+#define alloca Malloc
+
+#define YYMALLOC Malloc
+#define YYFREE Free
+
+/* -----------------------------------------------------------------------------
+ *                               Externals
+ * ----------------------------------------------------------------------------- */
+
+int  yyparse(void);
+
+/* NEW Variables */
+
+static Node    *top = 0;      /* Top of the generated parse tree */
+static int      unnamed = 0;  /* Unnamed datatype counter */
+static Hash    *classes = 0;        /* Hash table of classes */
+static Hash    *classes_typedefs = 0; /* Hash table of typedef classes: typedef struct X {...} Y; */
+static Symtab  *prev_symtab = 0;
+static Node    *current_class = 0;
+String  *ModuleName = 0;
+static Node    *module_node = 0;
+static String  *Classprefix = 0;  
+static String  *Namespaceprefix = 0;
+static int      inclass = 0;
+static Node    *currentOuterClass = 0; /* for nested classes */
+static const char *last_cpptype = 0;
+static int      inherit_list = 0;
+static Parm    *template_parameters = 0;
+static int      parsing_template_declaration = 0;
+static int      extendmode   = 0;
+static int      compact_default_args = 0;
+static int      template_reduce = 0;
+static int      cparse_externc = 0;
+int		ignore_nested_classes = 0;
+int		kwargs_supported = 0;
+/* -----------------------------------------------------------------------------
+ *                            Doxygen Comment Globals
+ * ----------------------------------------------------------------------------- */
+static String *currentDeclComment = NULL; /* Comment of C/C++ declaration. */
+static Node *previousNode = NULL; /* Pointer to the previous node (for post comments) */
+static Node *currentNode = NULL; /* Pointer to the current node (for post comments) */
+
+/* -----------------------------------------------------------------------------
+ *                            Assist Functions
+ * ----------------------------------------------------------------------------- */
+
+
+ 
+/* Called by the parser (yyparse) when an error is found.*/
+static void yyerror (const char *e) {
+  (void)e;
+}
+
+static Node *new_node(const_String_or_char_ptr tag) {
+  Node *n = Swig_cparse_new_node(tag);
+  /* Remember the previous node in case it will need a post-comment */
+  previousNode = currentNode;
+  currentNode = n;
+  return n;
+}
+
+/* Copies a node.  Does not copy tree links or symbol table data (except for
+   sym:name) */
+
+static Node *copy_node(Node *n) {
+  Node *nn;
+  Iterator k;
+  nn = NewHash();
+  Setfile(nn,Getfile(n));
+  Setline(nn,Getline(n));
+  for (k = First(n); k.key; k = Next(k)) {
+    String *ci;
+    String *key = k.key;
+    char *ckey = Char(key);
+    if ((strcmp(ckey,"nextSibling") == 0) ||
+	(strcmp(ckey,"previousSibling") == 0) ||
+	(strcmp(ckey,"parentNode") == 0) ||
+	(strcmp(ckey,"lastChild") == 0)) {
+      continue;
+    }
+    if (Strncmp(key,"csym:",5) == 0) continue;
+    /* We do copy sym:name.  For templates */
+    if ((strcmp(ckey,"sym:name") == 0) || 
+	(strcmp(ckey,"sym:weak") == 0) ||
+	(strcmp(ckey,"sym:typename") == 0)) {
+      String *ci = Copy(k.item);
+      Setattr(nn,key, ci);
+      Delete(ci);
+      continue;
+    }
+    if (strcmp(ckey,"sym:symtab") == 0) {
+      Setattr(nn,"sym:needs_symtab", "1");
+    }
+    /* We don't copy any other symbol table attributes */
+    if (strncmp(ckey,"sym:",4) == 0) {
+      continue;
+    }
+    /* If children.  We copy them recursively using this function */
+    if (strcmp(ckey,"firstChild") == 0) {
+      /* Copy children */
+      Node *cn = k.item;
+      while (cn) {
+	Node *copy = copy_node(cn);
+	appendChild(nn,copy);
+	Delete(copy);
+	cn = nextSibling(cn);
+      }
+      continue;
+    }
+    /* We don't copy the symbol table.  But we drop an attribute 
+       requires_symtab so that functions know it needs to be built */
+
+    if (strcmp(ckey,"symtab") == 0) {
+      /* Node defined a symbol table. */
+      Setattr(nn,"requires_symtab","1");
+      continue;
+    }
+    /* Can't copy nodes */
+    if (strcmp(ckey,"node") == 0) {
+      continue;
+    }
+    if ((strcmp(ckey,"parms") == 0) || (strcmp(ckey,"pattern") == 0) || (strcmp(ckey,"throws") == 0)
+	|| (strcmp(ckey,"kwargs") == 0)) {
+      ParmList *pl = CopyParmList(k.item);
+      Setattr(nn,key,pl);
+      Delete(pl);
+      continue;
+    }
+    if (strcmp(ckey,"nested:outer") == 0) { /* don't copy outer classes links, they will be updated later */
+      Setattr(nn, key, k.item);
+      continue;
+    }
+    /* defaultargs will be patched back in later in update_defaultargs() */
+    if (strcmp(ckey,"defaultargs") == 0) {
+      Setattr(nn, "needs_defaultargs", "1");
+      continue;
+    }
+    /* same for abstracts, which contains pointers to the source node children, and so will need to be patch too */
+    if (strcmp(ckey,"abstracts") == 0) {
+      SetFlag(nn, "needs_abstracts");
+      continue;
+    }
+    /* Looks okay.  Just copy the data using Copy */
+    ci = Copy(k.item);
+    Setattr(nn, key, ci);
+    Delete(ci);
+  }
+  return nn;
+}
+
+static void set_comment(Node *n, String *comment) {
+  String *name;
+  Parm *p;
+  if (!n || !comment)
+    return;
+
+  if (Getattr(n, "doxygen"))
+    Append(Getattr(n, "doxygen"), comment);
+  else {
+    Setattr(n, "doxygen", comment);
+    /* This is the first comment, populate it with @params, if any */
+    p = Getattr(n, "parms");
+    while (p) {
+      if (Getattr(p, "doxygen"))
+	Printv(comment, "\n@param ", Getattr(p, "name"), Getattr(p, "doxygen"), NIL);
+      p=nextSibling(p);
+    }
+  }
+  
+  /* Append same comment to every generated overload */
+  name = Getattr(n, "name");
+  if (!name)
+    return;
+  n = nextSibling(n);
+  while (n && Getattr(n, "name") && Strcmp(Getattr(n, "name"), name) == 0) {
+    Setattr(n, "doxygen", comment);
+    n = nextSibling(n);
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ *                              Variables
+ * ----------------------------------------------------------------------------- */
+
+static char  *typemap_lang = 0;    /* Current language setting */
+
+static int cplus_mode  = 0;
+
+/* C++ modes */
+
+#define  CPLUS_PUBLIC    1
+#define  CPLUS_PRIVATE   2
+#define  CPLUS_PROTECTED 3
+
+/* include types */
+static int   import_mode = 0;
+
+void SWIG_typemap_lang(const char *tm_lang) {
+  typemap_lang = Swig_copy_string(tm_lang);
+}
+
+void SWIG_cparse_set_compact_default_args(int defargs) {
+  compact_default_args = defargs;
+}
+
+int SWIG_cparse_template_reduce(int treduce) {
+  template_reduce = treduce;
+  return treduce;  
+}
+
+/* -----------------------------------------------------------------------------
+ *                           Assist functions
+ * ----------------------------------------------------------------------------- */
+
+static int promote_type(int t) {
+  if (t <= T_UCHAR || t == T_CHAR || t == T_WCHAR) return T_INT;
+  return t;
+}
+
+/* Perform type-promotion for binary operators */
+static int promote(int t1, int t2) {
+  t1 = promote_type(t1);
+  t2 = promote_type(t2);
+  return t1 > t2 ? t1 : t2;
+}
+
+static String *yyrename = 0;
+
+/* Forward renaming operator */
+
+static String *resolve_create_node_scope(String *cname, int is_class_definition);
+
+
+Hash *Swig_cparse_features(void) {
+  static Hash   *features_hash = 0;
+  if (!features_hash) features_hash = NewHash();
+  return features_hash;
+}
+
+/* Fully qualify any template parameters */
+static String *feature_identifier_fix(String *s) {
+  String *tp = SwigType_istemplate_templateprefix(s);
+  if (tp) {
+    String *ts, *ta, *tq;
+    ts = SwigType_templatesuffix(s);
+    ta = SwigType_templateargs(s);
+    tq = Swig_symbol_type_qualify(ta,0);
+    Append(tp,tq);
+    Append(tp,ts);
+    Delete(ts);
+    Delete(ta);
+    Delete(tq);
+    return tp;
+  } else {
+    return NewString(s);
+  }
+}
+
+static void set_access_mode(Node *n) {
+  if (cplus_mode == CPLUS_PUBLIC)
+    Setattr(n, "access", "public");
+  else if (cplus_mode == CPLUS_PROTECTED)
+    Setattr(n, "access", "protected");
+  else
+    Setattr(n, "access", "private");
+}
+
+static void restore_access_mode(Node *n) {
+  String *mode = Getattr(n, "access");
+  if (Strcmp(mode, "private") == 0)
+    cplus_mode = CPLUS_PRIVATE;
+  else if (Strcmp(mode, "protected") == 0)
+    cplus_mode = CPLUS_PROTECTED;
+  else
+    cplus_mode = CPLUS_PUBLIC;
+}
+
+/* Generate the symbol table name for an object */
+/* This is a bit of a mess. Need to clean up */
+static String *add_oldname = 0;
+
+
+
+static String *make_name(Node *n, String *name,SwigType *decl) {
+  String *made_name = 0;
+  int destructor = name && (*(Char(name)) == '~');
+
+  if (yyrename) {
+    String *s = NewString(yyrename);
+    Delete(yyrename);
+    yyrename = 0;
+    if (destructor  && (*(Char(s)) != '~')) {
+      Insert(s,0,"~");
+    }
+    return s;
+  }
+
+  if (!name) return 0;
+
+  if (parsing_template_declaration)
+    SetFlag(n, "parsing_template_declaration");
+  made_name = Swig_name_make(n, Namespaceprefix, name, decl, add_oldname);
+  Delattr(n, "parsing_template_declaration");
+
+  return made_name;
+}
+
+/* Generate an unnamed identifier */
+static String *make_unnamed(void) {
+  unnamed++;
+  return NewStringf("$unnamed%d$",unnamed);
+}
+
+/* Return if the node is a friend declaration */
+static int is_friend(Node *n) {
+  return Cmp(Getattr(n,"storage"),"friend") == 0;
+}
+
+static int is_operator(String *name) {
+  return Strncmp(name,"operator ", 9) == 0;
+}
+
+
+/* Add declaration list to symbol table */
+static int  add_only_one = 0;
+
+static void add_symbols(Node *n) {
+  String *decl;
+  String *wrn = 0;
+
+  if (inclass && n) {
+    cparse_normalize_void(n);
+  }
+  while (n) {
+    String *symname = 0;
+    /* for friends, we need to pop the scope once */
+    String *old_prefix = 0;
+    Symtab *old_scope = 0;
+    int isfriend = inclass && is_friend(n);
+    int iscdecl = Cmp(nodeType(n),"cdecl") == 0;
+    int only_csymbol = 0;
+    
+    if (inclass) {
+      String *name = Getattr(n, "name");
+      if (isfriend) {
+	/* for friends, we need to add the scopename if needed */
+	String *prefix = name ? Swig_scopename_prefix(name) : 0;
+	old_prefix = Namespaceprefix;
+	old_scope = Swig_symbol_popscope();
+	Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+	if (!prefix) {
+	  if (name && !is_operator(name) && Namespaceprefix) {
+	    String *nname = NewStringf("%s::%s", Namespaceprefix, name);
+	    Setattr(n,"name",nname);
+	    Delete(nname);
+	  }
+	} else {
+	  Symtab *st = Swig_symbol_getscope(prefix);
+	  String *ns = st ? Getattr(st,"name") : prefix;
+	  String *base  = Swig_scopename_last(name);
+	  String *nname = NewStringf("%s::%s", ns, base);
+	  Setattr(n,"name",nname);
+	  Delete(nname);
+	  Delete(base);
+	  Delete(prefix);
+	}
+	Namespaceprefix = 0;
+      } else {
+	/* for member functions, we need to remove the redundant
+	   class scope if provided, as in
+	   
+	   struct Foo {
+	   int Foo::method(int a);
+	   };
+	   
+	*/
+	String *prefix = name ? Swig_scopename_prefix(name) : 0;
+	if (prefix) {
+	  if (Classprefix && (Equal(prefix,Classprefix))) {
+	    String *base = Swig_scopename_last(name);
+	    Setattr(n,"name",base);
+	    Delete(base);
+	  }
+	  Delete(prefix);
+	}
+      }
+    }
+
+    if (!isfriend && (inclass || extendmode)) {
+      Setattr(n,"ismember","1");
+    }
+
+    if (extendmode) {
+      if (!Getattr(n, "template"))
+        SetFlag(n,"isextendmember");
+    }
+
+    if (!isfriend && inclass) {
+      if ((cplus_mode != CPLUS_PUBLIC)) {
+	only_csymbol = 1;
+	if (cplus_mode == CPLUS_PROTECTED) {
+	  Setattr(n,"access", "protected");
+	  only_csymbol = !Swig_need_protected(n);
+	} else {
+	  Setattr(n,"access", "private");
+	  /* private are needed only when they are pure virtuals - why? */
+	  if ((Cmp(Getattr(n,"storage"),"virtual") == 0) && (Cmp(Getattr(n,"value"),"0") == 0)) {
+	    only_csymbol = 0;
+	  }
+	  if (Cmp(nodeType(n),"destructor") == 0) {
+	    /* Needed for "unref" feature */
+	    only_csymbol = 0;
+	  }
+	}
+      } else {
+	  Setattr(n,"access", "public");
+      }
+    }
+    if (Getattr(n,"sym:name")) {
+      n = nextSibling(n);
+      continue;
+    }
+    decl = Getattr(n,"decl");
+    if (!SwigType_isfunction(decl)) {
+      String *name = Getattr(n,"name");
+      String *makename = Getattr(n,"parser:makename");
+      if (iscdecl) {	
+	String *storage = Getattr(n, "storage");
+	if (Cmp(storage,"typedef") == 0) {
+	  Setattr(n,"kind","typedef");
+	} else {
+	  SwigType *type = Getattr(n,"type");
+	  String *value = Getattr(n,"value");
+	  Setattr(n,"kind","variable");
+	  if (value && Len(value)) {
+	    Setattr(n,"hasvalue","1");
+	  }
+	  if (type) {
+	    SwigType *ty;
+	    SwigType *tmp = 0;
+	    if (decl) {
+	      ty = tmp = Copy(type);
+	      SwigType_push(ty,decl);
+	    } else {
+	      ty = type;
+	    }
+	    if (!SwigType_ismutable(ty) || (storage && Strstr(storage, "constexpr"))) {
+	      SetFlag(n,"hasconsttype");
+	      SetFlag(n,"feature:immutable");
+	    }
+	    if (tmp) Delete(tmp);
+	  }
+	  if (!type) {
+	    Printf(stderr,"notype name %s\n", name);
+	  }
+	}
+      }
+      Swig_features_get(Swig_cparse_features(), Namespaceprefix, name, 0, n);
+      if (makename) {
+	symname = make_name(n, makename,0);
+        Delattr(n,"parser:makename"); /* temporary information, don't leave it hanging around */
+      } else {
+        makename = name;
+	symname = make_name(n, makename,0);
+      }
+      
+      if (!symname) {
+	symname = Copy(Getattr(n,"unnamed"));
+      }
+      if (symname) {
+	if (parsing_template_declaration)
+	  SetFlag(n, "parsing_template_declaration");
+	wrn = Swig_name_warning(n, Namespaceprefix, symname,0);
+	Delattr(n, "parsing_template_declaration");
+      }
+    } else {
+      String *name = Getattr(n,"name");
+      SwigType *fdecl = Copy(decl);
+      SwigType *fun = SwigType_pop_function(fdecl);
+      if (iscdecl) {	
+	Setattr(n,"kind","function");
+      }
+      
+      Swig_features_get(Swig_cparse_features(),Namespaceprefix,name,fun,n);
+
+      symname = make_name(n, name,fun);
+      if (parsing_template_declaration)
+	SetFlag(n, "parsing_template_declaration");
+      wrn = Swig_name_warning(n, Namespaceprefix,symname,fun);
+      Delattr(n, "parsing_template_declaration");
+      
+      Delete(fdecl);
+      Delete(fun);
+      
+    }
+    if (!symname) {
+      n = nextSibling(n);
+      continue;
+    }
+    if (cparse_cplusplus) {
+      String *value = Getattr(n, "value");
+      if (value && Strcmp(value, "delete") == 0) {
+	/* C++11 deleted definition / deleted function */
+        SetFlag(n,"deleted");
+        SetFlag(n,"feature:ignore");
+      }
+      if (SwigType_isrvalue_reference(Getattr(n, "refqualifier"))) {
+	/* Ignore rvalue ref-qualifiers by default
+	 * Use Getattr instead of GetFlag to handle explicit ignore and explicit not ignore */
+	if (!(Getattr(n, "feature:ignore") || Strncmp(symname, "$ignore", 7) == 0)) {
+	  SWIG_WARN_NODE_BEGIN(n);
+	  Swig_warning(WARN_TYPE_RVALUE_REF_QUALIFIER_IGNORED, Getfile(n), Getline(n),
+	      "Method with rvalue ref-qualifier %s ignored.\n", Swig_name_decl(n));
+	  SWIG_WARN_NODE_END(n);
+	  SetFlag(n, "feature:ignore");
+	}
+      }
+    }
+    if (only_csymbol || GetFlag(n, "feature:ignore") || Strncmp(symname, "$ignore", 7) == 0) {
+      /* Only add to C symbol table and continue */
+      Swig_symbol_add(0, n);
+      if (!only_csymbol && !GetFlag(n, "feature:ignore")) {
+	/* Print the warning attached to $ignore name, if any */
+        char *c = Char(symname) + 7;
+	if (strlen(c)) {
+	  SWIG_WARN_NODE_BEGIN(n);
+	  Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1);
+	  SWIG_WARN_NODE_END(n);
+	}
+	/* If the symbol was ignored via "rename" and is visible, set also feature:ignore*/
+	SetFlag(n, "feature:ignore");
+      }
+      if (!GetFlag(n, "feature:ignore") && Strcmp(symname,"$ignore") == 0) {
+	/* Add feature:ignore if the symbol was explicitly ignored, regardless of visibility */
+	SetFlag(n, "feature:ignore");
+      }
+    } else {
+      Node *c;
+      if ((wrn) && (Len(wrn))) {
+	String *metaname = symname;
+	if (!Getmeta(metaname,"already_warned")) {
+	  SWIG_WARN_NODE_BEGIN(n);
+	  Swig_warning(0,Getfile(n),Getline(n), "%s\n", wrn);
+	  SWIG_WARN_NODE_END(n);
+	  Setmeta(metaname,"already_warned","1");
+	}
+      }
+      c = Swig_symbol_add(symname,n);
+
+      if (c != n) {
+        /* symbol conflict attempting to add in the new symbol */
+        if (Getattr(n,"sym:weak")) {
+          Setattr(n,"sym:name",symname);
+        } else {
+          String *e = NewStringEmpty();
+          String *en = NewStringEmpty();
+          String *ec = NewStringEmpty();
+          int redefined = Swig_need_redefined_warn(n,c,inclass);
+          if (redefined) {
+            Printf(en,"Identifier '%s' redefined (ignored)",symname);
+            Printf(ec,"previous definition of '%s'",symname);
+          } else {
+            Printf(en,"Redundant redeclaration of '%s'",symname);
+            Printf(ec,"previous declaration of '%s'",symname);
+          }
+          if (Cmp(symname,Getattr(n,"name"))) {
+            Printf(en," (Renamed from '%s')", SwigType_namestr(Getattr(n,"name")));
+          }
+          Printf(en,",");
+          if (Cmp(symname,Getattr(c,"name"))) {
+            Printf(ec," (Renamed from '%s')", SwigType_namestr(Getattr(c,"name")));
+          }
+          Printf(ec,".");
+	  SWIG_WARN_NODE_BEGIN(n);
+          if (redefined) {
+            Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en);
+            Swig_warning(WARN_PARSE_REDEFINED,Getfile(c),Getline(c),"%s\n",ec);
+          } else if (!is_friend(n) && !is_friend(c)) {
+            Swig_warning(WARN_PARSE_REDUNDANT,Getfile(n),Getline(n),"%s\n",en);
+            Swig_warning(WARN_PARSE_REDUNDANT,Getfile(c),Getline(c),"%s\n",ec);
+          }
+	  SWIG_WARN_NODE_END(n);
+          Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(n),Getline(n),en,
+                 Getfile(c),Getline(c),ec);
+          Setattr(n,"error",e);
+	  Delete(e);
+          Delete(en);
+          Delete(ec);
+        }
+      }
+    }
+    /* restore the class scope if needed */
+    if (isfriend) {
+      Swig_symbol_setscope(old_scope);
+      if (old_prefix) {
+	Delete(Namespaceprefix);
+	Namespaceprefix = old_prefix;
+      }
+    }
+    Delete(symname);
+
+    if (add_only_one) return;
+    n = nextSibling(n);
+  }
+}
+
+
+/* add symbols a parse tree node copy */
+
+static void add_symbols_copy(Node *n) {
+  String *name;
+  int    emode = 0;
+  while (n) {
+    char *cnodeType = Char(nodeType(n));
+
+    if (strcmp(cnodeType,"access") == 0) {
+      String *kind = Getattr(n,"kind");
+      if (Strcmp(kind,"public") == 0) {
+	cplus_mode = CPLUS_PUBLIC;
+      } else if (Strcmp(kind,"private") == 0) {
+	cplus_mode = CPLUS_PRIVATE;
+      } else if (Strcmp(kind,"protected") == 0) {
+	cplus_mode = CPLUS_PROTECTED;
+      }
+      n = nextSibling(n);
+      continue;
+    }
+
+    add_oldname = Getattr(n,"sym:name");
+    if ((add_oldname) || (Getattr(n,"sym:needs_symtab"))) {
+      int old_inclass = -1;
+      Node *old_current_class = 0;
+      if (add_oldname) {
+	DohIncref(add_oldname);
+	/*  Disable this, it prevents %rename to work with templates */
+	/* If already renamed, we used that name  */
+	/*
+	if (Strcmp(add_oldname, Getattr(n,"name")) != 0) {
+	  Delete(yyrename);
+	  yyrename = Copy(add_oldname);
+	}
+	*/
+      }
+      Delattr(n,"sym:needs_symtab");
+      Delattr(n,"sym:name");
+
+      add_only_one = 1;
+      add_symbols(n);
+
+      if (Getattr(n,"partialargs")) {
+	Swig_symbol_cadd(Getattr(n,"partialargs"),n);
+      }
+      add_only_one = 0;
+      name = Getattr(n,"name");
+      if (Getattr(n,"requires_symtab")) {
+	Swig_symbol_newscope();
+	Swig_symbol_setscopename(name);
+	Delete(Namespaceprefix);
+	Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+      }
+      if (strcmp(cnodeType,"class") == 0) {
+	old_inclass = inclass;
+	inclass = 1;
+	old_current_class = current_class;
+	current_class = n;
+	if (Strcmp(Getattr(n,"kind"),"class") == 0) {
+	  cplus_mode = CPLUS_PRIVATE;
+	} else {
+	  cplus_mode = CPLUS_PUBLIC;
+	}
+      }
+      if (strcmp(cnodeType,"extend") == 0) {
+	emode = cplus_mode;
+	cplus_mode = CPLUS_PUBLIC;
+      }
+      add_symbols_copy(firstChild(n));
+      if (strcmp(cnodeType,"extend") == 0) {
+	cplus_mode = emode;
+      }
+      if (Getattr(n,"requires_symtab")) {
+	Setattr(n,"symtab", Swig_symbol_popscope());
+	Delattr(n,"requires_symtab");
+	Delete(Namespaceprefix);
+	Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+      }
+      if (add_oldname) {
+	Delete(add_oldname);
+	add_oldname = 0;
+      }
+      if (strcmp(cnodeType,"class") == 0) {
+	inclass = old_inclass;
+	current_class = old_current_class;
+      }
+    } else {
+      if (strcmp(cnodeType,"extend") == 0) {
+	emode = cplus_mode;
+	cplus_mode = CPLUS_PUBLIC;
+      }
+      add_symbols_copy(firstChild(n));
+      if (strcmp(cnodeType,"extend") == 0) {
+	cplus_mode = emode;
+      }
+    }
+    n = nextSibling(n);
+  }
+}
+
+/* Add in the "defaultargs" attribute for functions in instantiated templates.
+ * n should be any instantiated template (class or start of linked list of functions). */
+static void update_defaultargs(Node *n) {
+  if (n) {
+    Node *firstdefaultargs = n;
+    update_defaultargs(firstChild(n));
+    n = nextSibling(n);
+    /* recursively loop through nodes of all types, but all we really need are the overloaded functions */
+    while (n) {
+      update_defaultargs(firstChild(n));
+      if (!Getattr(n, "defaultargs")) {
+	if (Getattr(n, "needs_defaultargs")) {
+	  Setattr(n, "defaultargs", firstdefaultargs);
+	  Delattr(n, "needs_defaultargs");
+	} else {
+	  firstdefaultargs = n;
+	}
+      } else {
+	/* Functions added in with %extend (for specialized template classes) will already have default args patched up */
+	assert(Getattr(n, "defaultargs") == firstdefaultargs);
+      }
+      n = nextSibling(n);
+    }
+  }
+}
+
+/* Check a set of declarations to see if any are pure-abstract */
+
+static List *pure_abstracts(Node *n) {
+  List *abstracts = 0;
+  while (n) {
+    if (Cmp(nodeType(n),"cdecl") == 0) {
+      String *decl = Getattr(n,"decl");
+      if (SwigType_isfunction(decl)) {
+	String *init = Getattr(n,"value");
+	if (Cmp(init,"0") == 0) {
+	  if (!abstracts) {
+	    abstracts = NewList();
+	  }
+	  Append(abstracts,n);
+	  SetFlag(n,"abstract");
+	}
+      }
+    } else if (Cmp(nodeType(n),"destructor") == 0) {
+      if (Cmp(Getattr(n,"value"),"0") == 0) {
+	if (!abstracts) {
+	  abstracts = NewList();
+	}
+	Append(abstracts,n);
+	SetFlag(n,"abstract");
+      }
+    }
+    n = nextSibling(n);
+  }
+  return abstracts;
+}
+
+/* Recompute the "abstracts" attribute for the classes in instantiated templates, similarly to update_defaultargs() above. */
+static void update_abstracts(Node *n) {
+  for (; n; n = nextSibling(n)) {
+    Node* const child = firstChild(n);
+    if (!child)
+      continue;
+
+    update_abstracts(child);
+
+    if (Getattr(n, "needs_abstracts")) {
+      Setattr(n, "abstracts", pure_abstracts(child));
+      Delattr(n, "needs_abstracts");
+    }
+  }
+}
+
+/* Make a classname */
+
+static String *make_class_name(String *name) {
+  String *nname = 0;
+  String *prefix;
+  if (Namespaceprefix) {
+    nname= NewStringf("%s::%s", Namespaceprefix, name);
+  } else {
+    nname = NewString(name);
+  }
+  prefix = SwigType_istemplate_templateprefix(nname);
+  if (prefix) {
+    String *args, *qargs;
+    args   = SwigType_templateargs(nname);
+    qargs  = Swig_symbol_type_qualify(args,0);
+    Append(prefix,qargs);
+    Delete(nname);
+    Delete(args);
+    Delete(qargs);
+    nname = prefix;
+  }
+  return nname;
+}
+
+/* Use typedef name as class name */
+
+static void add_typedef_name(Node *n, Node *declnode, String *oldName, Symtab *cscope, String *scpname) {
+  String *class_rename = 0;
+  SwigType *decl = Getattr(declnode, "decl");
+  if (!decl || !Len(decl)) {
+    String *cname;
+    String *tdscopename;
+    String *class_scope = Swig_symbol_qualifiedscopename(cscope);
+    String *name = Getattr(declnode, "name");
+    cname = Copy(name);
+    Setattr(n, "tdname", cname);
+    tdscopename = class_scope ? NewStringf("%s::%s", class_scope, name) : Copy(name);
+    class_rename = Getattr(n, "class_rename");
+    if (class_rename && (Strcmp(class_rename, oldName) == 0))
+      Setattr(n, "class_rename", NewString(name));
+    if (!classes_typedefs) classes_typedefs = NewHash();
+    if (!Equal(scpname, tdscopename) && !Getattr(classes_typedefs, tdscopename)) {
+      Setattr(classes_typedefs, tdscopename, n);
+    }
+    Setattr(n, "decl", decl);
+    Delete(class_scope);
+    Delete(cname);
+    Delete(tdscopename);
+  }
+}
+
+/* If the class name is qualified.  We need to create or lookup namespace entries */
+
+static Symtab *set_scope_to_global(void) {
+  Symtab *symtab = Swig_symbol_global_scope();
+  Swig_symbol_setscope(symtab);
+  return symtab;
+}
+ 
+/* Remove the block braces, { and }, if the 'noblock' attribute is set.
+ * Node *kw can be either a Hash or Parmlist. */
+static String *remove_block(Node *kw, const String *inputcode) {
+  String *modified_code = 0;
+  while (kw) {
+   String *name = Getattr(kw,"name");
+   if (name && (Cmp(name,"noblock") == 0)) {
+     char *cstr = Char(inputcode);
+     int len = Len(inputcode);
+     if (len && cstr[0] == '{') {
+       --len; ++cstr; 
+       if (len && cstr[len - 1] == '}') { --len; }
+       /* we now remove the extra spaces */
+       while (len && isspace((int)cstr[0])) { --len; ++cstr; }
+       while (len && isspace((int)cstr[len - 1])) { --len; }
+       modified_code = NewStringWithSize(cstr, len);
+       break;
+     }
+   }
+   kw = nextSibling(kw);
+  }
+  return modified_code;
+}
+
+/*
+#define RESOLVE_DEBUG 1
+*/
+static Node *nscope = 0;
+static Node *nscope_inner = 0;
+
+/* Remove the scope prefix from cname and return the base name without the prefix.
+ * The scopes required for the symbol name are resolved and/or created, if required.
+ * For example AA::BB::CC as input returns CC and creates the namespace AA then inner 
+ * namespace BB in the current scope. */
+static String *resolve_create_node_scope(String *cname, int is_class_definition) {
+  Symtab *gscope = 0;
+  Node *cname_node = 0;
+  String *last = Swig_scopename_last(cname);
+  nscope = 0;
+  nscope_inner = 0;  
+
+  if (Strncmp(cname,"::" ,2) != 0) {
+    if (is_class_definition) {
+      /* Only lookup symbols which are in scope via a using declaration but not via a using directive.
+         For example find y via 'using x::y' but not y via a 'using namespace x'. */
+      cname_node = Swig_symbol_clookup_no_inherit(cname, 0);
+      if (!cname_node) {
+	Node *full_lookup_node = Swig_symbol_clookup(cname, 0);
+	if (full_lookup_node) {
+	 /* This finds a symbol brought into scope via both a using directive and a using declaration. */
+	  Node *last_node = Swig_symbol_clookup_no_inherit(last, 0);
+	  if (last_node == full_lookup_node)
+	    cname_node = last_node;
+	}
+      }
+    } else {
+      /* For %template, the template needs to be in scope via any means. */
+      cname_node = Swig_symbol_clookup(cname, 0);
+    }
+  }
+#if RESOLVE_DEBUG
+  if (!cname_node)
+    Printf(stdout, "symbol does not yet exist (%d): [%s]\n", is_class_definition, cname);
+  else
+    Printf(stdout, "symbol does exist (%d): [%s]\n", is_class_definition, cname);
+#endif
+
+  if (cname_node) {
+    /* The symbol has been defined already or is in another scope.
+       If it is a weak symbol, it needs replacing and if it was brought into the current scope,
+       the scope needs adjusting appropriately for the new symbol.
+       Similarly for defined templates. */
+    Symtab *symtab = Getattr(cname_node, "sym:symtab");
+    Node *sym_weak = Getattr(cname_node, "sym:weak");
+    if ((symtab && sym_weak) || Equal(nodeType(cname_node), "template")) {
+      /* Check if the scope is the current scope */
+      String *current_scopename = Swig_symbol_qualifiedscopename(0);
+      String *found_scopename = Swig_symbol_qualifiedscopename(symtab);
+      if (!current_scopename)
+	current_scopename = NewString("");
+      if (!found_scopename)
+	found_scopename = NewString("");
+
+      {
+	int fail = 1;
+	List *current_scopes = Swig_scopename_tolist(current_scopename);
+	List *found_scopes = Swig_scopename_tolist(found_scopename);
+        Iterator cit = First(current_scopes);
+	Iterator fit = First(found_scopes);
+#if RESOLVE_DEBUG
+Printf(stdout, "comparing current: [%s] found: [%s]\n", current_scopename, found_scopename);
+#endif
+	for (; fit.item && cit.item; fit = Next(fit), cit = Next(cit)) {
+	  String *current = cit.item;
+	  String *found = fit.item;
+#if RESOLVE_DEBUG
+	  Printf(stdout, "  looping %s %s\n", current, found);
+#endif
+	  if (Strcmp(current, found) != 0)
+	    break;
+	}
+
+	if (!cit.item) {
+	  String *subscope = NewString("");
+	  for (; fit.item; fit = Next(fit)) {
+	    if (Len(subscope) > 0)
+	      Append(subscope, "::");
+	    Append(subscope, fit.item);
+	  }
+	  if (Len(subscope) > 0)
+	    cname = NewStringf("%s::%s", subscope, last);
+	  else
+	    cname = Copy(last);
+#if RESOLVE_DEBUG
+	  Printf(stdout, "subscope to create: [%s] cname: [%s]\n", subscope, cname);
+#endif
+	  fail = 0;
+	  Delete(subscope);
+	} else {
+	  if (is_class_definition) {
+	    if (!fit.item) {
+	      /* It is valid to define a new class with the same name as one forward declared in a parent scope */
+	      fail = 0;
+	    } else if (Swig_scopename_check(cname)) {
+	      /* Classes defined with scope qualifiers must have a matching forward declaration in matching scope */
+	      fail = 1;
+	    } else {
+	      /* This may let through some invalid cases */
+	      fail = 0;
+	    }
+#if RESOLVE_DEBUG
+	    Printf(stdout, "scope for class definition, fail: %d\n", fail);
+#endif
+	  } else {
+#if RESOLVE_DEBUG
+	    Printf(stdout, "no matching base scope for template\n");
+#endif
+	    fail = 1;
+	  }
+	}
+
+	Delete(found_scopes);
+	Delete(current_scopes);
+
+	if (fail) {
+	  String *cname_resolved = NewStringf("%s::%s", found_scopename, last);
+	  Swig_error(cparse_file, cparse_line, "'%s' resolves to '%s' and was incorrectly instantiated in scope '%s' instead of within scope '%s'.\n", cname, cname_resolved, current_scopename, found_scopename);
+	  cname = Copy(last);
+	  Delete(cname_resolved);
+	}
+      }
+
+      Delete(current_scopename);
+      Delete(found_scopename);
+    }
+  } else if (!is_class_definition) {
+    /* A template instantiation requires a template to be found in scope... fail here too?
+    Swig_error(cparse_file, cparse_line, "No template found to instantiate '%s' with %%template.\n", cname);
+     */
+  }
+
+  if (Swig_scopename_check(cname)) {
+    Node   *ns;
+    String *prefix = Swig_scopename_prefix(cname);
+    if (prefix && (Strncmp(prefix,"::",2) == 0)) {
+/* I don't think we can use :: global scope to declare classes and hence neither %template. - consider reporting error instead - wsfulton. */
+      /* Use the global scope */
+      String *nprefix = NewString(Char(prefix)+2);
+      Delete(prefix);
+      prefix= nprefix;
+      gscope = set_scope_to_global();
+    }
+    if (Len(prefix) == 0) {
+      String *base = Copy(last);
+      /* Use the global scope, but we need to add a 'global' namespace.  */
+      if (!gscope) gscope = set_scope_to_global();
+      /* note that this namespace is not the "unnamed" one,
+	 and we don't use Setattr(nscope,"name", ""),
+	 because the unnamed namespace is private */
+      nscope = new_node("namespace");
+      Setattr(nscope,"symtab", gscope);;
+      nscope_inner = nscope;
+      Delete(last);
+      return base;
+    }
+    /* Try to locate the scope */
+    ns = Swig_symbol_clookup(prefix,0);
+    if (!ns) {
+      Swig_error(cparse_file,cparse_line,"Undefined scope '%s'\n", prefix);
+    } else {
+      Symtab *nstab = Getattr(ns,"symtab");
+      if (!nstab) {
+	Swig_error(cparse_file,cparse_line, "'%s' is not defined as a valid scope.\n", prefix);
+	ns = 0;
+      } else {
+	/* Check if the node scope is the current scope */
+	String *tname = Swig_symbol_qualifiedscopename(0);
+	String *nname = Swig_symbol_qualifiedscopename(nstab);
+	if (tname && (Strcmp(tname,nname) == 0)) {
+	  ns = 0;
+	  cname = Copy(last);
+	}
+	Delete(tname);
+	Delete(nname);
+      }
+      if (ns) {
+	/* we will try to create a new node using the namespaces we
+	   can find in the scope name */
+	List *scopes = Swig_scopename_tolist(prefix);
+	String *sname;
+	Iterator si;
+
+	for (si = First(scopes); si.item; si = Next(si)) {
+	  Node *ns1,*ns2;
+	  sname = si.item;
+	  ns1 = Swig_symbol_clookup(sname,0);
+	  assert(ns1);
+	  if (Strcmp(nodeType(ns1),"namespace") == 0) {
+	    if (Getattr(ns1,"alias")) {
+	      ns1 = Getattr(ns1,"namespace");
+	    }
+	  } else {
+	    /* now this last part is a class */
+	    si = Next(si);
+	    /*  or a nested class tree, which is unrolled here */
+	    for (; si.item; si = Next(si)) {
+	      if (si.item) {
+		Printf(sname,"::%s",si.item);
+	      }
+	    }
+	    /* we get the 'inner' class */
+	    nscope_inner = Swig_symbol_clookup(sname,0);
+	    /* set the scope to the inner class */
+	    Swig_symbol_setscope(Getattr(nscope_inner,"symtab"));
+	    /* save the last namespace prefix */
+	    Delete(Namespaceprefix);
+	    Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+	    /* and return the node name, including the inner class prefix */
+	    break;
+	  }
+	  /* here we just populate the namespace tree as usual */
+	  ns2 = new_node("namespace");
+	  Setattr(ns2,"name",sname);
+	  Setattr(ns2,"symtab", Getattr(ns1,"symtab"));
+	  add_symbols(ns2);
+	  Swig_symbol_setscope(Getattr(ns1,"symtab"));
+	  Delete(Namespaceprefix);
+	  Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+	  if (nscope_inner) {
+	    if (Getattr(nscope_inner,"symtab") != Getattr(ns2,"symtab")) {
+	      appendChild(nscope_inner,ns2);
+	      Delete(ns2);
+	    }
+	  }
+	  nscope_inner = ns2;
+	  if (!nscope) nscope = ns2;
+	}
+	cname = Copy(last);
+	Delete(scopes);
+      }
+    }
+    Delete(prefix);
+  }
+  Delete(last);
+
+  return cname;
+}
+ 
+/* look for simple typedef name in typedef list */
+static String *try_to_find_a_name_for_unnamed_structure(const char *storage, Node *decls) {
+  String *name = 0;
+  Node *n = decls;
+  if (storage && (strcmp(storage, "typedef") == 0)) {
+    for (; n; n = nextSibling(n)) {
+      if (!Len(Getattr(n, "decl"))) {
+	name = Copy(Getattr(n, "name"));
+	break;
+      }
+    }
+  }
+  return name;
+}
+
+/* traverse copied tree segment, and update outer class links*/
+static void update_nested_classes(Node *n)
+{
+  Node *c = firstChild(n);
+  while (c) {
+    if (Getattr(c, "nested:outer"))
+      Setattr(c, "nested:outer", n);
+    update_nested_classes(c);
+    c = nextSibling(c);
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * nested_forward_declaration()
+ * 
+ * Nested struct handling for C++ code if the nested classes are disabled.
+ * Create the nested class/struct/union as a forward declaration.
+ * ----------------------------------------------------------------------------- */
+
+static Node *nested_forward_declaration(const char *storage, const char *kind, String *sname, String *name, Node *cpp_opt_declarators) {
+  Node *nn = 0;
+
+  if (sname) {
+    /* Add forward declaration of the nested type */
+    Node *n = new_node("classforward");
+    Setattr(n, "kind", kind);
+    Setattr(n, "name", sname);
+    Setattr(n, "storage", storage);
+    Setattr(n, "sym:weak", "1");
+    add_symbols(n);
+    nn = n;
+  }
+
+  /* Add any variable instances. Also add in any further typedefs of the nested type.
+     Note that anonymous typedefs (eg typedef struct {...} a, b;) are treated as class forward declarations */
+  if (cpp_opt_declarators) {
+    int storage_typedef = (storage && (strcmp(storage, "typedef") == 0));
+    int variable_of_anonymous_type = !sname && !storage_typedef;
+    if (!variable_of_anonymous_type) {
+      int anonymous_typedef = !sname && (storage && (strcmp(storage, "typedef") == 0));
+      Node *n = cpp_opt_declarators;
+      SwigType *type = name;
+      while (n) {
+	Setattr(n, "type", type);
+	Setattr(n, "storage", storage);
+	if (anonymous_typedef) {
+	  Setattr(n, "nodeType", "classforward");
+	  Setattr(n, "sym:weak", "1");
+	}
+	n = nextSibling(n);
+      }
+      add_symbols(cpp_opt_declarators);
+
+      if (nn) {
+	set_nextSibling(nn, cpp_opt_declarators);
+      } else {
+	nn = cpp_opt_declarators;
+      }
+    }
+  }
+
+  if (!currentOuterClass || !GetFlag(currentOuterClass, "nested")) {
+    if (nn && Equal(nodeType(nn), "classforward")) {
+      Node *n = nn;
+      if (!GetFlag(n, "feature:ignore")) {
+	SWIG_WARN_NODE_BEGIN(n);
+	Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line,"Nested %s not currently supported (%s ignored)\n", kind, sname ? sname : name);
+	SWIG_WARN_NODE_END(n);
+      }
+    } else {
+      Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", kind);
+    }
+  }
+
+  return nn;
+}
+
+
+Node *Swig_cparse(File *f) {
+  scanner_file(f);
+  top = 0;
+  yyparse();
+  return top;
+}
+
+static void single_new_feature(const char *featurename, String *val, Hash *featureattribs, char *declaratorid, SwigType *type, ParmList *declaratorparms, String *qualifier) {
+  String *fname;
+  String *name;
+  String *fixname;
+  SwigType *t = Copy(type);
+
+  /* Printf(stdout, "single_new_feature: [%s] [%s] [%s] [%s] [%s] [%s]\n", featurename, val, declaratorid, t, ParmList_str_defaultargs(declaratorparms), qualifier); */
+
+  /* Warn about deprecated features */
+  if (strcmp(featurename, "nestedworkaround") == 0)
+    Swig_warning(WARN_DEPRECATED_NESTED_WORKAROUND, cparse_file, cparse_line, "The 'nestedworkaround' feature is deprecated.\n");
+
+  fname = NewStringf("feature:%s",featurename);
+  if (declaratorid) {
+    fixname = feature_identifier_fix(declaratorid);
+  } else {
+    fixname = NewStringEmpty();
+  }
+  if (Namespaceprefix) {
+    name = NewStringf("%s::%s",Namespaceprefix, fixname);
+  } else {
+    name = fixname;
+  }
+
+  if (declaratorparms) Setmeta(val,"parms",declaratorparms);
+  if (!Len(t)) t = 0;
+  if (t) {
+    if (qualifier) SwigType_push(t,qualifier);
+    if (SwigType_isfunction(t)) {
+      SwigType *decl = SwigType_pop_function(t);
+      if (SwigType_ispointer(t)) {
+	String *nname = NewStringf("*%s",name);
+	Swig_feature_set(Swig_cparse_features(), nname, decl, fname, val, featureattribs);
+	Delete(nname);
+      } else {
+	Swig_feature_set(Swig_cparse_features(), name, decl, fname, val, featureattribs);
+      }
+      Delete(decl);
+    } else if (SwigType_ispointer(t)) {
+      String *nname = NewStringf("*%s",name);
+      Swig_feature_set(Swig_cparse_features(),nname,0,fname,val, featureattribs);
+      Delete(nname);
+    }
+  } else {
+    /* Global feature, that is, feature not associated with any particular symbol */
+    Swig_feature_set(Swig_cparse_features(),name,0,fname,val, featureattribs);
+  }
+  Delete(fname);
+  Delete(name);
+}
+
+/* Add a new feature to the Hash. Additional features are added if the feature has a parameter list (declaratorparms)
+ * and one or more of the parameters have a default argument. An extra feature is added for each defaulted parameter,
+ * simulating the equivalent overloaded method. */
+static void new_feature(const char *featurename, String *val, Hash *featureattribs, char *declaratorid, SwigType *type, ParmList *declaratorparms, String *qualifier) {
+
+  ParmList *declparms = declaratorparms;
+
+  /* remove the { and } braces if the noblock attribute is set */
+  String *newval = remove_block(featureattribs, val);
+  val = newval ? newval : val;
+
+  /* Add the feature */
+  single_new_feature(featurename, val, featureattribs, declaratorid, type, declaratorparms, qualifier);
+
+  /* Add extra features if there are default parameters in the parameter list */
+  if (type) {
+    while (declparms) {
+      if (ParmList_has_defaultargs(declparms)) {
+
+        /* Create a parameter list for the new feature by copying all
+           but the last (defaulted) parameter */
+        ParmList* newparms = CopyParmListMax(declparms, ParmList_len(declparms)-1);
+
+        /* Create new declaration - with the last parameter removed */
+        SwigType *newtype = Copy(type);
+        Delete(SwigType_pop_function(newtype)); /* remove the old parameter list from newtype */
+        SwigType_add_function(newtype,newparms);
+
+        single_new_feature(featurename, Copy(val), featureattribs, declaratorid, newtype, newparms, qualifier);
+        declparms = newparms;
+      } else {
+        declparms = 0;
+      }
+    }
+  }
+}
+
+/* check if a function declaration is a plain C object */
+static int is_cfunction(Node *n) {
+  if (!cparse_cplusplus || cparse_externc)
+    return 1;
+  if (Swig_storage_isexternc(n)) {
+    return 1;
+  }
+  return 0;
+}
+
+/* If the Node is a function with parameters, check to see if any of the parameters
+ * have default arguments. If so create a new function for each defaulted argument. 
+ * The additional functions form a linked list of nodes with the head being the original Node n. */
+static void default_arguments(Node *n) {
+  Node *function = n;
+
+  if (function) {
+    ParmList *varargs = Getattr(function,"feature:varargs");
+    if (varargs) {
+      /* Handles the %varargs directive by looking for "feature:varargs" and 
+       * substituting ... with an alternative set of arguments.  */
+      Parm     *p = Getattr(function,"parms");
+      Parm     *pp = 0;
+      while (p) {
+	SwigType *t = Getattr(p,"type");
+	if (Strcmp(t,"v(...)") == 0) {
+	  if (pp) {
+	    ParmList *cv = Copy(varargs);
+	    set_nextSibling(pp,cv);
+	    Delete(cv);
+	  } else {
+	    ParmList *cv =  Copy(varargs);
+	    Setattr(function,"parms", cv);
+	    Delete(cv);
+	  }
+	  break;
+	}
+	pp = p;
+	p = nextSibling(p);
+      }
+    }
+
+    /* Do not add in functions if kwargs is being used or if user wants old default argument wrapping
+       (one wrapped method per function irrespective of number of default arguments) */
+    if (compact_default_args 
+	|| is_cfunction(function) 
+	|| GetFlag(function,"feature:compactdefaultargs") 
+	|| (GetFlag(function,"feature:kwargs") && kwargs_supported)) {
+      ParmList *p = Getattr(function,"parms");
+      if (p) 
+        Setattr(p,"compactdefargs", "1"); /* mark parameters for special handling */
+      function = 0; /* don't add in extra methods */
+    }
+  }
+
+  while (function) {
+    ParmList *parms = Getattr(function,"parms");
+    if (ParmList_has_defaultargs(parms)) {
+
+      /* Create a parameter list for the new function by copying all
+         but the last (defaulted) parameter */
+      ParmList* newparms = CopyParmListMax(parms,ParmList_len(parms)-1);
+
+      /* Create new function and add to symbol table */
+      {
+	SwigType *ntype = Copy(nodeType(function));
+	char *cntype = Char(ntype);
+        Node *new_function = new_node(ntype);
+        SwigType *decl = Copy(Getattr(function,"decl"));
+        int constqualifier = SwigType_isconst(decl);
+	String *ccode = Copy(Getattr(function,"code"));
+	String *cstorage = Copy(Getattr(function,"storage"));
+	String *cvalue = Copy(Getattr(function,"value"));
+	SwigType *ctype = Copy(Getattr(function,"type"));
+	String *cthrow = Copy(Getattr(function,"throw"));
+
+        Delete(SwigType_pop_function(decl)); /* remove the old parameter list from decl */
+        SwigType_add_function(decl,newparms);
+        if (constqualifier)
+          SwigType_add_qualifier(decl,"const");
+
+        Setattr(new_function,"name", Getattr(function,"name"));
+        Setattr(new_function,"code", ccode);
+        Setattr(new_function,"decl", decl);
+        Setattr(new_function,"parms", newparms);
+        Setattr(new_function,"storage", cstorage);
+        Setattr(new_function,"value", cvalue);
+        Setattr(new_function,"type", ctype);
+        Setattr(new_function,"throw", cthrow);
+
+	Delete(ccode);
+	Delete(cstorage);
+	Delete(cvalue);
+	Delete(ctype);
+	Delete(cthrow);
+	Delete(decl);
+
+        {
+          Node *throws = Getattr(function,"throws");
+	  ParmList *pl = CopyParmList(throws);
+          if (throws) Setattr(new_function,"throws",pl);
+	  Delete(pl);
+        }
+
+        /* copy specific attributes for global (or in a namespace) template functions - these are not templated class methods */
+        if (strcmp(cntype,"template") == 0) {
+          Node *templatetype = Getattr(function,"templatetype");
+          Node *symtypename = Getattr(function,"sym:typename");
+          Parm *templateparms = Getattr(function,"templateparms");
+          if (templatetype) {
+	    Node *tmp = Copy(templatetype);
+	    Setattr(new_function,"templatetype",tmp);
+	    Delete(tmp);
+	  }
+          if (symtypename) {
+	    Node *tmp = Copy(symtypename);
+	    Setattr(new_function,"sym:typename",tmp);
+	    Delete(tmp);
+	  }
+          if (templateparms) {
+	    Parm *tmp = CopyParmList(templateparms);
+	    Setattr(new_function,"templateparms",tmp);
+	    Delete(tmp);
+	  }
+        } else if (strcmp(cntype,"constructor") == 0) {
+          /* only copied for constructors as this is not a user defined feature - it is hard coded in the parser */
+          if (GetFlag(function,"feature:new")) SetFlag(new_function,"feature:new");
+        }
+
+        add_symbols(new_function);
+        /* mark added functions as ones with overloaded parameters and point to the parsed method */
+        Setattr(new_function,"defaultargs", n);
+
+        /* Point to the new function, extending the linked list */
+        set_nextSibling(function, new_function);
+	Delete(new_function);
+        function = new_function;
+	
+	Delete(ntype);
+      }
+    } else {
+      function = 0;
+    }
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * mark_nodes_as_extend()
+ *
+ * Used by the %extend to mark subtypes with "feature:extend".
+ * template instances declared within %extend are skipped
+ * ----------------------------------------------------------------------------- */
+
+static void mark_nodes_as_extend(Node *n) {
+  for (; n; n = nextSibling(n)) {
+    if (Getattr(n, "template") && Strcmp(nodeType(n), "class") == 0)
+      continue;
+    /* Fix me: extend is not a feature. Replace with isextendmember? */
+    Setattr(n, "feature:extend", "1");
+    mark_nodes_as_extend(firstChild(n));
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * add_qualifier_to_declarator()
+ *
+ * Normally the qualifier is pushed on to the front of the type.
+ * Adding a qualifier to a pointer to member function is a special case.
+ * For example       : typedef double (Cls::*pmf)(void) const;
+ * The qualifier is  : q(const).
+ * The declarator is : m(Cls).f(void).
+ * We need           : m(Cls).q(const).f(void).
+ * ----------------------------------------------------------------------------- */
+
+static String *add_qualifier_to_declarator(SwigType *type, SwigType *qualifier) {
+  int is_pointer_to_member_function = 0;
+  String *decl = Copy(type);
+  String *poppedtype = NewString("");
+  assert(qualifier);
+
+  while (decl) {
+    if (SwigType_ismemberpointer(decl)) {
+      String *memberptr = SwigType_pop(decl);
+      if (SwigType_isfunction(decl)) {
+	is_pointer_to_member_function = 1;
+	SwigType_push(decl, qualifier);
+	SwigType_push(decl, memberptr);
+	Insert(decl, 0, poppedtype);
+	Delete(memberptr);
+	break;
+      } else {
+	Append(poppedtype, memberptr);
+      }
+      Delete(memberptr);
+    } else {
+      String *popped = SwigType_pop(decl);
+      if (!popped)
+	break;
+      Append(poppedtype, popped);
+      Delete(popped);
+    }
+  }
+
+  if (!is_pointer_to_member_function) {
+    Delete(decl);
+    decl = Copy(type);
+    SwigType_push(decl, qualifier);
+  }
+
+  Delete(poppedtype);
+  return decl;
+}
+
+
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+#line 1554 "parser.y"
+{
+  const char  *id;
+  List  *bases;
+  struct Define {
+    String *val;
+    String *rawval;
+    int     type;
+    String *qualifier;
+    String *refqualifier;
+    String *bitfield;
+    Parm   *throws;
+    String *throwf;
+    String *nexcept;
+    String *final;
+  } dtype;
+  struct {
+    const char *type;
+    String *filename;
+    int   line;
+  } loc;
+  struct {
+    char      *id;
+    SwigType  *type;
+    String    *defarg;
+    ParmList  *parms;
+    short      have_parms;
+    ParmList  *throws;
+    String    *throwf;
+    String    *nexcept;
+    String    *final;
+  } decl;
+  Parm         *tparms;
+  struct {
+    String     *method;
+    Hash       *kwargs;
+  } tmap;
+  struct {
+    String     *type;
+    String     *us;
+  } ptype;
+  SwigType     *type;
+  String       *str;
+  Parm         *p;
+  ParmList     *pl;
+  int           intvalue;
+  Node         *node;
+}
+/* Line 193 of yacc.c.  */
+#line 1963 "parser.c"
+	YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+/* Copy the second part of user declarations.  */
+
+
+/* Line 216 of yacc.c.  */
+#line 1976 "parser.c"
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions.  */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int i)
+#else
+static int
+YYID (i)
+    int i;
+#endif
+{
+  return i;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     ifndef _STDLIB_H
+#      define _STDLIB_H 1
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined _STDLIB_H \
+       && ! ((defined YYMALLOC || defined malloc) \
+	     && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef _STDLIB_H
+#    define _STDLIB_H 1
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss;
+  YYSTYPE yyvs;
+  };
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
+      while (YYID (0))
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack)					\
+    do									\
+      {									\
+	YYSIZE_T yynewbytes;						\
+	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+	Stack = &yyptr->Stack;						\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+	yyptr += yynewbytes / sizeof (*yyptr);				\
+      }									\
+    while (YYID (0))
+
+#endif
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  62
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   6355
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  145
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  185
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  632
+/* YYNRULES -- Number of states.  */
+#define YYNSTATES  1203
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   399
+
+#define YYTRANSLATE(YYX)						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
+      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
+     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
+     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
+     135,   136,   137,   138,   139,   140,   141,   142,   143,   144
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+   YYRHS.  */
+static const yytype_uint16 yyprhs[] =
+{
+       0,     0,     3,     5,     9,    12,    16,    19,    25,    29,
+      32,    35,    38,    40,    42,    44,    46,    48,    50,    52,
+      55,    57,    59,    61,    63,    65,    67,    69,    71,    73,
+      75,    77,    79,    81,    83,    85,    87,    89,    91,    93,
+      95,    97,    98,   107,   113,   117,   123,   129,   139,   143,
+     147,   150,   153,   159,   162,   168,   171,   176,   178,   180,
+     188,   196,   202,   203,   211,   213,   215,   218,   221,   223,
+     229,   235,   241,   245,   250,   254,   262,   271,   277,   281,
+     283,   285,   289,   291,   296,   304,   311,   313,   315,   323,
+     333,   342,   353,   359,   367,   374,   383,   385,   387,   393,
+     398,   404,   412,   414,   418,   425,   432,   441,   443,   446,
+     450,   452,   455,   459,   466,   472,   482,   485,   487,   489,
+     491,   492,   499,   501,   508,   519,   521,   528,   538,   540,
+     546,   548,   550,   552,   554,   556,   558,   560,   562,   565,
+     567,   580,   595,   604,   606,   608,   610,   612,   614,   615,
+     619,   621,   624,   627,   630,   632,   638,   647,   659,   666,
+     668,   670,   672,   674,   676,   678,   679,   690,   691,   700,
+     702,   707,   712,   713,   720,   724,   731,   736,   744,   746,
+     748,   750,   752,   754,   756,   758,   761,   763,   765,   767,
+     771,   773,   777,   782,   783,   790,   791,   797,   803,   806,
+     807,   808,   816,   818,   820,   821,   825,   827,   829,   831,
+     833,   835,   837,   839,   841,   845,   847,   849,   851,   853,
+     855,   857,   859,   861,   863,   865,   868,   871,   878,   885,
+     893,   902,   911,   920,   930,   938,   944,   947,   950,   953,
+     956,   958,   960,   962,   964,   966,   968,   970,   972,   974,
+     976,   978,   981,   986,   989,   992,   997,  1000,  1006,  1008,
+    1010,  1012,  1014,  1016,  1019,  1021,  1023,  1026,  1029,  1031,
+    1033,  1035,  1037,  1039,  1041,  1044,  1047,  1050,  1053,  1055,
+    1058,  1061,  1064,  1067,  1069,  1071,  1074,  1076,  1080,  1085,
+    1087,  1090,  1098,  1100,  1102,  1105,  1108,  1110,  1113,  1115,
+    1119,  1121,  1123,  1125,  1128,  1130,  1134,  1136,  1139,  1145,
+    1148,  1151,  1153,  1156,  1159,  1161,  1167,  1169,  1171,  1177,
+    1179,  1182,  1186,  1190,  1192,  1195,  1198,  1202,  1207,  1213,
+    1218,  1222,  1227,  1232,  1235,  1239,  1243,  1248,  1254,  1261,
+    1268,  1274,  1280,  1282,  1285,  1289,  1294,  1300,  1304,  1309,
+    1314,  1316,  1319,  1324,  1329,  1334,  1340,  1347,  1353,  1360,
+    1364,  1369,  1374,  1380,  1382,  1385,  1388,  1391,  1395,  1399,
+    1401,  1404,  1407,  1409,  1411,  1414,  1418,  1422,  1427,  1431,
+    1436,  1439,  1443,  1447,  1452,  1458,  1462,  1466,  1469,  1472,
+    1474,  1476,  1479,  1481,  1483,  1485,  1487,  1490,  1492,  1494,
+    1496,  1498,  1501,  1503,  1506,  1510,  1512,  1514,  1516,  1519,
+    1521,  1523,  1526,  1528,  1533,  1535,  1537,  1540,  1542,  1544,
+    1546,  1548,  1550,  1552,  1554,  1556,  1558,  1560,  1562,  1564,
+    1566,  1568,  1569,  1572,  1574,  1576,  1578,  1580,  1582,  1584,
+    1586,  1588,  1591,  1593,  1595,  1597,  1600,  1604,  1609,  1611,
+    1615,  1617,  1620,  1622,  1626,  1628,  1630,  1632,  1636,  1643,
+    1647,  1654,  1658,  1665,  1669,  1676,  1678,  1680,  1682,  1688,
+    1695,  1700,  1703,  1705,  1707,  1709,  1711,  1713,  1717,  1722,
+    1728,  1734,  1740,  1747,  1754,  1757,  1760,  1762,  1764,  1766,
+    1768,  1770,  1772,  1774,  1776,  1780,  1784,  1788,  1792,  1796,
+    1800,  1804,  1808,  1812,  1816,  1820,  1824,  1828,  1832,  1838,
+    1844,  1848,  1852,  1856,  1862,  1865,  1868,  1871,  1874,  1877,
+    1879,  1881,  1883,  1884,  1888,  1890,  1892,  1896,  1897,  1902,
+    1903,  1910,  1912,  1914,  1916,  1918,  1920,  1923,  1926,  1928,
+    1930,  1932,  1934,  1936,  1938,  1940,  1942,  1944,  1946,  1948,
+    1950,  1953,  1956,  1958,  1960,  1962,  1964,  1969,  1971,  1973,
+    1979,  1982,  1987,  1989,  1991,  1994,  1996,  1998,  2002,  2006,
+    2011,  2016,  2020,  2025,  2028,  2030,  2032,  2036,  2039,  2044,
+    2047,  2050,  2054,  2056,  2058,  2060,  2062,  2064,  2066,  2068,
+    2070,  2073,  2078,  2080,  2084,  2086,  2089,  2093,  2097,  2100,
+    2103,  2106,  2108,  2111,  2113,  2117,  2120,  2125,  2127,  2131,
+    2133,  2137,  2141,  2144,  2147,  2150,  2153,  2155,  2158,  2160,
+    2162,  2164,  2166,  2170,  2172,  2176,  2182,  2184,  2188,  2192,
+    2198,  2200,  2202
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+static const yytype_int16 yyrhs[] =
+{
+     146,     0,    -1,   147,    -1,   123,   243,    43,    -1,   123,
+       1,    -1,   124,   243,    43,    -1,   124,     1,    -1,   125,
+      40,   239,    41,    43,    -1,   125,     1,    43,    -1,   147,
+     148,    -1,   147,   126,    -1,   147,   127,    -1,   329,    -1,
+     149,    -1,   186,    -1,   203,    -1,    43,    -1,     1,    -1,
+     202,    -1,     1,   122,    -1,   150,    -1,   152,    -1,   153,
+      -1,   154,    -1,   155,    -1,   156,    -1,   159,    -1,   160,
+      -1,   163,    -1,   164,    -1,   165,    -1,   166,    -1,   167,
+      -1,   168,    -1,   171,    -1,   173,    -1,   176,    -1,   178,
+      -1,   183,    -1,   184,    -1,   185,    -1,    -1,    67,   326,
+     301,   317,    46,   151,   220,    47,    -1,    99,   182,    46,
+     180,    47,    -1,   100,   180,    43,    -1,    63,   314,    55,
+     270,    43,    -1,    63,   263,   253,   250,    43,    -1,    63,
+     263,   255,    40,   239,    41,   259,   250,    43,    -1,    63,
+       1,    43,    -1,    63,     1,     0,    -1,    98,     4,    -1,
+      98,   323,    -1,    97,    40,   314,    41,    46,    -1,    97,
+      46,    -1,    97,    40,   314,    41,    43,    -1,    97,    43,
+      -1,   323,    46,   243,    47,    -1,   323,    -1,   157,    -1,
+     102,    40,   158,    42,   327,    41,     4,    -1,   102,    40,
+     158,    42,   327,    41,    46,    -1,   102,    40,   158,    41,
+      43,    -1,    -1,   162,   326,   323,    60,   161,   147,    61,
+      -1,     8,    -1,     9,    -1,    95,     4,    -1,    95,    46,
+      -1,     4,    -1,    10,    40,   315,    41,   323,    -1,    10,
+      40,   315,    41,     4,    -1,    10,    40,   315,    41,    46,
+      -1,    57,   326,   315,    -1,    64,    40,   315,    41,    -1,
+      64,    40,    41,    -1,    94,    40,   314,    41,   238,   314,
+      43,    -1,    94,    40,   314,    41,   238,   263,   253,    43,
+      -1,    68,   170,   314,    55,   169,    -1,    68,   170,   314,
+      -1,   323,    -1,     4,    -1,    40,   314,    41,    -1,   329,
+      -1,   172,   253,   315,    43,    -1,   172,    40,   327,    41,
+     253,   308,    43,    -1,   172,    40,   327,    41,   323,    43,
+      -1,    65,    -1,    66,    -1,    69,    40,   315,    41,   253,
+     308,   174,    -1,    69,    40,   315,    42,   328,    41,   253,
+     308,    43,    -1,    69,    40,   315,   175,    41,   253,   308,
+     174,    -1,    69,    40,   315,    42,   328,   175,    41,   253,
+     308,    43,    -1,    69,    40,   315,    41,   174,    -1,    69,
+      40,   315,    42,   328,    41,    43,    -1,    69,    40,   315,
+     175,    41,   174,    -1,    69,    40,   315,    42,   328,   175,
+      41,    43,    -1,   325,    -1,    43,    -1,   116,    40,   239,
+      41,    43,    -1,    42,   315,    55,   328,    -1,    42,   315,
+      55,   328,   175,    -1,    70,    40,   177,    41,   253,   308,
+      43,    -1,   239,    -1,    13,    42,   243,    -1,    96,    40,
+     179,    41,   180,   325,    -1,    96,    40,   179,    41,   180,
+      43,    -1,    96,    40,   179,    41,   180,    55,   182,    43,
+      -1,   327,    -1,   182,   181,    -1,    42,   182,   181,    -1,
+     329,    -1,   263,   252,    -1,    40,   239,    41,    -1,    40,
+     239,    41,    40,   239,    41,    -1,   115,    40,   239,    41,
+     174,    -1,   101,    40,   316,    41,   321,   104,   244,   105,
+      43,    -1,   103,   323,    -1,   188,    -1,   201,    -1,   200,
+      -1,    -1,    44,   323,    46,   187,   147,    47,    -1,   192,
+      -1,    92,   317,    55,   263,   252,    43,    -1,   120,   104,
+     212,   105,    92,   317,    55,   263,   252,    43,    -1,   230,
+      -1,   238,   263,   253,   308,   190,   189,    -1,   238,    88,
+     253,   308,   113,   191,   304,   190,   189,    -1,    43,    -1,
+      42,   253,   308,   190,   189,    -1,    46,    -1,     1,    -1,
+     250,    -1,   267,    -1,    32,    -1,    30,    -1,    35,    -1,
+     317,    -1,   317,   133,    -1,   266,    -1,   238,    88,   317,
+      55,   193,   194,    40,   239,    41,   308,   195,   196,    -1,
+     238,    88,   317,    55,   193,   194,    40,   239,    41,   308,
+     113,   263,   195,   196,    -1,   238,    88,   317,    55,   193,
+     194,   195,   196,    -1,    58,    -1,   104,    -1,   329,    -1,
+      46,    -1,    43,    -1,    -1,    40,   197,    43,    -1,    71,
+      -1,    71,    72,    -1,    71,    53,    -1,    77,   265,    -1,
+     329,    -1,   238,   198,   275,   199,    43,    -1,   238,   198,
+     275,   199,    46,   278,    47,    43,    -1,   238,   198,   275,
+     199,    46,   278,    47,   253,   308,   190,   189,    -1,   238,
+     263,    40,   239,    41,   309,    -1,   204,    -1,   208,    -1,
+     209,    -1,   216,    -1,   217,    -1,   229,    -1,    -1,   238,
+     299,   317,   305,   290,    46,   205,   220,    47,   207,    -1,
+      -1,   238,   299,   290,    46,   206,   220,    47,   207,    -1,
+      43,    -1,   253,   308,   190,   189,    -1,   238,   299,   317,
+      43,    -1,    -1,   120,   104,   212,   105,   210,   211,    -1,
+     120,   299,   317,    -1,   120,   191,   317,    40,   239,    41,
+      -1,    44,   120,   299,   317,    -1,    44,   120,   191,   317,
+      40,   239,    41,    -1,   188,    -1,   204,    -1,   226,    -1,
+     209,    -1,   208,    -1,   228,    -1,   213,    -1,   214,   215,
+      -1,   329,    -1,   298,    -1,   243,    -1,    42,   214,   215,
+      -1,   329,    -1,    92,   317,    43,    -1,    92,    93,   317,
+      43,    -1,    -1,    93,   317,    46,   218,   147,    47,    -1,
+      -1,    93,    46,   219,   147,    47,    -1,    93,   314,    55,
+     317,    43,    -1,   225,   220,    -1,    -1,    -1,    67,    46,
+     221,   220,    47,   222,   220,    -1,   160,    -1,   329,    -1,
+      -1,     1,   223,   220,    -1,   186,    -1,   226,    -1,   227,
+      -1,   231,    -1,   232,    -1,   228,    -1,   208,    -1,   204,
+      -1,   238,   317,    43,    -1,   216,    -1,   209,    -1,   229,
+      -1,   184,    -1,   185,    -1,   235,    -1,   159,    -1,   183,
+      -1,    43,    -1,   224,    -1,   126,   224,    -1,   224,   127,
+      -1,   238,   263,    40,   239,    41,   309,    -1,   142,   319,
+      40,   239,    41,   233,    -1,    79,   142,   319,    40,   239,
+      41,   234,    -1,   238,   122,   263,   258,    40,   239,    41,
+     234,    -1,   238,   122,   263,   133,    40,   239,    41,   234,
+      -1,   238,   122,   263,   130,    40,   239,    41,   234,    -1,
+     238,   122,   263,   258,   133,    40,   239,    41,   234,    -1,
+     238,   122,   263,    40,   239,    41,   234,    -1,    82,    40,
+     239,    41,    46,    -1,    84,    40,    -1,    75,    77,    -1,
+      74,    77,    -1,    76,    77,    -1,   168,    -1,   154,    -1,
+     166,    -1,   171,    -1,   173,    -1,   176,    -1,   164,    -1,
+     178,    -1,   152,    -1,   153,    -1,   155,    -1,   308,    43,
+      -1,   308,    55,   272,    43,    -1,   308,    46,    -1,   308,
+      43,    -1,   308,    55,   270,    43,    -1,   308,    46,    -1,
+     238,   236,    77,   283,    43,    -1,   267,    -1,    32,    -1,
+      30,    -1,    35,    -1,   317,    -1,    44,   323,    -1,    44,
+      -1,   237,    -1,   237,    86,    -1,   237,    21,    -1,    78,
+      -1,    21,    -1,    79,    -1,    80,    -1,    83,    -1,    85,
+      -1,    83,    85,    -1,    85,    83,    -1,    78,    85,    -1,
+      85,    78,    -1,    86,    -1,    86,    78,    -1,    78,    86,
+      -1,    44,    86,    -1,    86,    44,    -1,   329,    -1,   240,
+      -1,   243,   241,    -1,   329,    -1,    42,   243,   241,    -1,
+      42,   127,   243,   241,    -1,   329,    -1,   264,   251,    -1,
+     120,   104,   299,   105,   299,   317,   250,    -1,    49,    -1,
+     242,    -1,   126,   242,    -1,   242,   127,    -1,   245,    -1,
+     247,   246,    -1,   329,    -1,    42,   247,   246,    -1,   329,
+      -1,   243,    -1,   286,    -1,   286,   249,    -1,   329,    -1,
+      42,   286,   249,    -1,   329,    -1,    55,   270,    -1,    55,
+     270,    58,   283,    59,    -1,    55,    46,    -1,    77,   283,
+      -1,   329,    -1,   253,   250,    -1,   256,   250,    -1,   250,
+      -1,   255,    40,   239,    41,   259,    -1,   253,    -1,   256,
+      -1,   255,    40,   239,    41,   259,    -1,   329,    -1,   258,
+     254,    -1,   258,   133,   254,    -1,   258,   130,   254,    -1,
+     255,    -1,   133,   254,    -1,   130,   254,    -1,   317,   118,
+     254,    -1,   258,   317,   118,   254,    -1,   258,   317,   118,
+     133,   254,    -1,   317,   118,   133,   254,    -1,   258,    49,
+     254,    -1,   258,   133,    49,   254,    -1,   258,   130,    49,
+     254,    -1,    49,   255,    -1,   133,    49,   254,    -1,   130,
+      49,   254,    -1,   317,   118,    49,   254,    -1,   258,   317,
+     118,    49,   254,    -1,   258,   317,   118,   133,    49,   254,
+      -1,   258,   317,   118,   130,    49,   254,    -1,   317,   118,
+     133,    49,   254,    -1,   317,   118,   130,    49,   254,    -1,
+     317,    -1,   142,   317,    -1,    40,   317,    41,    -1,    40,
+     258,   254,    41,    -1,    40,   317,   118,   254,    41,    -1,
+     254,    58,    59,    -1,   254,    58,   283,    59,    -1,   254,
+      40,   239,    41,    -1,   317,    -1,   142,   317,    -1,    40,
+     258,   255,    41,    -1,    40,   133,   255,    41,    -1,    40,
+     130,   255,    41,    -1,    40,   317,   118,   253,    41,    -1,
+      40,   317,   118,   261,   253,    41,    -1,    40,   317,   118,
+     256,    41,    -1,    40,   317,   118,   261,   256,    41,    -1,
+     255,    58,    59,    -1,   255,    58,   283,    59,    -1,   255,
+      40,   239,    41,    -1,   121,     3,    40,   239,    41,    -1,
+     258,    -1,   258,   257,    -1,   258,   133,    -1,   258,   130,
+      -1,   258,   133,   257,    -1,   258,   130,   257,    -1,   257,
+      -1,   133,   257,    -1,   130,   257,    -1,   133,    -1,   130,
+      -1,   317,   118,    -1,   317,   118,   261,    -1,   258,   317,
+     118,    -1,   258,   317,   118,   257,    -1,   257,    58,    59,
+      -1,   257,    58,   283,    59,    -1,    58,    59,    -1,    58,
+     283,    59,    -1,    40,   256,    41,    -1,   257,    40,   239,
+      41,    -1,   257,    40,   239,    41,   259,    -1,    40,   239,
+      41,    -1,   140,   261,   258,    -1,   140,   258,    -1,   140,
+     261,    -1,   140,    -1,   261,    -1,   261,   260,    -1,   260,
+      -1,   133,    -1,   130,    -1,   262,    -1,   262,   261,    -1,
+      50,    -1,    51,    -1,    52,    -1,   264,    -1,   261,   265,
+      -1,   265,    -1,   265,   261,    -1,   261,   265,   261,    -1,
+     267,    -1,    32,    -1,    30,    -1,   198,   317,    -1,    35,
+      -1,   317,    -1,   299,   317,    -1,   266,    -1,    87,    40,
+     317,    41,    -1,   268,    -1,   269,    -1,   269,   268,    -1,
+      22,    -1,    24,    -1,    25,    -1,    28,    -1,    29,    -1,
+      26,    -1,    27,    -1,    31,    -1,    23,    -1,    33,    -1,
+      36,    -1,    37,    -1,    38,    -1,    39,    -1,    -1,   271,
+     283,    -1,   272,    -1,   273,    -1,   274,    -1,   106,    -1,
+     107,    -1,   314,    -1,   329,    -1,   154,    -1,   154,   276,
+      -1,   276,    -1,   329,    -1,   279,    -1,   279,   127,    -1,
+     279,    42,   278,    -1,   279,    42,   127,   278,    -1,   277,
+      -1,   277,   280,   277,    -1,   281,    -1,   126,   281,    -1,
+     314,    -1,   314,    55,   282,    -1,   283,    -1,   286,    -1,
+     263,    -1,     3,   113,     3,    -1,     3,   113,     3,    40,
+     248,    41,    -1,   284,   113,     3,    -1,   284,   113,     3,
+      40,   248,    41,    -1,     3,    48,     3,    -1,     3,    48,
+       3,    40,   248,    41,    -1,   284,    48,     3,    -1,   284,
+      48,     3,    40,   248,    41,    -1,   287,    -1,   284,    -1,
+     323,    -1,    56,    40,   263,   251,    41,    -1,    56,    49,
+      40,   263,   251,    41,    -1,    56,    40,   285,    41,    -1,
+      56,   285,    -1,   324,    -1,    11,    -1,    12,    -1,   285,
+      -1,   288,    -1,    40,   283,    41,    -1,    40,   283,    41,
+     283,    -1,    40,   283,   258,    41,   283,    -1,    40,   283,
+     133,    41,   283,    -1,    40,   283,   130,    41,   283,    -1,
+      40,   283,   258,   133,    41,   283,    -1,    40,   283,   258,
+     130,    41,   283,    -1,   133,   283,    -1,   140,   283,    -1,
+      13,    -1,    14,    -1,    15,    -1,    16,    -1,    17,    -1,
+      18,    -1,    19,    -1,    20,    -1,   283,   137,   283,    -1,
+     283,   136,   283,    -1,   283,   140,   283,    -1,   283,   139,
+     283,    -1,   283,   138,   283,    -1,   283,   133,   283,    -1,
+     283,   131,   283,    -1,   283,   132,   283,    -1,   283,   135,
+     283,    -1,   283,   134,   283,    -1,   283,   130,   283,    -1,
+     283,   129,   283,    -1,   283,   110,   283,    -1,   283,   111,
+     283,    -1,    40,   283,   105,   283,    41,    -1,    40,   285,
+     104,   283,    41,    -1,   283,   109,   283,    -1,   283,   108,
+     283,    -1,   283,   112,   283,    -1,   283,   114,   283,    77,
+     283,    -1,   136,   283,    -1,   137,   283,    -1,   142,   283,
+      -1,   141,   283,    -1,   263,    40,    -1,    49,    -1,   329,
+      -1,   291,    -1,    -1,    77,   292,   293,    -1,   329,    -1,
+     294,    -1,   293,    42,   294,    -1,    -1,   302,   295,   317,
+     289,    -1,    -1,   302,   297,   296,   302,   317,   289,    -1,
+      75,    -1,    74,    -1,    76,    -1,    72,    -1,    73,    -1,
+      72,    49,    -1,    73,    49,    -1,   298,    -1,    53,    -1,
+      54,    -1,    72,    -1,    53,    -1,    54,    -1,   300,    -1,
+     329,    -1,    79,    -1,   329,    -1,    90,    -1,    91,    -1,
+      91,    90,    -1,    90,    91,    -1,   303,    -1,   329,    -1,
+      91,    -1,   329,    -1,    81,    40,   239,    41,    -1,    89,
+      -1,   303,    -1,    81,    40,   239,    41,   303,    -1,    89,
+     303,    -1,    89,    40,   283,    41,    -1,   259,    -1,   306,
+      -1,   259,   306,    -1,   307,    -1,   329,    -1,   308,   310,
+      43,    -1,   308,   310,    46,    -1,    40,   239,    41,    43,
+      -1,    40,   239,    41,    46,    -1,    55,   270,    43,    -1,
+     306,    55,   272,    43,    -1,    77,   311,    -1,   329,    -1,
+     312,    -1,   311,    42,   312,    -1,   312,    49,    -1,   311,
+      42,   312,    49,    -1,   317,    40,    -1,   317,    46,    -1,
+     104,   244,   105,    -1,     3,    -1,    90,    -1,    91,    -1,
+     314,    -1,   272,    -1,   323,    -1,   315,    -1,   329,    -1,
+     319,   318,    -1,   117,   144,   320,   318,    -1,   319,    -1,
+     117,   144,   320,    -1,   121,    -1,   121,   313,    -1,   117,
+     144,   121,    -1,   144,   320,   318,    -1,   144,   320,    -1,
+     144,   121,    -1,   119,   319,    -1,   314,    -1,   314,   313,
+      -1,   319,    -1,   120,   314,   313,    -1,   314,   322,    -1,
+     117,   144,   314,   322,    -1,   314,    -1,   117,   144,   314,
+      -1,   121,    -1,   117,   144,   121,    -1,   144,   314,   322,
+      -1,   144,   314,    -1,   144,   121,    -1,   119,   314,    -1,
+     323,     6,    -1,     6,    -1,   324,     7,    -1,     7,    -1,
+     323,    -1,    46,    -1,     4,    -1,    40,   327,    41,    -1,
+     329,    -1,   315,    55,   328,    -1,   315,    55,   328,    42,
+     327,    -1,   315,    -1,   315,    42,   327,    -1,   315,    55,
+     157,    -1,   315,    55,   157,    42,   327,    -1,   323,    -1,
+     287,    -1,    -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const yytype_uint16 yyrline[] =
+{
+       0,  1730,  1730,  1742,  1746,  1749,  1752,  1755,  1758,  1763,
+    1772,  1776,  1783,  1788,  1789,  1790,  1791,  1792,  1802,  1818,
+    1828,  1829,  1830,  1831,  1832,  1833,  1834,  1835,  1836,  1837,
+    1838,  1839,  1840,  1841,  1842,  1843,  1844,  1845,  1846,  1847,
+    1848,  1855,  1855,  1937,  1947,  1961,  1981,  2005,  2029,  2033,
+    2044,  2053,  2072,  2078,  2084,  2089,  2096,  2103,  2107,  2120,
+    2129,  2144,  2157,  2157,  2213,  2214,  2221,  2240,  2271,  2275,
+    2285,  2290,  2308,  2351,  2357,  2370,  2376,  2402,  2408,  2415,
+    2416,  2419,  2420,  2427,  2473,  2519,  2530,  2533,  2560,  2566,
+    2572,  2578,  2586,  2592,  2598,  2604,  2612,  2613,  2614,  2617,
+    2622,  2632,  2668,  2669,  2704,  2721,  2729,  2742,  2764,  2770,
+    2774,  2777,  2788,  2793,  2806,  2818,  3117,  3127,  3134,  3135,
+    3139,  3139,  3172,  3178,  3188,  3200,  3209,  3289,  3352,  3356,
+    3381,  3385,  3396,  3401,  3402,  3403,  3407,  3408,  3409,  3413,
+    3424,  3429,  3434,  3441,  3447,  3451,  3454,  3459,  3462,  3462,
+    3475,  3478,  3481,  3490,  3493,  3500,  3522,  3551,  3649,  3702,
+    3703,  3704,  3705,  3706,  3707,  3716,  3716,  3965,  3965,  4112,
+    4113,  4125,  4143,  4143,  4404,  4410,  4416,  4422,  4428,  4431,
+    4434,  4437,  4440,  4443,  4448,  4484,  4488,  4491,  4494,  4499,
+    4503,  4508,  4518,  4549,  4549,  4607,  4607,  4629,  4656,  4673,
+    4678,  4673,  4686,  4687,  4688,  4688,  4702,  4703,  4720,  4721,
+    4722,  4723,  4724,  4725,  4726,  4727,  4728,  4729,  4730,  4731,
+    4732,  4733,  4734,  4735,  4737,  4740,  4744,  4756,  4785,  4815,
+    4848,  4867,  4888,  4910,  4933,  4956,  4964,  4971,  4978,  4986,
+    4994,  4997,  5001,  5004,  5005,  5006,  5007,  5008,  5009,  5010,
+    5011,  5014,  5025,  5036,  5049,  5060,  5071,  5085,  5088,  5091,
+    5092,  5096,  5098,  5106,  5118,  5119,  5120,  5127,  5128,  5129,
+    5130,  5131,  5132,  5133,  5134,  5135,  5136,  5137,  5138,  5139,
+    5140,  5141,  5142,  5143,  5150,  5161,  5165,  5172,  5176,  5181,
+    5185,  5197,  5207,  5217,  5220,  5224,  5230,  5243,  5247,  5250,
+    5254,  5258,  5286,  5294,  5298,  5301,  5305,  5308,  5321,  5337,
+    5348,  5358,  5370,  5374,  5378,  5385,  5407,  5424,  5443,  5462,
+    5469,  5477,  5486,  5495,  5499,  5508,  5519,  5530,  5542,  5552,
+    5566,  5574,  5583,  5592,  5596,  5605,  5616,  5627,  5639,  5649,
+    5659,  5670,  5683,  5690,  5698,  5714,  5722,  5733,  5744,  5755,
+    5774,  5782,  5799,  5807,  5814,  5821,  5832,  5844,  5855,  5867,
+    5878,  5889,  5909,  5930,  5936,  5942,  5949,  5956,  5965,  5974,
+    5977,  5986,  5995,  6002,  6009,  6016,  6024,  6034,  6045,  6056,
+    6067,  6074,  6081,  6084,  6101,  6119,  6129,  6136,  6142,  6147,
+    6154,  6158,  6163,  6170,  6174,  6180,  6184,  6190,  6191,  6192,
+    6198,  6204,  6208,  6209,  6213,  6220,  6223,  6224,  6228,  6229,
+    6231,  6234,  6237,  6242,  6253,  6278,  6281,  6335,  6339,  6343,
+    6347,  6351,  6355,  6359,  6363,  6367,  6371,  6375,  6379,  6383,
+    6387,  6393,  6393,  6409,  6414,  6417,  6423,  6438,  6454,  6455,
+    6458,  6459,  6463,  6464,  6474,  6478,  6483,  6493,  6504,  6509,
+    6514,  6517,  6523,  6531,  6543,  6558,  6559,  6579,  6583,  6587,
+    6591,  6595,  6599,  6603,  6607,  6614,  6617,  6620,  6624,  6629,
+    6641,  6649,  6653,  6658,  6672,  6689,  6690,  6693,  6703,  6721,
+    6728,  6735,  6742,  6750,  6758,  6762,  6768,  6769,  6770,  6771,
+    6772,  6773,  6774,  6775,  6778,  6782,  6786,  6790,  6794,  6798,
+    6802,  6806,  6810,  6814,  6818,  6822,  6826,  6830,  6838,  6848,
+    6852,  6856,  6860,  6869,  6875,  6879,  6883,  6887,  6891,  6907,
+    6910,  6915,  6920,  6920,  6921,  6924,  6941,  6950,  6950,  6968,
+    6968,  6986,  6987,  6988,  6991,  6995,  6999,  7003,  7009,  7012,
+    7016,  7022,  7026,  7030,  7036,  7039,  7044,  7045,  7048,  7051,
+    7054,  7057,  7062,  7065,  7070,  7073,  7078,  7084,  7090,  7096,
+    7102,  7108,  7116,  7124,  7129,  7136,  7139,  7149,  7160,  7171,
+    7181,  7191,  7199,  7211,  7212,  7215,  7216,  7217,  7218,  7221,
+    7233,  7239,  7248,  7249,  7250,  7253,  7254,  7255,  7258,  7259,
+    7262,  7267,  7271,  7274,  7277,  7280,  7283,  7288,  7292,  7295,
+    7302,  7308,  7311,  7316,  7319,  7325,  7330,  7334,  7337,  7340,
+    7343,  7348,  7352,  7355,  7358,  7364,  7367,  7370,  7378,  7381,
+    7384,  7388,  7393,  7406,  7410,  7415,  7421,  7425,  7430,  7434,
+    7441,  7444,  7449
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "END", "error", "$undefined", "ID", "HBLOCK", "POUND", "STRING",
+  "WSTRING", "INCLUDE", "IMPORT", "INSERT", "CHARCONST", "WCHARCONST",
+  "NUM_INT", "NUM_FLOAT", "NUM_UNSIGNED", "NUM_LONG", "NUM_ULONG",
+  "NUM_LONGLONG", "NUM_ULONGLONG", "NUM_BOOL", "TYPEDEF", "TYPE_INT",
+  "TYPE_UNSIGNED", "TYPE_SHORT", "TYPE_LONG", "TYPE_FLOAT", "TYPE_DOUBLE",
+  "TYPE_CHAR", "TYPE_WCHAR", "TYPE_VOID", "TYPE_SIGNED", "TYPE_BOOL",
+  "TYPE_COMPLEX", "TYPE_TYPEDEF", "TYPE_RAW", "TYPE_NON_ISO_INT8",
+  "TYPE_NON_ISO_INT16", "TYPE_NON_ISO_INT32", "TYPE_NON_ISO_INT64",
+  "LPAREN", "RPAREN", "COMMA", "SEMI", "EXTERN", "INIT", "LBRACE",
+  "RBRACE", "PERIOD", "ELLIPSIS", "CONST_QUAL", "VOLATILE", "REGISTER",
+  "STRUCT", "UNION", "EQUAL", "SIZEOF", "MODULE", "LBRACKET", "RBRACKET",
+  "BEGINFILE", "ENDOFFILE", "ILLEGAL", "CONSTANT", "NAME", "RENAME",
+  "NAMEWARN", "EXTEND", "PRAGMA", "FEATURE", "VARARGS", "ENUM", "CLASS",
+  "TYPENAME", "PRIVATE", "PUBLIC", "PROTECTED", "COLON", "STATIC",
+  "VIRTUAL", "FRIEND", "THROW", "CATCH", "EXPLICIT", "STATIC_ASSERT",
+  "CONSTEXPR", "THREAD_LOCAL", "DECLTYPE", "AUTO", "NOEXCEPT", "OVERRIDE",
+  "FINAL", "USING", "NAMESPACE", "NATIVE", "INLINE", "TYPEMAP", "EXCEPT",
+  "ECHO", "APPLY", "CLEAR", "SWIGTEMPLATE", "FRAGMENT", "WARN", "LESSTHAN",
+  "GREATERTHAN", "DELETE_KW", "DEFAULT", "LESSTHANOREQUALTO",
+  "GREATERTHANOREQUALTO", "EQUALTO", "NOTEQUALTO", "LESSEQUALGREATER",
+  "ARROW", "QUESTIONMARK", "TYPES", "PARMS", "NONID", "DSTAR", "DCNOT",
+  "TEMPLATE", "OPERATOR", "CONVERSIONOPERATOR", "PARSETYPE", "PARSEPARM",
+  "PARSEPARMS", "DOXYGENSTRING", "DOXYGENPOSTSTRING", "CAST", "LOR",
+  "LAND", "OR", "XOR", "AND", "RSHIFT", "LSHIFT", "MINUS", "PLUS",
+  "MODULO", "SLASH", "STAR", "LNOT", "NOT", "UMINUS", "DCOLON", "$accept",
+  "program", "interface", "declaration", "swig_directive",
+  "extend_directive", "@1", "apply_directive", "clear_directive",
+  "constant_directive", "echo_directive", "except_directive", "stringtype",
+  "fname", "fragment_directive", "include_directive", "@2", "includetype",
+  "inline_directive", "insert_directive", "module_directive",
+  "name_directive", "native_directive", "pragma_directive", "pragma_arg",
+  "pragma_lang", "rename_directive", "rename_namewarn",
+  "feature_directive", "stringbracesemi", "featattr", "varargs_directive",
+  "varargs_parms", "typemap_directive", "typemap_type", "tm_list",
+  "tm_tail", "typemap_parm", "types_directive", "template_directive",
+  "warn_directive", "c_declaration", "@3", "c_decl", "c_decl_tail",
+  "initializer", "cpp_alternate_rettype", "cpp_lambda_decl",
+  "lambda_introducer", "lambda_template", "lambda_body", "lambda_tail",
+  "@4", "c_enum_key", "c_enum_inherit", "c_enum_forward_decl",
+  "c_enum_decl", "c_constructor_decl", "cpp_declaration", "cpp_class_decl",
+  "@5", "@6", "cpp_opt_declarators", "cpp_forward_class_decl",
+  "cpp_template_decl", "@7", "cpp_template_possible", "template_parms",
+  "templateparameters", "templateparameter", "templateparameterstail",
+  "cpp_using_decl", "cpp_namespace_decl", "@8", "@9", "cpp_members", "@10",
+  "@11", "@12", "cpp_member_no_dox", "cpp_member", "cpp_constructor_decl",
+  "cpp_destructor_decl", "cpp_conversion_operator", "cpp_catch_decl",
+  "cpp_static_assert", "cpp_protection_decl", "cpp_swig_directive",
+  "cpp_end", "cpp_vend", "anonymous_bitfield", "anon_bitfield_type",
+  "extern_string", "storage_class", "parms", "rawparms", "ptail",
+  "parm_no_dox", "parm", "valparms", "rawvalparms", "valptail", "valparm",
+  "callparms", "callptail", "def_args", "parameter_declarator",
+  "plain_declarator", "declarator", "notso_direct_declarator",
+  "direct_declarator", "abstract_declarator", "direct_abstract_declarator",
+  "pointer", "cv_ref_qualifier", "ref_qualifier", "type_qualifier",
+  "type_qualifier_raw", "type", "rawtype", "type_right", "decltype",
+  "primitive_type", "primitive_type_list", "type_specifier", "definetype",
+  "@13", "default_delete", "deleted_definition", "explicit_default",
+  "ename", "constant_directives", "optional_ignored_defines", "enumlist",
+  "enumlist_item", "edecl_with_dox", "edecl", "etype", "expr", "exprmem",
+  "exprsimple", "valexpr", "exprnum", "exprcompound", "variadic",
+  "inherit", "raw_inherit", "@14", "base_list", "base_specifier", "@15",
+  "@16", "access_specifier", "templcpptype", "cpptype", "classkey",
+  "classkeyopt", "opt_virtual", "virt_specifier_seq",
+  "virt_specifier_seq_opt", "class_virt_specifier_opt",
+  "exception_specification", "qualifiers_exception_specification",
+  "cpp_const", "ctor_end", "ctor_initializer", "mem_initializer_list",
+  "mem_initializer", "less_valparms_greater", "identifier", "idstring",
+  "idstringopt", "idcolon", "idcolontail", "idtemplate",
+  "idtemplatetemplate", "idcolonnt", "idcolontailnt", "string", "wstring",
+  "stringbrace", "options", "kwargs", "stringnum", "empty", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
+     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
+     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
+     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
+     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
+     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
+     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
+     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
+     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
+     375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
+     385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
+     395,   396,   397,   398,   399
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint16 yyr1[] =
+{
+       0,   145,   146,   146,   146,   146,   146,   146,   146,   147,
+     147,   147,   147,   148,   148,   148,   148,   148,   148,   148,
+     149,   149,   149,   149,   149,   149,   149,   149,   149,   149,
+     149,   149,   149,   149,   149,   149,   149,   149,   149,   149,
+     149,   151,   150,   152,   153,   154,   154,   154,   154,   154,
+     155,   155,   156,   156,   156,   156,   157,   158,   158,   159,
+     159,   159,   161,   160,   162,   162,   163,   163,   164,   164,
+     164,   164,   165,   166,   166,   167,   167,   168,   168,   169,
+     169,   170,   170,   171,   171,   171,   172,   172,   173,   173,
+     173,   173,   173,   173,   173,   173,   174,   174,   174,   175,
+     175,   176,   177,   177,   178,   178,   178,   179,   180,   181,
+     181,   182,   182,   182,   183,   184,   185,   186,   186,   186,
+     187,   186,   186,   186,   186,   186,   188,   188,   189,   189,
+     189,   189,   190,   191,   191,   191,   191,   191,   191,   191,
+     192,   192,   192,   193,   194,   194,   195,   196,   197,   196,
+     198,   198,   198,   199,   199,   200,   201,   201,   202,   203,
+     203,   203,   203,   203,   203,   205,   204,   206,   204,   207,
+     207,   208,   210,   209,   209,   209,   209,   209,   211,   211,
+     211,   211,   211,   211,   212,   213,   213,   214,   214,   215,
+     215,   216,   216,   218,   217,   219,   217,   217,   220,   221,
+     222,   220,   220,   220,   223,   220,   224,   224,   224,   224,
+     224,   224,   224,   224,   224,   224,   224,   224,   224,   224,
+     224,   224,   224,   224,   225,   225,   225,   226,   227,   227,
+     228,   228,   228,   228,   228,   229,   230,   231,   231,   231,
+     232,   232,   232,   232,   232,   232,   232,   232,   232,   232,
+     232,   233,   233,   233,   234,   234,   234,   235,   236,   236,
+     236,   236,   236,   237,   238,   238,   238,   238,   238,   238,
+     238,   238,   238,   238,   238,   238,   238,   238,   238,   238,
+     238,   238,   238,   238,   239,   240,   240,   241,   241,   241,
+     242,   242,   242,   243,   243,   243,   244,   245,   245,   246,
+     246,   247,   247,   248,   248,   249,   249,   250,   250,   250,
+     250,   250,   251,   251,   251,   251,   252,   252,   252,   252,
+     253,   253,   253,   253,   253,   253,   253,   253,   253,   253,
+     253,   253,   253,   253,   253,   253,   253,   253,   253,   253,
+     253,   253,   254,   254,   254,   254,   254,   254,   254,   254,
+     255,   255,   255,   255,   255,   255,   255,   255,   255,   255,
+     255,   255,   255,   256,   256,   256,   256,   256,   256,   256,
+     256,   256,   256,   256,   256,   256,   256,   256,   257,   257,
+     257,   257,   257,   257,   257,   257,   258,   258,   258,   258,
+     259,   259,   259,   260,   260,   261,   261,   262,   262,   262,
+     263,   264,   264,   264,   264,   265,   265,   265,   265,   265,
+     265,   265,   265,   266,   267,   268,   268,   269,   269,   269,
+     269,   269,   269,   269,   269,   269,   269,   269,   269,   269,
+     269,   271,   270,   270,   272,   272,   273,   274,   275,   275,
+     276,   276,   277,   277,   278,   278,   278,   278,   278,   279,
+     280,   280,   281,   281,   282,   283,   283,   284,   284,   284,
+     284,   284,   284,   284,   284,   285,   285,   285,   285,   285,
+     285,   285,   285,   285,   285,   286,   286,   286,   286,   286,
+     286,   286,   286,   286,   286,   286,   287,   287,   287,   287,
+     287,   287,   287,   287,   288,   288,   288,   288,   288,   288,
+     288,   288,   288,   288,   288,   288,   288,   288,   288,   288,
+     288,   288,   288,   288,   288,   288,   288,   288,   288,   289,
+     289,   290,   292,   291,   291,   293,   293,   295,   294,   296,
+     294,   297,   297,   297,   298,   298,   298,   298,   299,   299,
+     299,   300,   300,   300,   301,   301,   302,   302,   303,   303,
+     303,   303,   304,   304,   305,   305,   306,   306,   306,   306,
+     306,   306,   307,   307,   307,   308,   308,   309,   309,   309,
+     309,   309,   309,   310,   310,   311,   311,   311,   311,   312,
+     312,   313,   314,   314,   314,   315,   315,   315,   316,   316,
+     317,   317,   317,   317,   317,   317,   317,   318,   318,   318,
+     318,   319,   319,   320,   320,   321,   321,   321,   321,   321,
+     321,   322,   322,   322,   322,   323,   323,   324,   324,   325,
+     325,   325,   326,   326,   327,   327,   327,   327,   327,   327,
+     328,   328,   329
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     1,     3,     2,     3,     2,     5,     3,     2,
+       2,     2,     1,     1,     1,     1,     1,     1,     1,     2,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     0,     8,     5,     3,     5,     5,     9,     3,     3,
+       2,     2,     5,     2,     5,     2,     4,     1,     1,     7,
+       7,     5,     0,     7,     1,     1,     2,     2,     1,     5,
+       5,     5,     3,     4,     3,     7,     8,     5,     3,     1,
+       1,     3,     1,     4,     7,     6,     1,     1,     7,     9,
+       8,    10,     5,     7,     6,     8,     1,     1,     5,     4,
+       5,     7,     1,     3,     6,     6,     8,     1,     2,     3,
+       1,     2,     3,     6,     5,     9,     2,     1,     1,     1,
+       0,     6,     1,     6,    10,     1,     6,     9,     1,     5,
+       1,     1,     1,     1,     1,     1,     1,     1,     2,     1,
+      12,    14,     8,     1,     1,     1,     1,     1,     0,     3,
+       1,     2,     2,     2,     1,     5,     8,    11,     6,     1,
+       1,     1,     1,     1,     1,     0,    10,     0,     8,     1,
+       4,     4,     0,     6,     3,     6,     4,     7,     1,     1,
+       1,     1,     1,     1,     1,     2,     1,     1,     1,     3,
+       1,     3,     4,     0,     6,     0,     5,     5,     2,     0,
+       0,     7,     1,     1,     0,     3,     1,     1,     1,     1,
+       1,     1,     1,     1,     3,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     2,     2,     6,     6,     7,
+       8,     8,     8,     9,     7,     5,     2,     2,     2,     2,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     2,     4,     2,     2,     4,     2,     5,     1,     1,
+       1,     1,     1,     2,     1,     1,     2,     2,     1,     1,
+       1,     1,     1,     1,     2,     2,     2,     2,     1,     2,
+       2,     2,     2,     1,     1,     2,     1,     3,     4,     1,
+       2,     7,     1,     1,     2,     2,     1,     2,     1,     3,
+       1,     1,     1,     2,     1,     3,     1,     2,     5,     2,
+       2,     1,     2,     2,     1,     5,     1,     1,     5,     1,
+       2,     3,     3,     1,     2,     2,     3,     4,     5,     4,
+       3,     4,     4,     2,     3,     3,     4,     5,     6,     6,
+       5,     5,     1,     2,     3,     4,     5,     3,     4,     4,
+       1,     2,     4,     4,     4,     5,     6,     5,     6,     3,
+       4,     4,     5,     1,     2,     2,     2,     3,     3,     1,
+       2,     2,     1,     1,     2,     3,     3,     4,     3,     4,
+       2,     3,     3,     4,     5,     3,     3,     2,     2,     1,
+       1,     2,     1,     1,     1,     1,     2,     1,     1,     1,
+       1,     2,     1,     2,     3,     1,     1,     1,     2,     1,
+       1,     2,     1,     4,     1,     1,     2,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     0,     2,     1,     1,     1,     1,     1,     1,     1,
+       1,     2,     1,     1,     1,     2,     3,     4,     1,     3,
+       1,     2,     1,     3,     1,     1,     1,     3,     6,     3,
+       6,     3,     6,     3,     6,     1,     1,     1,     5,     6,
+       4,     2,     1,     1,     1,     1,     1,     3,     4,     5,
+       5,     5,     6,     6,     2,     2,     1,     1,     1,     1,
+       1,     1,     1,     1,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     5,     5,
+       3,     3,     3,     5,     2,     2,     2,     2,     2,     1,
+       1,     1,     0,     3,     1,     1,     3,     0,     4,     0,
+       6,     1,     1,     1,     1,     1,     2,     2,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       2,     2,     1,     1,     1,     1,     4,     1,     1,     5,
+       2,     4,     1,     1,     2,     1,     1,     3,     3,     4,
+       4,     3,     4,     2,     1,     1,     3,     2,     4,     2,
+       2,     3,     1,     1,     1,     1,     1,     1,     1,     1,
+       2,     4,     1,     3,     1,     2,     3,     3,     2,     2,
+       2,     1,     2,     1,     3,     2,     4,     1,     3,     1,
+       3,     3,     2,     2,     2,     2,     1,     2,     1,     1,
+       1,     1,     3,     1,     3,     5,     1,     3,     3,     5,
+       1,     1,     0
+};
+
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_uint16 yydefact[] =
+{
+     632,     0,     0,     0,     0,     0,    12,     4,   582,   417,
+     425,   418,   419,   422,   423,   420,   421,   407,   424,   406,
+     426,   409,   427,   428,   429,   430,   292,   397,   398,   399,
+     539,   540,   150,   534,   535,     0,   583,   584,     0,     0,
+     594,     0,     0,   293,     0,     0,   395,   632,   402,   412,
+     405,   414,   415,   538,     0,   601,   410,   592,     6,     0,
+       0,   632,     1,    17,    68,    64,    65,     0,   269,    16,
+     264,   632,     0,     0,    86,    87,   632,   632,     0,     0,
+     268,   270,   271,     0,   272,     0,   273,   278,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    10,    11,     9,    13,    20,    21,    22,    23,
+      24,    25,    26,    27,   632,    28,    29,    30,    31,    32,
+      33,    34,     0,    35,    36,    37,    38,    39,    40,    14,
+     117,   122,   119,   118,    18,    15,   159,   160,   161,   162,
+     163,   164,   125,   265,     0,   283,   152,   151,   536,   537,
+       0,     0,     0,   632,   595,   294,   408,   295,     3,   401,
+     396,   632,     0,   431,     0,     0,   594,   373,   372,   389,
+       0,   314,   290,   632,   323,   632,   369,   363,   350,   311,
+     403,   416,   411,   602,     0,     0,   590,     5,     8,     0,
+     284,   632,   286,    19,     0,   616,   281,     0,   263,     0,
+       0,   623,     0,     0,   400,   601,     0,   632,     0,     0,
+      82,     0,   632,   276,   280,   632,   274,   236,   277,   275,
+     282,   279,     0,     0,   195,   601,     0,     0,    66,    67,
+       0,     0,    55,    53,    50,    51,   632,     0,   632,     0,
+     632,   632,     0,   116,   632,   135,   134,   136,   632,     0,
+     139,   133,     0,   137,     0,     0,     0,     0,     0,   323,
+       0,   350,   267,   266,     0,   632,     0,   632,     0,     0,
+     596,   603,   593,     0,   582,   618,   473,   474,   486,   487,
+     488,   489,   490,   491,   492,   493,     0,     0,     0,     0,
+       0,     0,     0,     0,   301,     0,   296,   632,   456,   400,
+       0,   466,   475,   455,   465,   476,   467,   472,   298,   404,
+     632,   373,   372,     0,     0,   363,   410,     0,   333,   350,
+     309,   436,   437,   307,     0,   433,   434,   435,   380,     0,
+     455,   310,     0,   632,     0,     0,   325,   371,   342,     0,
+     324,   370,   387,   388,   351,   312,   632,     0,   313,   632,
+       0,     0,   366,   365,   320,   364,   342,   374,   600,   599,
+     598,     0,     0,   285,   289,   586,   585,     0,   587,     0,
+       0,   615,   120,   626,     0,    72,    49,    48,   632,   323,
+     431,    74,     0,   542,   543,   541,   544,     0,   545,     0,
+      78,     0,     0,     0,   102,     0,     0,   191,     0,   632,
+       0,   193,     0,     0,   107,     0,     0,     0,   111,   316,
+     323,   317,   319,    44,     0,   108,   110,   588,     0,   589,
+      58,     0,    57,     0,     0,   184,   632,   188,   538,   186,
+       0,   174,   138,     0,     0,     0,     0,   585,     0,     0,
+       0,     0,   632,     0,     0,   342,     0,   632,   350,   632,
+     601,   439,   632,   632,   522,     0,   521,   411,   524,   413,
+       0,   591,     0,     0,     0,     0,   475,     0,     0,     0,
+     471,   484,   514,   515,   485,   517,   516,   581,     0,   297,
+     300,   518,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   617,   373,   372,   363,   410,     0,     0,   385,
+     382,   366,   365,     0,   350,   374,     0,   432,   381,   632,
+     363,   410,   335,   343,   632,     0,   334,   386,     0,   359,
+       0,     0,   378,     0,   330,     0,   322,   368,     0,   321,
+     367,   376,     0,     0,     0,   326,   375,   597,     7,     0,
+     632,     0,     0,   176,   632,     0,     0,   622,     0,   632,
+       0,    73,     0,    81,     0,     0,     0,     0,     0,     0,
+       0,   192,   632,     0,     0,   632,   632,     0,     0,   112,
+       0,   632,   632,     0,     0,     0,     0,     0,   172,     0,
+     185,   190,   632,    62,     0,     0,     0,     0,    83,     0,
+       0,     0,   557,   548,   549,   394,   393,   562,   392,   390,
+     558,   563,   565,     0,   566,     0,     0,     0,   154,     0,
+     410,   632,   632,   167,   171,   554,   632,   555,   604,     0,
+     461,   457,   477,     0,     0,     0,   389,     0,     0,   632,
+       0,     0,   632,   511,   510,   506,   507,   512,     0,   505,
+     504,   500,   501,   499,   503,   502,   495,   494,   498,   497,
+     496,   463,   459,     0,   374,   354,   353,   352,   376,     0,
+       0,   375,     0,     0,     0,   342,   344,   374,     0,   347,
+       0,   361,   360,   383,   379,   332,   331,     0,     0,     0,
+     327,   377,   336,     0,     0,   329,   632,   287,    70,    71,
+      69,   632,     0,   627,   628,   631,   630,   624,    46,     0,
+      45,    41,    80,    77,    79,   621,    97,   620,     0,    92,
+     632,   619,    96,     0,   630,     0,     0,   103,   632,   235,
+       0,   196,   197,     0,   264,     0,     0,    54,    52,   632,
+      43,     0,   109,     0,   609,   607,     0,    61,     0,     0,
+     114,     0,   632,   632,     0,   632,     0,   632,     0,     0,
+     361,   632,     0,   560,   551,   550,   564,   391,     0,   143,
+     632,   153,   155,   632,   632,     0,   132,   546,   523,   525,
+     527,   547,     0,     0,   632,   632,   632,   478,     0,     0,
+       0,   389,   388,     0,     0,     0,     0,     0,   470,   632,
+     299,     0,   632,   632,   355,   357,     0,     0,   308,   362,
+     345,     0,   349,   348,   315,   384,   337,     0,     0,   328,
+     341,   340,   288,     0,   121,     0,     0,   361,     0,   632,
+       0,     0,     0,     0,     0,    94,   632,     0,   123,   194,
+     263,     0,   601,   105,     0,   104,     0,   361,     0,     0,
+       0,   605,   632,     0,    56,     0,   264,     0,   178,   179,
+     182,   181,   173,   180,   183,     0,   189,   175,     0,     0,
+      85,     0,     0,   632,   144,     0,   145,   440,   442,   448,
+       0,   444,   443,   632,   431,   563,   632,   158,   131,     0,
+     128,   130,   126,   632,   532,   531,   533,     0,   529,   204,
+     223,     0,     0,     0,     0,   270,   632,     0,   248,   249,
+     241,   250,   221,   202,   246,   242,   240,   243,   244,   245,
+     247,   222,   218,   219,   206,   213,   212,   216,   215,     0,
+     224,     0,   207,   208,   211,   217,   209,   210,   220,     0,
+     283,   165,   291,     0,   455,   304,     0,   508,   481,   480,
+     479,     0,     0,   509,   468,     0,   513,     0,     0,   356,
+     358,   346,   339,   338,   177,   629,   625,   632,     0,     0,
+      88,   630,    99,    93,   632,     0,     0,   101,     0,    75,
+       0,   113,   318,   610,   608,   614,   613,   612,     0,    59,
+      60,     0,   632,     0,     0,     0,    63,    84,   556,   561,
+     552,   632,   553,   632,   146,     0,   441,     0,   632,   450,
+     452,     0,   632,   445,     0,     0,     0,     0,     0,   574,
+     632,   526,   632,   632,     0,   199,   238,   237,   239,     0,
+     225,     0,     0,   226,   198,   407,   406,   409,     0,   405,
+     410,     0,   462,     0,   303,   306,   458,   483,   482,   469,
+     464,   460,     0,    42,     0,   100,     0,    95,   632,    90,
+      76,   106,   606,   611,     0,   632,     0,     0,   632,   559,
+       0,     0,   148,   147,   142,   451,   449,     0,   156,   632,
+     632,   446,     0,   571,     0,   573,   575,     0,   567,   568,
+     632,   519,   528,   520,     0,   205,     0,     0,   632,   169,
+     168,   632,     0,   214,     0,   455,    47,    98,    89,     0,
+     115,     0,   172,   632,     0,     0,     0,     0,   127,   632,
+       0,   453,   454,   632,   447,   569,   570,   572,     0,   577,
+     579,   580,     0,   632,     0,   632,     0,   632,     0,     0,
+     305,    91,   124,     0,   632,   632,   632,     0,   632,     0,
+     149,     0,   576,   129,   530,   200,     0,   632,     0,   257,
+     166,   632,     0,     0,     0,   632,   227,     0,     0,   157,
+     578,     0,   632,   228,     0,   170,   234,     0,   632,   632,
+     632,     0,     0,   140,   201,   229,   251,   253,     0,   254,
+     256,   431,   232,   231,   230,   632,     0,     0,     0,   233,
+     141,   252,   255
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
+{
+      -1,     4,     5,   104,   105,   106,   828,   908,   909,   910,
+     911,   111,   420,   421,   912,   913,   755,   114,   115,   914,
+     117,   915,   119,   916,   713,   209,   917,   122,   918,   719,
+     567,   919,   393,   920,   403,   239,   415,   240,   921,   922,
+     923,   924,   554,   130,   892,   775,   249,   131,   770,   875,
+    1005,  1074,  1120,    42,   617,   132,   133,   134,   135,   925,
+    1041,   782,  1100,   926,   927,   752,   862,   424,   425,   426,
+     590,   928,   140,   575,   399,   929,  1096,  1171,  1024,   930,
+     931,   932,   933,   934,   935,   142,   936,   937,  1173,  1176,
+     938,  1038,   143,   939,   313,   190,   363,    43,   191,   295,
+     296,   479,   297,   943,  1044,   776,   172,   408,   173,   336,
+     259,   175,   176,   260,   607,   608,    45,    46,   298,   204,
+      48,    49,    50,    51,    52,   323,   324,   365,   326,   327,
+     449,   878,   879,   880,   881,  1008,  1009,  1121,   300,   301,
+     302,   330,   304,   305,  1092,   455,   456,   622,   778,   779,
+     897,  1023,   898,    53,    54,   386,   387,   780,   610,  1001,
+     626,   611,   612,  1177,   887,  1018,  1085,  1086,   183,    55,
+     373,   418,    56,   186,    57,   272,   746,   851,   306,   307,
+     722,   200,   374,   707,   192
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF -939
+static const yytype_int16 yypact[] =
+{
+     701,  4737,  4842,    88,   106,  4171,  -939,  -939,  -939,  -939,
+    -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,   287,   164,   195,   304,  -939,  -939,   213,   311,
+     346,  5565,   388,   258,   349,  5852,   792,   312,   792,  -939,
+    -939,  -939,  2868,  -939,   388,   346,  -939,   322,  -939,   405,
+     413,  5158,  -939,   309,  -939,  -939,  -939,   424,  -939,  -939,
+      57,   432,  5235,   440,  -939,  -939,   432,   503,   517,   522,
+     438,  -939,  -939,   528,   502,   534,   444,    34,   212,    69,
+     568,    65,   570,   601,   281,  5637,  5637,   575,   577,   613,
+     600,  5923,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,  -939,  -939,   432,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,  2034,  -939,  -939,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,  -939,    41,  5709,  -939,  -939,  -939,  -939,  -939,
+     388,   114,   431,  2517,  -939,  -939,  -939,  -939,  -939,   792,
+    -939,  3756,   126,   265,  2649,  3441,    70,  1003,  1238,   144,
+     388,  -939,  -939,   321,   288,   321,   379,    67,   527,  -939,
+    -939,  -939,  -939,  -939,   173,   398,  -939,  -939,  -939,   608,
+    -939,   634,  -939,  -939,   230,  -939,  -939,  6123,    76,   230,
+     230,  -939,   232,  2140,  -939,   223,  1025,   492,   173,   173,
+    -939,   230,  5053,  -939,  -939,  5158,  -939,  -939,  -939,  -939,
+    -939,  -939,   388,    53,  -939,   262,   609,   173,  -939,  -939,
+     230,   173,  -939,  -939,  -939,   662,  5158,   647,  1257,   637,
+     657,   230,   613,   662,  5158,  -939,  -939,  -939,  5158,   388,
+    -939,  -939,   388,   576,   613,  2187,  1575,  1639,   230,   418,
+     942,   596,  -939,  -939,  2140,   388,  2169,   133,   680,   173,
+    -939,  -939,   322,   620,    27,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,  -939,  -939,  -939,  -939,  3441,  2318,  3441,  3441,
+    3441,  3441,  3441,  3441,  -939,   631,  -939,   700,   690,  1246,
+    2747,    37,  -939,   172,  -939,  -939,   662,   739,  -939,  -939,
+    3875,  1408,  1408,   703,   710,   162,   669,   353,   418,  -939,
+    -939,  -939,  -939,   731,  3441,  -939,  -939,  -939,  -939,  6116,
+    -939,  2747,   757,  3875,   248,   388,   473,   379,  -939,   248,
+     473,   379,  -939,   668,  -939,  -939,  5158,  2781,  -939,  5158,
+    2913,   248,  1475,  1486,   473,   379,   709,   965,  -939,  -939,
+     322,   776,  4947,  -939,  -939,  -939,  -939,   789,   662,   388,
+     388,  -939,  -939,    55,   794,  -939,  -939,  -939,   321,   489,
+     554,  -939,   799,  -939,  -939,  -939,  -939,   388,  -939,   804,
+     793,   646,   811,   816,  -939,   818,   820,  -939,  5781,  -939,
+     388,  -939,   819,   825,  -939,   830,   838,  5637,  -939,  -939,
+     523,  -939,  -939,  -939,  5637,  -939,  -939,  -939,   841,  -939,
+    -939,   723,   243,   864,   803,  -939,   857,  -939,   204,  -939,
+     872,  -939,  -939,   231,   126,   126,   126,   476,   796,   884,
+     315,   883,  5158,  1642,  1834,   810,  1114,  1752,   206,   852,
+     448,  -939,  3994,  1752,  -939,   890,  -939,   449,  -939,  -939,
+     346,  -939,   431,   936,   937,  3846,   837,    27,  5492,   902,
+    -939,  1955,  -939,  -939,  -939,  -939,  -939,  -939,  2517,  -939,
+    -939,  -939,  3441,  3441,  3441,  3441,  3441,  3441,  3441,  3441,
+    3441,  3441,  3441,  3441,  3441,  3441,  3441,  3441,  3441,  3441,
+     940,   943,  -939,   530,   530,  1200,   833,   590,   593,  -939,
+    -939,   530,   530,   595,   834,   411,  3441,  2747,  -939,  5158,
+    1355,    49,   473,  -939,  5158,  3045,   473,  -939,   912,  -939,
+    6149,   913,  -939,  6161,   473,   248,   473,   379,   248,   473,
+     379,   283,   248,   906,  1851,   473,  -939,  -939,  -939,  5158,
+     634,   471,   916,  -939,  -939,   230,   903,  -939,   915,  5158,
+     917,  -939,   919,  -939,   587,  1595,  2600,   918,  5158,  2140,
+     923,  -939,  1257,  4286,   920,  -939,   959,  5637,   491,   922,
+     924,  5158,   657,   391,   927,   230,  5158,    52,   881,  5158,
+    -939,  -939,  5158,  -939,   411,  1715,   248,    90,  -939,   934,
+    1705,   938,   344,   886,   889,  -939,  -939,   626,  -939,   -28,
+    -939,  -939,  -939,   870,  -939,   928,  5852,   639,  -939,   946,
+     796,   321,   909,  -939,  -939,  -939,   921,  -939,  -939,   388,
+     950,   953,  3441,  3441,  3177,  3309,  3573,    97,  3441,   312,
+     954,  5781,   700,  1315,  1315,  1374,  1374,  1433,  2615,  3011,
+    3143,  3275,  2623,  1955,   752,   752,   737,   737,  -939,  -939,
+    -939,   956,   957,   834,   792,  -939,  -939,  -939,   530,   958,
+     963,  1257,  6203,   966,   625,   834,  -939,   508,   968,  -939,
+    6215,   357,  -939,   357,  -939,   473,   473,   248,   969,  2093,
+     473,   379,   473,   248,   248,   473,   634,  -939,  -939,  -939,
+     662,  5158,  4401,  -939,   977,  -939,   243,   979,  -939,   993,
+    -939,  -939,  -939,  -939,   662,  -939,  -939,  -939,   995,  -939,
+    1752,   662,  -939,   981,   313,   730,  1595,  -939,  1752,  -939,
+    1004,  -939,  -939,  4516,    75,  5781,   375,  -939,  -939,  5158,
+    -939,  1005,  -939,   904,  -939,   327,   945,  -939,  1009,  1006,
+    -939,   388,   817,   857,  1010,  -939,  1257,  1752,   319,   248,
+    -939,  5158,  3441,  -939,  -939,  -939,  -939,  -939,  3832,  -939,
+     960,  -939,  -939,   991,  1037,   496,  -939,  -939,  1015,  -939,
+     858,  -939,  2383,  1014,   321,  3441,  3441,  2747,  4808,  3441,
+    3441,  3573,  4065,  3441,  1021,  1026,  4913,  1027,  -939,   312,
+    -939,  3441,  3441,  3441,  -939,  -939,  1028,  1030,  -939,  -939,
+    -939,   632,  -939,  -939,  -939,  -939,   473,   248,   248,   473,
+     473,   473,  -939,  1032,  -939,   230,   230,   357,  2383,  5158,
+      52,   903,  1291,   230,  1033,  -939,  1752,  1040,  -939,  -939,
+     662,  2140,   178,  -939,  5637,  -939,  1035,   357,   180,   173,
+     222,  -939,  2517,    87,  -939,  1036,    57,  6023,  -939,  -939,
+    -939,  -939,  -939,  -939,  -939,  5307,  -939,  -939,  4631,  1042,
+    -939,  1059,  5019,   742,  -939,   347,  -939,   991,  -939,    56,
+    1055,    25,  -939,  5158,   554,  1048,  1029,  -939,  -939,  2140,
+    -939,  -939,  -939,   909,  -939,  -939,  -939,   388,  -939,  -939,
+    -939,  1058,  1031,  1052,  1053,   967,  3655,   173,  -939,  -939,
+    -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,
+    -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  1063,
+     985,  2383,  -939,  -939,  -939,  -939,  -939,  -939,  -939,  5380,
+    1066,  -939,  -939,  1084,   809,  -939,  1093,  -939,  2747,  2747,
+    2747,  3441,  3441,  -939,  -939,  1094,  2879,  1095,  1097,  -939,
+    -939,  -939,   473,   473,  -939,  -939,  -939,   321,  1096,  1099,
+    -939,   662,  1100,  -939,  1752,  1827,    52,  -939,  1098,  -939,
+    1101,  -939,  -939,  -939,   327,  -939,  -939,   327,  1044,  -939,
+    -939,  5781,  5158,  2140,  5781,  2222,  -939,  -939,   742,  -939,
+    -939,   321,  -939,  5158,  -939,   215,  -939,   173,   991,  -939,
+    1103,  1849,   130,  -939,  1109,  1108,   554,   388,   688,  -939,
+    1752,  -939,  1104,   909,  2383,  -939,  -939,  -939,  -939,   173,
+    -939,  1115,  1987,  -939,  -939,  1079,  1083,  1085,  1087,  1088,
+     253,  2383,  -939,  3441,  -939,  -939,  -939,  2747,  2747,  -939,
+    -939,  -939,  1123,  -939,  1126,  -939,  1130,  -939,  1752,  -939,
+    -939,  -939,  -939,  -939,  1131,  1257,  1070,   129,  3994,  -939,
+     496,  1141,  -939,  -939,  -939,  -939,  -939,  3441,  -939,  1752,
+     991,  -939,   750,  -939,  1140,  1142,  1136,   382,  -939,  -939,
+     321,  -939,  -939,  -939,   388,  -939,  2383,  1146,  5158,  -939,
+    -939,  1752,  3441,  -939,  1143,   809,  -939,  -939,  -939,  1145,
+    -939,  1154,  -939,  5158,  1149,  1161,    15,  1166,  -939,  1752,
+    1165,  -939,  2747,   321,  -939,  -939,  -939,  -939,   388,  -939,
+    -939,  -939,   496,  1104,  1162,  5158,  1169,   321,  5346,  1987,
+    -939,  -939,  -939,  1170,  5158,  5158,  5158,  1172,  1037,    11,
+    -939,   496,  1167,  -939,  -939,  -939,  1173,  1752,   496,  -939,
+    -939,  1752,  1177,  1178,  1179,  5158,  -939,  5781,   215,  -939,
+    -939,  2383,  1752,  -939,   649,  -939,  -939,   667,  1752,  1752,
+    1752,  1180,  1183,  -939,  -939,  -939,  -939,  -939,   554,  -939,
+    -939,   554,  -939,  -939,  -939,  1752,   215,  1182,  1187,  -939,
+    -939,  -939,  -939
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int16 yypgoto[] =
+{
+    -939,  -939,  -369,  -939,  -939,  -939,  -939,    -4,     4,    17,
+      30,  -939,   670,  -939,    33,    36,  -939,  -939,  -939,    45,
+    -939,    59,  -939,    79,  -939,  -939,    81,  -939,    89,  -556,
+    -691,    96,  -939,    98,  -939,  -365,   651,   -69,   104,   108,
+     113,   116,  -939,   482,  -929,  -936,  -184,  -939,  -939,  -939,
+    -833,  -814,  -939,  -132,  -939,  -939,  -939,  -939,  -939,     6,
+    -939,  -939,    99,    10,    43,  -939,  -939,   245,  -939,   650,
+     493,   121,  -939,  -939,  -939,  -796,  -939,  -939,  -939,   336,
+    -939,   498,  -939,   499,   132,  -939,  -939,  -939,  -939,  -567,
+    -939,  -939,  -939,    16,   119,  -939,  -504,  1204,    18,   396,
+    -939,   610,   775,  -237,   152,   -43,  -588,  -555,   747,  1701,
+     -39,  -155,    -5,  1067,  -629,   652,    20,  -939,   -56,    78,
+     -38,   -41,   -77,  1207,  -939,  -370,  -939,  -161,  -939,  -939,
+    -939,   392,   260,  -938,  -939,  -939,   263,  -939,  1525,  -939,
+    -242,  -128,  -523,  -939,   138,   648,  -939,  -939,  -939,   383,
+    -939,  -939,  -939,  -225,   -52,  -939,  -939,   254,  -575,  -939,
+    -939,  -593,  -939,   749,   131,  -939,  -939,   153,   -22,  1353,
+    -107,  -939,  1105,  -211,  -148,  1107,  -939,  -183,  1520,  -939,
+     544,   166,  -202,  -537,     0
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -633
+static const yytype_int16 yytable[] =
+{
+       6,   107,   325,   271,   171,   145,   314,   159,   174,   108,
+     560,   136,   265,   369,   766,   137,   203,   730,   154,    44,
+      59,   144,   109,   428,   251,   303,   237,   763,   404,   725,
+     573,   750,   968,   705,   834,   110,   358,   271,   112,   238,
+     238,   113,   580,   705,   466,   470,   697,   179,   138,   252,
+     116,   797,   814,   439,   815,  1146,   715,  1004,   195,     8,
+     250,   461,   262,   195,   118,  1070,   160,  1012,   180,   228,
+       8,   201,     8,   332,  1081,   463,   201,   210,   220,    47,
+      47,   195,   371,   411,   120,   500,   121,   367,   266,    60,
+     676,   989,   267,   375,   123,   716,   397,   555,   717,   382,
+     273,   124,   605,   125,   391,   606,    62,   333,   398,   126,
+     556,   229,   221,   127,   201,   224,   351,     8,   128,    47,
+     251,   129,   372,   318,  1167,   164,   139,   263,    61,     8,
+     345,   676,   348,   990,   417,  1034,     8,   141,   793,    47,
+     464,  1118,  1124,   196,   154,   370,    36,    37,  1147,   547,
+     501,   441,  1013,   308,  1132,   314,   250,    36,    37,    36,
+      37,   196,   337,   341,   379,     8,   317,   677,   718,  1113,
+     835,   294,   355,   179,   153,   179,     8,   197,   314,   309,
+     189,   885,  1007,     8,    38,   702,    38,  1151,    40,   343,
+      40,   364,   822,    72,    27,    28,    29,   352,   967,   410,
+     353,  1158,   161,  1153,    36,    37,   733,   388,   759,   335,
+     454,   955,   736,   148,  -302,     8,    36,    37,   982,   325,
+     164,   979,  1169,    36,    37,     8,   640,   794,  1095,  1175,
+     795,   299,   376,     8,   269,   270,   195,   371,   412,    47,
+     416,   419,   207,    38,   149,  1104,  -187,   166,   429,   371,
+      38,     8,    36,    37,    40,  1072,   171,  1080,  1073,  1114,
+     174,   615,  1115,    36,    37,   451,   427,   458,   170,   169,
+      36,    37,   507,   508,   970,   377,   513,  -302,   380,    38,
+     254,  1055,   153,   166,   169,   234,     8,   195,   440,   586,
+      47,   593,   511,    47,   972,   512,  1103,   480,  1000,   179,
+    1134,   983,    36,    37,   170,   222,   337,   341,   705,  -187,
+     355,   320,    36,    37,    47,     8,  1168,   400,     8,   371,
+      36,    37,    47,   333,   446,   371,    47,   153,   346,    38,
+    -262,   394,   687,    40,   395,   558,   321,   322,    36,    37,
+     146,   164,   572,   986,   150,   582,   347,   537,   540,  1196,
+     303,   238,   161,   703,  1183,   406,     8,   151,   238,   147,
+     670,   162,   870,   423,   428,    38,   153,   163,  -587,    40,
+     164,   321,   322,    36,    37,  1184,   163,   546,   179,   715,
+     550,   195,  1200,   748,   762,   157,   868,  1003,    47,   165,
+     335,     8,   158,  1004,     8,   507,   508,   513,   165,     6,
+      38,     8,    36,    37,    40,    36,    37,    27,    28,    29,
+     629,    47,   639,   688,     8,   152,   689,   411,   843,   349,
+    1059,   717,  1130,  1069,    47,   335,   591,    47,  1131,    38,
+     844,   193,    38,   166,   603,   604,    40,   350,   628,   670,
+      47,   184,   167,    36,    37,   168,   849,   614,   187,   618,
+     153,   161,   169,   614,   170,   169,   188,   627,   442,   723,
+     162,    27,    28,    29,   194,   528,   185,   609,   531,   164,
+      38,   850,   199,   609,    40,   698,   347,   195,    36,    37,
+     206,    36,    37,   434,    30,    31,   435,   605,    36,    37,
+     606,  -438,   624,   169,  -438,  -632,   294,   888,   337,   341,
+     355,    36,    37,    33,    34,    38,   537,   540,   743,    40,
+    1111,     8,   744,   524,  1015,   355,   807,   699,   269,   359,
+      47,   238,   218,   213,   214,  -438,  -632,   219,    38,   559,
+      47,   525,   166,   410,   737,   671,   691,   738,   889,   890,
+     625,   167,   891,   208,   168,   383,   384,   347,   440,   946,
+     364,   169,   153,   170,     6,   885,   299,   211,    27,    28,
+      29,   599,   212,   581,   385,   957,   958,   696,   215,   107,
+     310,   619,   412,   145,   217,     6,   145,   108,   771,   136,
+     153,   347,   416,   137,   873,   799,   727,   216,   164,   144,
+     109,   712,   735,   195,  -601,  -601,   171,    47,    36,    37,
+     174,   807,    47,   110,   749,  1185,   112,   427,   227,   113,
+     230,  1192,  1193,  1194,   756,   241,   138,   242,   116,   195,
+    -601,   179,   781,   965,   966,    38,   458,    47,  1199,    40,
+     442,   665,   118,   442,   666,   442,   667,    47,   673,   179,
+     244,   231,   480,   678,   232,   357,    47,   233,   347,   361,
+     335,   347,   120,   347,   121,   401,   792,   944,   944,    47,
+     321,   322,   123,   691,    47,   524,   810,    47,   371,   124,
+      47,   125,   524,   961,   944,   944,   362,   126,   709,   841,
+     413,   127,   772,   525,   546,   773,   128,   565,   566,   129,
+     525,   251,  1186,   407,   139,  1187,   364,   546,   107,   414,
+     741,   609,   145,   609,  1188,   141,   108,   601,   136,   432,
+    1189,   754,   137,  1190,   446,   602,   603,   604,   144,   109,
+     614,   459,  1191,   325,   303,   462,   723,   250,   614,   107,
+     481,  1088,   110,   145,  1089,   112,   477,   108,   113,   136,
+     609,   942,   478,   137,   509,   138,   502,   116,   609,   144,
+     109,   510,   145,   591,   159,     6,   171,   614,   859,  1031,
+     174,   118,   860,   110,   584,   585,   112,   428,   865,   113,
+     876,   832,   833,   882,   614,   980,   138,   609,   116,    47,
+     251,   120,   940,   121,   179,   945,   945,   515,   238,   516,
+     877,   123,   118,  1125,   609,   861,  1126,   519,   124,   179,
+     125,  1062,   945,   945,  1063,   252,   126,   265,   169,   995,
+     127,   792,   120,   267,   121,   128,   250,    47,   129,   548,
+     823,  1198,   123,   139,     1,     2,     3,   541,   940,   124,
+     551,   125,   603,   604,   141,   557,   614,   126,    68,    47,
+     561,   127,    27,    28,    29,   563,   128,   609,   564,   129,
+    -632,  1043,   308,   568,   139,  1084,   609,   569,   846,   570,
+     576,   856,  1039,   571,   107,   141,   577,   609,   145,   258,
+     294,   578,   108,  1002,   136,   497,   498,   499,   137,   579,
+     871,  1097,   583,   995,   144,   109,  1019,   267,   495,   496,
+     497,   498,   499,   781,   877,    80,    81,    82,   110,   589,
+      84,   112,    86,    87,   113,   587,   145,    47,   588,   195,
+     411,   138,   592,   116,   594,  1105,   278,   279,   280,   281,
+     282,   283,   284,   285,  1052,   595,   598,   118,   600,   616,
+     299,   940,   894,   895,   896,  1065,   623,   857,  1067,   630,
+     631,   638,   641,   661,  1045,     8,   662,   120,   969,   121,
+     378,   664,   668,   681,   683,   693,   701,   123,   708,   726,
+     710,    47,   739,   732,   124,   711,   125,   179,     8,   729,
+     747,   740,   126,   751,   614,   760,   127,   764,   761,   765,
+      68,   128,   440,   768,   129,   409,   769,   774,   777,   139,
+     785,   351,   429,   786,   609,   798,   802,   803,   454,   804,
+     141,   179,  1014,   734,   805,   440,     8,   809,   882,   812,
+     427,   447,   882,   453,   542,    27,    28,    29,   817,   825,
+     614,   826,  1093,   781,   940,   877,   410,  1197,     8,   877,
+     325,   195,    36,    37,   827,   829,   831,    80,    81,    82,
+     609,   940,    84,   333,    86,    87,   847,   838,   848,   852,
+     853,   867,   334,   854,    72,    36,    37,   893,   614,    38,
+     941,   164,   951,    40,   874,   412,   381,   952,   954,   959,
+      47,   960,   443,   964,   975,   444,   981,   883,   609,   614,
+     882,    47,    38,   977,   335,   997,    40,    27,    28,    29,
+     179,   991,   884,    36,    37,   543,   940,   877,   544,   609,
+     998,   614,  1011,  1016,  1025,  1045,  1017,   335,  1026,  1029,
+    1032,  1182,  1033,  -203,   177,    36,    37,     8,   601,   614,
+      38,   609,  1071,   179,    40,  1042,   602,   603,   604,  1027,
+    1028,   321,   322,  1093,  1046,  1049,  1050,   179,  1051,   609,
+    1054,  1060,   833,  1053,  1061,   335,    47,   156,   614,  1064,
+    1082,  1083,   178,  1091,   440,  1098,  -260,   614,  1077,   182,
+    -259,   614,  -261,   542,  1102,  -258,  1106,   605,   609,  1107,
+     606,   940,   614,  1108,  1110,  1112,    47,   609,   614,   614,
+     614,   609,  1119,  1127,  1128,  1129,  1135,  1117,  1141,  1144,
+    1139,    47,   609,   223,   226,   614,   613,  1142,   609,   609,
+     609,  1145,   621,     8,    36,    37,   253,  1148,  1150,  1155,
+    1157,  1161,  1165,    47,  1172,   609,  1170,  1136,  1178,  1179,
+    1180,  1195,    47,    47,    47,  1201,   704,   261,   315,  1004,
+    1202,    38,  1143,   742,   858,    40,   342,  1066,  1160,   753,
+     310,     8,  1030,    47,   543,   155,   866,   544,   988,     8,
+     863,   864,   800,   642,  1156,   268,   335,  1140,   164,   181,
+       8,   767,   669,  1162,  1163,  1164,   316,   319,  1076,  1006,
+    1075,  1154,   338,   338,   783,   344,  1021,  1094,   333,  1166,
+     845,  1152,   356,     0,  1181,     0,   161,   339,  -632,     0,
+      36,    37,   360,     0,     8,   162,   164,   161,     0,     0,
+       0,   163,   253,     0,   164,   177,   162,     0,   261,     0,
+       0,     0,   720,     0,     0,   164,   728,    38,     0,   409,
+       0,    40,   436,   165,     0,     0,     0,   396,    36,    37,
+     511,   317,     0,   512,   973,     0,    36,    37,     0,     0,
+     162,   669,   757,   178,     0,     0,     0,    36,    37,     0,
+       0,  -632,     0,     0,   430,    38,     0,   431,     8,    40,
+     438,   338,   338,    38,     0,   445,   177,   166,     0,   448,
+     156,   261,   457,  -632,    38,     0,   167,   505,   166,   168,
+     335,    36,    37,     0,   436,     0,   169,   167,   170,     0,
+     168,     0,     0,     0,     0,   333,     0,   169,     0,   170,
+     520,     0,     0,     0,   178,     0,     0,     0,    38,     0,
+     527,     8,   166,   164,     0,   506,   319,   319,   806,     0,
+     514,   256,   438,     0,   257,   205,     0,   486,     0,     0,
+       0,   169,     0,   170,     0,     0,     0,     0,   521,   338,
+     523,     0,   225,     0,   338,    36,    37,     0,   161,   493,
+     494,   495,   496,   497,   498,   499,   338,   338,   338,     0,
+       0,     0,   338,     0,     0,     0,   164,     0,     0,   830,
+       0,     0,    38,   836,   552,   553,    40,   837,     8,     0,
+       0,     0,   482,   483,     0,   511,   486,     0,   512,     8,
+       0,     0,   562,     0,     0,     0,     0,   335,    36,    37,
+       0,     0,     0,   806,     0,   574,   869,   596,   493,   494,
+     495,   496,   497,   498,   499,   333,     0,     0,     0,   436,
+       0,     0,     0,   886,   535,    38,   333,     0,     0,   166,
+       0,     0,   637,   164,     0,   538,     0,     0,     0,   319,
+     319,   319,     0,     0,   164,   597,     0,   366,   338,   338,
+     170,   338,   366,   366,     0,     0,     0,   620,     0,   366,
+       0,   389,   390,     0,   366,    36,    37,   493,   494,   495,
+     496,   497,   498,   499,     0,     0,    36,    37,     8,   974,
+     402,     0,   177,   366,   405,   976,     0,     0,   978,     0,
+     198,     0,    38,     0,   366,     0,    40,     0,     8,   715,
+       0,   195,     0,    38,     0,     0,     0,    40,   437,     0,
+     663,   366,     0,     0,   235,   440,     0,   335,   450,   243,
+     178,     0,   460,     0,   334,   675,     0,     0,   335,     0,
+       0,     0,     0,     0,     0,   317,  1020,     0,   716,   177,
+     338,   717,     8,   338,   162,     8,   338,   338,     0,   338,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   177,     0,     0,     0,    36,    37,     0,     0,     0,
+     261,     0,     0,     0,   261,     0,     0,   178,     0,   440,
+       0,     0,   440,     0,     0,    36,    37,     0,   339,   329,
+     331,   535,    38,     0,     0,     0,    40,     0,     0,   178,
+     261,   338,     0,   342,     0,   338,   177,     0,     8,     0,
+       0,   718,    38,     0,   368,     0,   166,   335,     8,   368,
+     368,   195,  1058,  1056,     0,   256,   368,     0,   257,    36,
+      37,   368,    36,    37,   784,   169,     0,   170,   177,     0,
+     447,     0,   453,     0,   178,   440,     0,     0,     0,     0,
+     368,     0,     0,     0,   687,   317,    38,     0,  1079,    38,
+      40,   368,   422,    40,   162,     0,     0,     0,     0,  1090,
+       0,     0,     0,     0,   433,   368,   178,     0,   368,  1101,
+       0,   335,   338,     0,   335,     0,     0,     0,     0,     0,
+       0,     0,   338,     0,   338,    36,    37,     0,   338,   338,
+       0,     0,    27,    28,    29,    36,    37,  1109,     0,     0,
+       0,   465,   409,   471,   472,   473,   474,   475,   476,     0,
+       0,     0,    38,   177,     0,     0,    40,     0,  1123,     0,
+       8,   261,    38,   601,     0,   688,   166,     8,   689,     0,
+       0,   602,   603,   604,     0,   256,     0,   335,   257,   517,
+    1137,     0,     8,     0,     8,   169,   855,   170,   342,   527,
+       0,   178,     0,     0,   338,     0,   177,   317,  1149,   340,
+    1057,     0,   530,   253,   440,   533,   162,     0,   354,     0,
+       0,     0,   605,   538,     0,   606,  1101,     0,     0,   317,
+       0,   440,  1078,     0,     0,     0,     0,   886,   162,     0,
+     694,     0,     0,     0,   178,     0,  1174,     0,   366,     0,
+       0,     0,     0,     0,     0,     0,     0,    36,    37,   366,
+       0,     0,   338,   338,    36,    37,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   745,   261,   366,    36,
+      37,    36,    37,     0,    38,     0,   261,     0,   166,     0,
+       0,    38,     0,     0,     0,    40,     0,   256,   340,     0,
+     257,   354,   253,     0,     0,     0,    38,   169,    38,   170,
+     166,     0,    40,     0,     0,     0,   335,     0,     0,   256,
+       0,     0,   257,     0,     0,     0,     0,     0,     0,   169,
+       8,   170,     0,   335,   261,     0,     0,     0,     0,     0,
+       0,     0,  1022,     0,     0,     0,     0,   643,   644,   645,
+     646,   647,   648,   649,   650,   651,   652,   653,   654,   655,
+     656,   657,   658,   659,   660,     0,     0,   317,     0,     0,
+    1099,     0,     0,     0,     0,   522,   162,     8,     0,     0,
+     526,   672,     0,     0,  1040,     0,     0,     0,     0,     0,
+     680,     0,   534,   536,   539,     0,     0,     0,   545,     0,
+       0,     0,     0,   482,   483,   484,   485,   486,     0,     0,
+       0,   700,     0,     0,   255,   368,   706,    36,    37,     0,
+     261,     0,     0,   162,   714,   721,   724,     0,   842,   493,
+     494,   495,   496,   497,   498,   499,     8,     0,   261,     0,
+     261,     0,     0,     0,    38,   368,     0,   721,   166,     0,
+       0,     0,     0,     0,     0,   758,   261,   256,     0,     0,
+     257,     0,  1087,     0,    36,    37,     0,   169,     0,   170,
+       0,     0,   177,   440,  1116,   436,     0,   261,     0,     0,
+       0,     0,   818,     8,   536,   539,     0,   545,     0,     0,
+       0,    38,     0,     0,     0,   166,     0,   787,   788,   650,
+     653,   660,     0,   796,   256,     0,     0,   257,     0,     0,
+     178,     0,     8,   620,   169,     0,   170,     0,   366,   366,
+     317,     0,     0,    36,    37,     0,   366,     0,     0,   162,
+       8,     0,     0,   195,     0,     0,     0,     0,     0,  1133,
+       0,   984,   985,   987,     0,     0,     0,     0,     0,   452,
+      38,     0,     0,     0,    40,     0,     0,     0,   162,     0,
+       0,   674,     0,     0,     0,     8,     0,     0,     0,     0,
+      36,    37,  1010,  1087,     0,   335,   685,     0,     0,   686,
+       0,     0,   690,   692,   261,   695,   721,     0,     0,     0,
+       0,     0,     0,     0,   840,     0,   721,    38,     0,    36,
+      37,   166,  1068,     0,     0,     0,     0,     0,     0,     0,
+     256,   162,     0,   257,     0,     0,     0,    36,    37,     0,
+     169,     0,   170,     0,     0,     0,    38,   872,     0,     0,
+     166,     0,     0,   321,   322,     0,     0,   674,     0,   256,
+       0,   690,   257,     0,    38,     0,     0,     0,    40,   169,
+       0,   170,    36,    37,   948,   949,   474,   434,   950,     0,
+     435,   467,     0,     0,   195,   275,   956,   169,     0,   276,
+     277,   278,   279,   280,   281,   282,   283,   284,   285,    38,
+       0,     0,     0,   166,     0,   368,   368,     0,     0,     0,
+     721,   971,   256,   368,     0,   257,     0,     0,   468,     0,
+    1010,     0,   169,     0,   170,     0,     0,   469,     0,     0,
+       0,     0,     0,     0,   287,     0,   840,     0,   811,     0,
+       0,     0,     0,     0,   899,     0,  -632,    64,   816,     0,
+     819,    65,    66,    67,   820,   821,     0,     0,     0,     0,
+       0,     0,     0,     0,    68,  -632,  -632,  -632,  -632,  -632,
+    -632,  -632,  -632,  -632,  -632,  -632,  -632,     0,  -632,  -632,
+    -632,  -632,  -632,     0,     0,     0,   900,    70,     0,     0,
+    -632,     0,     0,  -632,  -632,  -632,  -632,  -632,     0,     0,
+       0,     0,     0,     0,     0,     0,    72,    73,    74,    75,
+     901,    77,    78,    79,  -632,  -632,  -632,   902,   903,   904,
+     811,    80,   905,    82,     0,    83,    84,    85,    86,    87,
+    -632,  -632,     0,  -632,  -632,    88,  1047,  1048,     0,    92,
+       0,    94,    95,    96,    97,    98,    99,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   721,     0,   100,     0,
+    -632,     0,     0,   101,  -632,  -632,     0,     0,     0,   906,
+       0,     0,     0,     0,     0,     0,     0,     0,   962,   963,
+     274,     0,     0,   195,   275,   907,     0,     0,   276,   277,
+     278,   279,   280,   281,   282,   283,   284,   285,     0,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,     0,    21,    22,    23,    24,    25,   286,     0,     0,
+       0,     0,     0,     0,     0,     0,    26,    27,    28,    29,
+      30,    31,     0,   287,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    32,    33,
+      34,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,  1122,     8,    35,     0,   195,    36,    37,     0,
+       0,     0,     0,   278,   279,   280,   281,   282,   283,   284,
+     285,     0,     0,     0,     0,     0,     0,  1138,     0,     0,
+       0,     0,     0,     0,    38,     0,     0,    39,    40,     0,
+       0,     0,     0,    41,     0,     0,     0,     0,     0,     0,
+     288,     0,   274,   289,   290,   195,   275,   291,   292,   293,
+     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
+       0,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,     0,    21,    22,    23,    24,    25,   286,
+      36,    37,   801,     0,     0,     0,     0,     0,     0,    27,
+      28,    29,    30,    31,     0,   287,   321,   322,   328,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      32,    33,    34,   482,   483,   484,   485,   486,     0,   487,
+       0,   482,   483,   484,   485,   486,    35,     0,     0,    36,
+      37,     0,     0,     0,   488,   489,   490,   491,   492,   493,
+     494,   495,   496,   497,   498,   499,   492,   493,   494,   495,
+     496,   497,   498,   499,     0,     0,    38,     0,     0,     0,
+      40,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   288,     0,   274,   289,   290,   195,   275,   291,
+     292,   293,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,     0,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,     0,    21,    22,    23,    24,
+      25,   286,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    27,    28,    29,    30,    31,     0,   287,     0,     0,
+     529,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    32,    33,    34,   482,   483,   484,   485,   486,
+       0,   487,     0,     0,     0,     0,     0,     0,    35,     0,
+       0,    36,    37,     0,     0,     0,   488,   489,   490,   491,
+     492,   493,   494,   495,   496,   497,   498,   499,     0,     0,
+       9,    10,    11,    12,    13,    14,    15,    16,    38,    18,
+       0,    20,    40,     0,    22,    23,    24,    25,     0,     0,
+       0,     0,     0,     0,   288,     0,   274,   289,   290,   195,
+     275,   291,   292,   293,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,     0,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,     0,    21,    22,
+      23,    24,    25,   286,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    27,    28,    29,    30,    31,     0,   287,
+       0,     0,   532,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    32,    33,    34,   482,   483,   484,
+     485,   486,     0,     0,     0,     0,     0,     0,     0,     0,
+      35,     0,     0,    36,    37,     0,     0,     0,   488,   489,
+     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      38,     0,     0,     0,    40,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   288,     0,   274,   289,
+     290,   195,   275,   291,   292,   293,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,     0,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,     0,
+      21,    22,    23,    24,    25,   286,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    27,    28,    29,    30,    31,
+       0,   287,     0,     0,   679,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    32,    33,    34,   482,
+     483,   484,   485,   486,     0,     0,     0,     0,     0,     0,
+       0,     0,    35,     0,     0,    36,    37,     0,     0,     0,
+       0,   489,   490,   491,   492,   493,   494,   495,   496,   497,
+     498,   499,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    38,     0,     0,     0,    40,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   288,     0,
+     274,   289,   290,   195,   275,   291,   292,   293,   276,   277,
+     278,   279,   280,   281,   282,   283,   284,   285,     0,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,     0,    21,    22,    23,    24,    25,   286,   789,     0,
+       0,     0,     0,     0,     0,     0,     0,    27,    28,    29,
+      30,    31,     0,   287,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    32,    33,
+      34,   482,   483,   484,   485,   486,     0,     0,     0,     0,
+       0,     0,     0,     0,    35,     0,     0,    36,    37,     0,
+       0,     0,     0,     0,   490,   491,   492,   493,   494,   495,
+     496,   497,   498,   499,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    38,     0,     0,     0,    40,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     288,     0,   274,   289,   290,   195,   275,   291,   292,   293,
+     276,   277,   278,   279,   280,   281,   282,   283,   284,   285,
+       0,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,     0,    21,    22,    23,    24,    25,   286,
+     790,     0,     0,     0,     0,     0,     0,     0,     0,    27,
+      28,    29,    30,    31,     0,   287,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      32,    33,    34,   482,   483,   484,   485,   486,     0,     0,
+       0,     0,     0,     0,     0,     0,    35,     0,     0,    36,
+      37,     0,     0,     0,     0,     0,     0,   491,   492,   493,
+     494,   495,   496,   497,   498,   499,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    38,     0,     0,     0,
+      40,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   288,     0,   274,   289,   290,   195,   275,   291,
+     292,   293,   276,   277,   278,   279,   280,   281,   282,   283,
+     284,   285,     0,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,     0,    21,    22,    23,    24,
+      25,   286,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    27,    28,    29,    30,    31,     0,   287,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    32,    33,    34,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    35,     0,
+       0,    36,    37,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    38,     0,
+       0,     0,    40,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   288,     0,   274,   289,   290,   195,
+     275,   291,   292,   293,   276,   277,   278,   279,   280,   281,
+     282,   283,   284,   285,     0,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,     0,    21,    22,
+      23,    24,    25,   286,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    27,    28,    29,    30,    31,     0,   287,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    32,    33,    34,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    64,
+      35,     0,     0,    36,    37,    67,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    68,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      38,     0,     0,     0,    40,     0,     0,     0,   900,    70,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   289,
+     290,     0,     0,   791,   292,   293,     0,     0,    72,    73,
+      74,    75,     0,    77,    78,    79,     0,     0,     0,   902,
+     903,   904,     0,    80,   905,    82,     0,    83,    84,    85,
+      86,    87,     0,     0,     0,     0,     0,    88,     0,     0,
+       0,    92,     0,    94,    95,    96,    97,    98,    99,     8,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     100,     0,     0,     0,     0,   101,     0,     0,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+       0,    21,    22,    23,    24,    25,   310,   907,     0,     0,
+       0,     0,     0,     0,     0,    26,    27,    28,    29,    30,
+      31,     0,     0,     0,   164,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    32,    33,    34,
+       0,     0,     0,     0,     0,     8,     0,     0,     0,     0,
+       0,     0,     0,    35,     0,     0,    36,    37,     0,     0,
+       0,     0,     0,     0,     9,    10,    11,    12,    13,    14,
+      15,    16,   245,    18,   246,    20,     0,   247,    22,    23,
+      24,    25,     0,    38,     0,     0,    39,    40,     8,     0,
+       0,     0,    41,     0,     0,     0,   311,   632,     0,   312,
+       0,     0,     0,     0,     0,     0,   169,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,     0,
+      21,    22,    23,    24,    25,   310,     0,     0,     0,    35,
+       0,     0,    36,    37,    26,    27,    28,    29,    30,    31,
+       0,     0,     0,   164,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    32,    33,    34,    38,
+       0,   633,     0,    40,   482,   483,   484,   485,   486,     0,
+     487,     0,    35,     0,     0,    36,    37,     0,     0,     0,
+       0,     0,     0,     0,     0,   488,   634,   490,   491,   635,
+     493,   494,   495,   496,   497,   498,   636,     0,     0,     0,
+       0,     0,    38,     0,     0,    39,    40,     8,     0,     0,
+       0,    41,     0,     0,     0,   503,     0,     0,   504,     0,
+       0,     0,     0,     0,     0,   169,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,     0,    21,
+      22,    23,    24,    25,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    26,    27,    28,    29,    30,    31,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    32,    33,    34,     8,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    35,     0,     0,    36,    37,     0,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,     0,
+      21,    22,    23,    24,    25,     0,     0,     0,     0,     0,
+       0,    38,     0,     0,    39,    40,     0,     0,    30,    31,
+      41,     0,     0,     0,   434,     0,     0,   435,     0,     0,
+       0,     0,     0,     0,   169,     0,    32,    33,    34,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    35,     0,     0,    36,    37,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    -2,    63,     0,  -632,    64,     0,     0,     0,    65,
+      66,    67,    38,     0,     0,     0,    40,     0,     0,     0,
+       0,     0,    68,  -632,  -632,  -632,  -632,  -632,  -632,  -632,
+    -632,  -632,  -632,  -632,  -632,   169,  -632,  -632,  -632,  -632,
+    -632,     0,     0,     0,    69,    70,     0,     0,     0,     0,
+       0,  -632,  -632,  -632,  -632,  -632,     0,     0,    71,     0,
+       0,     0,     0,     0,    72,    73,    74,    75,    76,    77,
+      78,    79,  -632,  -632,  -632,     0,     0,     0,     0,    80,
+      81,    82,     0,    83,    84,    85,    86,    87,  -632,  -632,
+       0,  -632,  -632,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   100,    63,  -632,  -632,
+      64,   101,  -632,     0,    65,    66,    67,   102,   103,     0,
+       0,     0,     0,     0,     0,     0,     0,    68,  -632,  -632,
+    -632,  -632,  -632,  -632,  -632,  -632,  -632,  -632,  -632,  -632,
+       0,  -632,  -632,  -632,  -632,  -632,     0,     0,     0,    69,
+      70,     0,     0,   731,     0,     0,  -632,  -632,  -632,  -632,
+    -632,     0,     0,    71,     0,     0,     0,     0,     0,    72,
+      73,    74,    75,    76,    77,    78,    79,  -632,  -632,  -632,
+       0,     0,     0,     0,    80,    81,    82,     0,    83,    84,
+      85,    86,    87,  -632,  -632,     0,  -632,  -632,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   100,    63,  -632,  -632,    64,   101,  -632,     0,    65,
+      66,    67,   102,   103,     0,     0,     0,     0,     0,     0,
+       0,     0,    68,  -632,  -632,  -632,  -632,  -632,  -632,  -632,
+    -632,  -632,  -632,  -632,  -632,     0,  -632,  -632,  -632,  -632,
+    -632,     0,     0,     0,    69,    70,     0,     0,   824,     0,
+       0,  -632,  -632,  -632,  -632,  -632,     0,     0,    71,     0,
+       0,     0,     0,     0,    72,    73,    74,    75,    76,    77,
+      78,    79,  -632,  -632,  -632,     0,     0,     0,     0,    80,
+      81,    82,     0,    83,    84,    85,    86,    87,  -632,  -632,
+       0,  -632,  -632,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   100,    63,  -632,  -632,
+      64,   101,  -632,     0,    65,    66,    67,   102,   103,     0,
+       0,     0,     0,     0,     0,     0,     0,    68,  -632,  -632,
+    -632,  -632,  -632,  -632,  -632,  -632,  -632,  -632,  -632,  -632,
+       0,  -632,  -632,  -632,  -632,  -632,     0,     0,     0,    69,
+      70,     0,     0,   839,     0,     0,  -632,  -632,  -632,  -632,
+    -632,     0,     0,    71,     0,     0,     0,     0,     0,    72,
+      73,    74,    75,    76,    77,    78,    79,  -632,  -632,  -632,
+       0,     0,     0,     0,    80,    81,    82,     0,    83,    84,
+      85,    86,    87,  -632,  -632,     0,  -632,  -632,    88,    89,
+      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   100,    63,  -632,  -632,    64,   101,  -632,     0,    65,
+      66,    67,   102,   103,     0,     0,     0,     0,     0,     0,
+       0,     0,    68,  -632,  -632,  -632,  -632,  -632,  -632,  -632,
+    -632,  -632,  -632,  -632,  -632,     0,  -632,  -632,  -632,  -632,
+    -632,     0,     0,     0,    69,    70,     0,     0,     0,     0,
+       0,  -632,  -632,  -632,  -632,  -632,     0,     0,    71,     0,
+       0,     0,   996,     0,    72,    73,    74,    75,    76,    77,
+      78,    79,  -632,  -632,  -632,     0,     0,     0,     0,    80,
+      81,    82,     0,    83,    84,    85,    86,    87,  -632,  -632,
+       0,  -632,  -632,    88,    89,    90,    91,    92,    93,    94,
+      95,    96,    97,    98,    99,     0,     0,     0,     7,     0,
+       8,     0,     0,     0,     0,     0,   100,     0,  -632,     0,
+       0,   101,  -632,     0,     0,     0,     0,   102,   103,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,     0,    21,    22,    23,    24,    25,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    26,    27,    28,    29,
+      30,    31,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    32,    33,
+      34,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    35,     0,     0,    36,    37,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    58,     0,     8,     0,     0,     0,   947,
+       0,     0,     0,     0,    38,     0,     0,    39,    40,     0,
+       0,     0,     0,    41,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,     0,    21,    22,    23,
+      24,    25,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    26,    27,    28,    29,    30,    31,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    32,    33,    34,   482,   483,   484,   485,
+     486,     0,   487,     0,     0,     0,     0,     0,     0,    35,
+       0,     0,    36,    37,     0,     0,     0,   488,   489,   490,
+     491,   492,   493,   494,   495,   496,   497,   498,   499,     0,
+       8,     0,     0,     0,   953,     0,     0,     0,     0,    38,
+       0,     0,    39,    40,     0,     0,     0,     0,    41,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,     0,    21,    22,    23,    24,    25,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    26,    27,    28,    29,
+      30,    31,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    32,    33,
+      34,   482,   483,   484,   485,   486,     0,   487,     0,     0,
+       0,     0,     0,     0,    35,     0,     0,    36,    37,     0,
+       0,     0,   488,   489,   490,   491,   492,   493,   494,   495,
+     496,   497,   498,   499,     0,     0,     8,     0,     0,     0,
+     999,     0,     0,     0,    38,     0,   392,    39,    40,     0,
+       0,     0,     0,    41,   549,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,     0,    21,    22,
+      23,    24,    25,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    26,    27,    28,    29,    30,    31,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    32,    33,    34,   482,   483,   484,
+     485,   486,     0,   487,     0,     0,     0,     0,     0,     0,
+      35,     0,     0,    36,    37,     0,     0,     0,   488,   489,
+     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
+       0,     8,     0,     0,     0,     0,     0,     0,     0,     0,
+      38,     0,     0,    39,    40,     0,     0,     0,     0,    41,
+       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,     0,    21,    22,    23,    24,    25,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    26,    27,    28,
+      29,    30,    31,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    32,
+      33,    34,     0,     0,     0,     0,   202,     0,     8,     0,
+       0,     0,     0,     0,     0,    35,     0,     0,    36,    37,
+       0,     0,     0,     0,     0,     0,     0,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,     0,
+      21,    22,    23,    24,    25,    38,     0,     0,    39,    40,
+       0,     0,     0,     0,    41,    27,    28,    29,    30,    31,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    32,    33,    34,     0,
+       8,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    35,     0,     0,    36,    37,     0,     0,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,     0,    21,    22,    23,    24,    25,     0,     0,     0,
+       0,     0,    38,     0,     0,     0,    40,    27,    28,    29,
+      30,    31,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    32,    33,
+      34,     0,     0,     8,     0,     0,     0,     0,     0,  1159,
+       0,     0,     0,     0,    35,   993,     0,    36,    37,     0,
+       0,     0,     9,    10,    11,    12,    13,    14,    15,    16,
+    1035,    18,  1036,    20,     0,  1037,    22,    23,    24,    25,
+       0,     0,     0,     0,    38,     0,     0,     0,    40,   994,
+      27,    28,    29,    30,    31,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    32,    33,    34,   482,   483,   484,   485,   486,     0,
+     487,     0,     0,     0,     0,     0,     0,    35,   264,     0,
+      36,    37,     0,     0,     0,   488,   489,   490,   491,   492,
+     493,   494,   495,   496,   497,   498,   499,     0,     0,     0,
+       0,     0,     0,     0,     0,   274,     0,    38,   195,   275,
+       0,    40,   994,   276,   277,   278,   279,   280,   281,   282,
+     283,   284,   285,     0,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,     0,    21,    22,    23,
+      24,    25,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    27,    28,    29,    30,    31,     0,   287,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    32,    33,    34,     0,     0,     8,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    35,
+       0,     0,    36,    37,     0,     0,     0,     9,    10,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,     0,
+      21,    22,    23,    24,    25,     0,     0,     0,     0,    38,
+       0,     0,     0,    40,    26,    27,    28,    29,    30,    31,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    32,    33,    34,     0,
+       8,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    35,     0,     0,    36,    37,     0,     0,     9,
+      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+      20,     0,    21,    22,    23,    24,    25,   236,     0,     0,
+       0,     0,    38,     0,     0,    39,    40,    27,    28,    29,
+      30,    31,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    32,    33,
+      34,     0,     8,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    35,     0,     0,    36,    37,     0,
+       0,     9,    10,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,     0,    21,    22,    23,    24,    25,     0,
+       0,     0,     0,     0,    38,     0,     0,     0,    40,    27,
+      28,    29,    30,    31,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      32,    33,    34,     0,     8,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    35,   264,     0,    36,
+      37,     0,     0,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,     0,    21,    22,    23,    24,
+      25,     0,     0,     0,     0,     0,    38,     0,     0,     0,
+      40,    27,    28,    29,    30,    31,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    32,    33,    34,     8,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    35,     0,
+       0,    36,    37,     0,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,     0,    21,    22,    23,
+      24,    25,     0,     0,     0,     0,     0,     0,    38,     0,
+       0,     0,    40,     0,     0,    30,    31,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    32,    33,    34,     8,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    35,
+       0,     0,    36,    37,     0,     9,    10,    11,    12,    13,
+      14,    15,    16,   245,    18,   246,    20,     0,   247,    22,
+      23,    24,    25,     0,     0,     0,     0,     0,     0,    38,
+       0,     0,     0,    40,     0,     0,    30,    31,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    33,    34,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      35,     0,     0,    36,    37,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     8,   248,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      38,     0,     0,     0,    40,     9,    10,    11,    12,    13,
+      14,    15,    16,   245,    18,   246,    20,     0,   247,    22,
+      23,    24,    25,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    30,    31,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    33,    34,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      35,     0,     0,    36,    37,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     8,   992,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      38,     0,     0,     0,    40,     9,    10,    11,    12,    13,
+      14,    15,    16,   245,    18,   246,    20,     0,   247,    22,
+      23,    24,    25,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   518,    30,    31,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    33,    34,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   682,     0,
+      35,     0,     0,    36,    37,     0,     0,     0,     0,     0,
+     684,     0,     0,     0,   482,   483,   484,   485,   486,     0,
+     487,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+      38,     0,     0,     0,    40,   488,   489,   490,   491,   492,
+     493,   494,   495,   496,   497,   498,   499,   482,   483,   484,
+     485,   486,   808,   487,     0,     0,     0,     0,     0,   482,
+     483,   484,   485,   486,   813,   487,     0,     0,   488,   489,
+     490,   491,   492,   493,   494,   495,   496,   497,   498,   499,
+     488,   489,   490,   491,   492,   493,   494,   495,   496,   497,
+     498,   499,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   482,   483,   484,   485,   486,     0,   487,     0,     0,
+       0,     0,     0,   482,   483,   484,   485,   486,     0,   487,
+       0,     0,   488,   489,   490,   491,   492,   493,   494,   495,
+     496,   497,   498,   499,   488,   489,   490,   491,   492,   493,
+     494,   495,   496,   497,   498,   499
+};
+
+static const yytype_int16 yycheck[] =
+{
+       0,     5,   163,   151,    47,     5,   161,    45,    47,     5,
+     380,     5,   144,   197,   607,     5,    72,   572,    40,     1,
+       2,     5,     5,   248,   101,   153,    95,   602,   230,   566,
+     399,   587,   828,   556,   725,     5,   184,   185,     5,    95,
+      96,     5,   407,   566,   286,   287,   550,    47,     5,   101,
+       5,   639,   681,   255,   683,    40,     4,    46,     6,     3,
+     101,   272,    21,     6,     5,  1001,    46,    42,    48,     4,
+       3,    71,     3,     3,  1012,    48,    76,    77,    44,     1,
+       2,     6,     6,   238,     5,    48,     5,   194,   144,     1,
+      41,     4,   144,   200,     5,    43,    43,    42,    46,   206,
+     152,     5,   130,     5,   211,   133,     0,    40,    55,     5,
+      55,    46,    78,     5,   114,    46,    49,     3,     5,    41,
+     197,     5,    46,   162,   113,    58,     5,    86,    40,     3,
+     173,    41,   175,    46,   241,   931,     3,     5,    41,    61,
+     113,  1070,  1080,    86,   166,   197,    90,    91,   133,   360,
+     113,   258,   127,   153,  1090,   310,   197,    90,    91,    90,
+      91,    86,   167,   168,   203,     3,    40,   118,   116,    40,
+     726,   153,   177,   173,   104,   175,     3,   120,   333,   159,
+      61,   774,   126,     3,   117,   554,   117,  1123,   121,   169,
+     121,   191,   696,    63,    50,    51,    52,   130,   827,   238,
+     133,  1137,    40,  1132,    90,    91,   575,   207,   118,   142,
+      77,   799,   577,    49,    42,     3,    90,    91,   847,   380,
+      58,    43,  1151,    90,    91,     3,   468,   130,  1024,  1158,
+     133,   153,     0,     3,   120,   121,     6,     6,   238,   161,
+     240,   241,    76,   117,    49,  1041,    42,   121,   248,     6,
+     117,     3,    90,    91,   121,    40,   299,   127,    43,   130,
+     299,    55,   133,    90,    91,   265,   248,   267,   142,   140,
+      90,    91,   311,   312,   830,    43,   315,   105,    55,   117,
+     114,   972,   104,   121,   140,     4,     3,     6,    40,    46,
+     212,    60,   130,   215,   831,   133,    43,   297,   873,   299,
+    1096,   121,    90,    91,   142,    93,   311,   312,   831,   105,
+     315,    46,    90,    91,   236,     3,  1149,    55,     3,     6,
+      90,    91,   244,    40,   118,     6,   248,   104,    40,   117,
+      77,   212,    49,   121,   215,   378,   106,   107,    90,    91,
+      53,    58,   398,   121,    40,   414,    58,   352,   353,  1182,
+     478,   407,    40,   555,  1168,   236,     3,   144,   414,    72,
+     515,    49,    43,   244,   589,   117,   104,    55,    55,   121,
+      58,   106,   107,    90,    91,  1171,    55,   357,   378,     4,
+     362,     6,  1196,   585,    40,   127,   755,    40,   310,    77,
+     142,     3,    43,    46,     3,   434,   435,   436,    77,   399,
+     117,     3,    90,    91,   121,    90,    91,    50,    51,    52,
+     462,   333,   468,   130,     3,   104,   133,   572,    43,    40,
+     976,    46,    40,   998,   346,   142,   426,   349,    46,   117,
+      55,   122,   117,   121,    90,    91,   121,    58,   460,   594,
+     362,   119,   130,    90,    91,   133,   119,   447,    43,   449,
+     104,    40,   140,   453,   142,   140,    43,   457,    40,   566,
+      49,    50,    51,    52,    40,   346,   144,   447,   349,    58,
+     117,   144,    40,   453,   121,     4,    58,     6,    90,    91,
+      40,    90,    91,   130,    53,    54,   133,   130,    90,    91,
+     133,    43,    43,   140,    46,    46,   478,     1,   503,   504,
+     505,    90,    91,    72,    73,   117,   511,   512,   117,   121,
+    1065,     3,   121,    40,   884,   520,   671,    46,   120,   121,
+     442,   577,    78,    85,    86,    77,    77,    83,   117,    40,
+     452,    58,   121,   572,    43,   515,   541,    46,    42,    43,
+      91,   130,    46,    40,   133,    53,    54,    58,    40,   786,
+     550,   140,   104,   142,   554,  1148,   478,    40,    50,    51,
+      52,   442,    40,    40,    72,   802,   803,   549,    40,   573,
+      40,   452,   572,   573,    40,   575,   576,   573,   616,   573,
+     104,    58,   582,   573,   768,   641,   568,    85,    58,   573,
+     573,     4,   576,     6,   118,   119,   639,   519,    90,    91,
+     639,   756,   524,   573,   586,  1172,   573,   589,    40,   573,
+      40,  1178,  1179,  1180,   594,    40,   573,    40,   573,     6,
+     144,   621,   622,   825,   826,   117,   626,   549,  1195,   121,
+      40,    41,   573,    40,    41,    40,    41,   559,   519,   639,
+      40,    40,   642,   524,    43,   118,   568,    46,    58,    41,
+     142,    58,   573,    58,   573,    46,   636,   785,   786,   581,
+     106,   107,   573,   668,   586,    40,    41,   589,     6,   573,
+     592,   573,    40,    41,   802,   803,    42,   573,   559,   735,
+      43,   573,    43,    58,   664,    46,   573,    41,    42,   573,
+      58,   768,    43,    46,   573,    46,   696,   677,   702,    42,
+     581,   681,   702,   683,    55,   573,   702,    81,   702,   133,
+      43,   592,   702,    46,   118,    89,    90,    91,   702,   702,
+     720,    41,    55,   884,   852,   105,   833,   768,   728,   733,
+      40,    43,   702,   733,    46,   702,   105,   733,   702,   733,
+     720,   784,    42,   733,    41,   702,     7,   702,   728,   733,
+     733,    41,   752,   753,   792,   755,   799,   757,   752,   907,
+     799,   702,   752,   733,    41,    42,   733,   992,   752,   733,
+     770,    41,    42,   773,   774,   844,   733,   757,   733,   701,
+     857,   702,   782,   702,   784,   785,   786,   118,   844,    58,
+     773,   702,   733,    43,   774,   752,    46,    40,   702,   799,
+     702,   984,   802,   803,   987,   857,   702,   939,   140,   865,
+     702,   791,   733,   865,   733,   702,   857,   739,   702,    43,
+     701,  1191,   733,   702,   123,   124,   125,   118,   828,   733,
+      41,   733,    90,    91,   702,    41,   836,   733,    21,   761,
+      41,   733,    50,    51,    52,    41,   733,   827,    55,   733,
+      41,    42,   852,    42,   733,  1016,   836,    41,   739,    41,
+      41,    44,   939,    43,   868,   733,    41,   847,   868,   122,
+     852,    41,   868,   873,   868,   138,   139,   140,   868,    41,
+     761,  1029,    41,   939,   868,   868,   886,   939,   136,   137,
+     138,   139,   140,   893,   877,    78,    79,    80,   868,    42,
+      83,   868,    85,    86,   868,    41,   906,   829,   105,     6,
+    1065,   868,    40,   868,   118,  1043,    13,    14,    15,    16,
+      17,    18,    19,    20,   967,    41,    43,   868,   118,    77,
+     852,   931,    74,    75,    76,   991,    46,   120,   994,     3,
+       3,   104,    40,     3,   944,     3,     3,   868,   829,   868,
+     203,   118,   118,    41,    41,    49,    40,   868,    43,    41,
+      43,   883,    40,    43,   868,    46,   868,   967,     3,    46,
+      43,    47,   868,    92,   974,    41,   868,    91,    40,    90,
+      21,   868,    40,   113,   868,   238,    58,    41,    79,   868,
+      40,    49,   992,    40,   974,    41,    40,    40,    77,    41,
+     868,  1001,   883,    44,    41,    40,     3,    41,  1008,    41,
+     992,   264,  1012,   266,    49,    50,    51,    52,    49,    42,
+    1020,    42,  1022,  1023,  1024,  1008,  1065,  1188,     3,  1012,
+    1191,     6,    90,    91,    41,    40,    55,    78,    79,    80,
+    1020,  1041,    83,    40,    85,    86,    41,    43,   144,   104,
+      41,    41,    49,    47,    63,    90,    91,    42,  1058,   117,
+      46,    58,    41,   121,   104,  1065,    41,    41,    41,    41,
+     992,    41,   130,    41,    41,   133,    41,    40,  1058,  1079,
+    1080,  1003,   117,    43,   142,    43,   121,    50,    51,    52,
+    1090,    55,    55,    90,    91,   130,  1096,  1080,   133,  1079,
+      41,  1101,    47,    55,    46,  1105,    77,   142,    77,   142,
+      47,  1167,   127,    47,    47,    90,    91,     3,    81,  1119,
+     117,  1101,  1003,  1123,   121,    41,    89,    90,    91,    77,
+      77,   106,   107,  1133,    41,    41,    41,  1137,    41,  1119,
+      41,    43,    42,    47,    43,   142,  1068,    42,  1148,   105,
+      41,    43,    47,    49,    40,    40,    77,  1157,    55,    54,
+      77,  1161,    77,    49,    77,    77,    43,   130,  1148,    43,
+     133,  1171,  1172,    43,    43,   105,  1098,  1157,  1178,  1179,
+    1180,  1161,    41,    43,    42,    49,    40,  1068,    43,    40,
+      47,  1113,  1172,    88,    89,  1195,   447,    43,  1178,  1179,
+    1180,    40,   453,     3,    90,    91,   101,    41,    43,    47,
+      41,    41,    40,  1135,    41,  1195,    49,  1098,    41,    41,
+      41,    41,  1144,  1145,  1146,    43,   556,   122,   161,    46,
+      43,   117,  1113,   582,   752,   121,   169,   992,  1139,   589,
+      40,     3,   906,  1165,   130,    41,   753,   133,   852,     3,
+     752,   752,   642,   478,  1135,   150,   142,  1105,    58,    52,
+       3,   609,   515,  1144,  1145,  1146,   161,   162,  1008,   877,
+    1007,  1133,   167,   168,   626,   170,   893,  1023,    40,  1148,
+     736,  1128,   177,    -1,  1165,    -1,    40,    49,    42,    -1,
+      90,    91,   185,    -1,     3,    49,    58,    40,    -1,    -1,
+      -1,    55,   197,    -1,    58,   238,    49,    -1,   203,    -1,
+      -1,    -1,   565,    -1,    -1,    58,   569,   117,    -1,   572,
+      -1,   121,   255,    77,    -1,    -1,    -1,   222,    90,    91,
+     130,    40,    -1,   133,    43,    -1,    90,    91,    -1,    -1,
+      49,   594,   595,   238,    -1,    -1,    -1,    90,    91,    -1,
+      -1,   105,    -1,    -1,   249,   117,    -1,   252,     3,   121,
+     255,   256,   257,   117,    -1,   260,   299,   121,    -1,   264,
+     265,   266,   267,   127,   117,    -1,   130,   310,   121,   133,
+     142,    90,    91,    -1,   317,    -1,   140,   130,   142,    -1,
+     133,    -1,    -1,    -1,    -1,    40,    -1,   140,    -1,   142,
+     333,    -1,    -1,    -1,   299,    -1,    -1,    -1,   117,    -1,
+     343,     3,   121,    58,    -1,   310,   311,   312,   671,    -1,
+     315,   130,   317,    -1,   133,    72,    -1,   112,    -1,    -1,
+      -1,   140,    -1,   142,    -1,    -1,    -1,    -1,   333,   334,
+     335,    -1,    89,    -1,   339,    90,    91,    -1,    40,   134,
+     135,   136,   137,   138,   139,   140,   351,   352,   353,    -1,
+      -1,    -1,   357,    -1,    -1,    -1,    58,    -1,    -1,   720,
+      -1,    -1,   117,   726,   369,   370,   121,   728,     3,    -1,
+      -1,    -1,   108,   109,    -1,   130,   112,    -1,   133,     3,
+      -1,    -1,   387,    -1,    -1,    -1,    -1,   142,    90,    91,
+      -1,    -1,    -1,   756,    -1,   400,   757,   440,   134,   135,
+     136,   137,   138,   139,   140,    40,    -1,    -1,    -1,   452,
+      -1,    -1,    -1,   774,    49,   117,    40,    -1,    -1,   121,
+      -1,    -1,   465,    58,    -1,    49,    -1,    -1,    -1,   434,
+     435,   436,    -1,    -1,    58,   440,    -1,   194,   443,   444,
+     142,   446,   199,   200,    -1,    -1,    -1,   452,    -1,   206,
+      -1,   208,   209,    -1,   211,    90,    91,   134,   135,   136,
+     137,   138,   139,   140,    -1,    -1,    90,    91,     3,   832,
+     227,    -1,   515,   230,   231,   836,    -1,    -1,   841,    -1,
+      70,    -1,   117,    -1,   241,    -1,   121,    -1,     3,     4,
+      -1,     6,    -1,   117,    -1,    -1,    -1,   121,   255,    -1,
+     505,   258,    -1,    -1,    94,    40,    -1,   142,   265,    99,
+     515,    -1,   269,    -1,    49,   520,    -1,    -1,   142,    -1,
+      -1,    -1,    -1,    -1,    -1,    40,   889,    -1,    43,   572,
+     535,    46,     3,   538,    49,     3,   541,   542,    -1,   544,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   594,    -1,    -1,    -1,    90,    91,    -1,    -1,    -1,
+     565,    -1,    -1,    -1,   569,    -1,    -1,   572,    -1,    40,
+      -1,    -1,    40,    -1,    -1,    90,    91,    -1,    49,   164,
+     165,    49,   117,    -1,    -1,    -1,   121,    -1,    -1,   594,
+     595,   596,    -1,   636,    -1,   600,   639,    -1,     3,    -1,
+      -1,   116,   117,    -1,   194,    -1,   121,   142,     3,   199,
+     200,     6,   975,   974,    -1,   130,   206,    -1,   133,    90,
+      91,   211,    90,    91,   629,   140,    -1,   142,   671,    -1,
+     993,    -1,   995,    -1,   639,    40,    -1,    -1,    -1,    -1,
+     230,    -1,    -1,    -1,    49,    40,   117,    -1,  1011,   117,
+     121,   241,   242,   121,    49,    -1,    -1,    -1,    -1,  1020,
+      -1,    -1,    -1,    -1,   254,   255,   671,    -1,   258,  1032,
+      -1,   142,   677,    -1,   142,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   687,    -1,   689,    90,    91,    -1,   693,   694,
+      -1,    -1,    50,    51,    52,    90,    91,  1058,    -1,    -1,
+      -1,   286,  1065,   288,   289,   290,   291,   292,   293,    -1,
+      -1,    -1,   117,   756,    -1,    -1,   121,    -1,  1079,    -1,
+       3,   726,   117,    81,    -1,   130,   121,     3,   133,    -1,
+      -1,    89,    90,    91,    -1,   130,    -1,   142,   133,   324,
+    1101,    -1,     3,    -1,     3,   140,   751,   142,   791,   792,
+      -1,   756,    -1,    -1,   759,    -1,   799,    40,  1119,   168,
+      43,    -1,   347,   768,    40,   350,    49,    -1,   177,    -1,
+      -1,    -1,   130,    49,    -1,   133,  1139,    -1,    -1,    40,
+      -1,    40,    43,    -1,    -1,    -1,    -1,  1148,    49,    -1,
+      49,    -1,    -1,    -1,   799,    -1,  1157,    -1,   555,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    91,   566,
+      -1,    -1,   817,   818,    90,    91,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   583,   832,   585,    90,
+      91,    90,    91,    -1,   117,    -1,   841,    -1,   121,    -1,
+      -1,   117,    -1,    -1,    -1,   121,    -1,   130,   257,    -1,
+     133,   260,   857,    -1,    -1,    -1,   117,   140,   117,   142,
+     121,    -1,   121,    -1,    -1,    -1,   142,    -1,    -1,   130,
+      -1,    -1,   133,    -1,    -1,    -1,    -1,    -1,    -1,   140,
+       3,   142,    -1,   142,   889,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   897,    -1,    -1,    -1,    -1,   482,   483,   484,
+     485,   486,   487,   488,   489,   490,   491,   492,   493,   494,
+     495,   496,   497,   498,   499,    -1,    -1,    40,    -1,    -1,
+      43,    -1,    -1,    -1,    -1,   334,    49,     3,    -1,    -1,
+     339,   516,    -1,    -1,   939,    -1,    -1,    -1,    -1,    -1,
+     525,    -1,   351,   352,   353,    -1,    -1,    -1,   357,    -1,
+      -1,    -1,    -1,   108,   109,   110,   111,   112,    -1,    -1,
+      -1,   551,    -1,    -1,    40,   555,   556,    90,    91,    -1,
+     975,    -1,    -1,    49,   564,   565,   566,    -1,   735,   134,
+     135,   136,   137,   138,   139,   140,     3,    -1,   993,    -1,
+     995,    -1,    -1,    -1,   117,   585,    -1,   587,   121,    -1,
+      -1,    -1,    -1,    -1,    -1,   595,  1011,   130,    -1,    -1,
+     133,    -1,  1017,    -1,    90,    91,    -1,   140,    -1,   142,
+      -1,    -1,  1065,    40,  1067,  1068,    -1,  1032,    -1,    -1,
+      -1,    -1,    49,     3,   443,   444,    -1,   446,    -1,    -1,
+      -1,   117,    -1,    -1,    -1,   121,    -1,   632,   633,   634,
+     635,   636,    -1,   638,   130,    -1,    -1,   133,    -1,    -1,
+    1065,    -1,     3,  1068,   140,    -1,   142,    -1,   825,   826,
+      40,    -1,    -1,    90,    91,    -1,   833,    -1,    -1,    49,
+       3,    -1,    -1,     6,    -1,    -1,    -1,    -1,    -1,  1094,
+      -1,   848,   849,   850,    -1,    -1,    -1,    -1,    -1,    40,
+     117,    -1,    -1,    -1,   121,    -1,    -1,    -1,    49,    -1,
+      -1,   520,    -1,    -1,    -1,     3,    -1,    -1,    -1,    -1,
+      90,    91,   879,  1128,    -1,   142,   535,    -1,    -1,   538,
+      -1,    -1,   541,   542,  1139,   544,   726,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   734,    -1,   736,   117,    -1,    90,
+      91,   121,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     130,    49,    -1,   133,    -1,    -1,    -1,    90,    91,    -1,
+     140,    -1,   142,    -1,    -1,    -1,   117,   762,    -1,    -1,
+     121,    -1,    -1,   106,   107,    -1,    -1,   596,    -1,   130,
+      -1,   600,   133,    -1,   117,    -1,    -1,    -1,   121,   140,
+      -1,   142,    90,    91,   789,   790,   791,   130,   793,    -1,
+     133,     3,    -1,    -1,     6,     7,   801,   140,    -1,    11,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,   117,
+      -1,    -1,    -1,   121,    -1,   825,   826,    -1,    -1,    -1,
+     830,   831,   130,   833,    -1,   133,    -1,    -1,    40,    -1,
+    1007,    -1,   140,    -1,   142,    -1,    -1,    49,    -1,    -1,
+      -1,    -1,    -1,    -1,    56,    -1,   856,    -1,   677,    -1,
+      -1,    -1,    -1,    -1,     1,    -1,     3,     4,   687,    -1,
+     689,     8,     9,    10,   693,   694,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    21,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    -1,    -1,    -1,    43,    44,    -1,    -1,
+      47,    -1,    -1,    50,    51,    52,    53,    54,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+     759,    78,    79,    80,    -1,    82,    83,    84,    85,    86,
+      87,    88,    -1,    90,    91,    92,   951,   952,    -1,    96,
+      -1,    98,    99,   100,   101,   102,   103,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   976,    -1,   115,    -1,
+     117,    -1,    -1,   120,   121,   122,    -1,    -1,    -1,   126,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   817,   818,
+       3,    -1,    -1,     6,     7,   142,    -1,    -1,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    -1,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    40,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    49,    50,    51,    52,
+      53,    54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    72,
+      73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,  1077,     3,    87,    -1,     6,    90,    91,    -1,
+      -1,    -1,    -1,    13,    14,    15,    16,    17,    18,    19,
+      20,    -1,    -1,    -1,    -1,    -1,    -1,  1102,    -1,    -1,
+      -1,    -1,    -1,    -1,   117,    -1,    -1,   120,   121,    -1,
+      -1,    -1,    -1,   126,    -1,    -1,    -1,    -1,    -1,    -1,
+     133,    -1,     3,   136,   137,     6,     7,   140,   141,   142,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
+      31,    32,    33,    -1,    35,    36,    37,    38,    39,    40,
+      90,    91,    77,    -1,    -1,    -1,    -1,    -1,    -1,    50,
+      51,    52,    53,    54,    -1,    56,   106,   107,    59,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      71,    72,    73,   108,   109,   110,   111,   112,    -1,   114,
+      -1,   108,   109,   110,   111,   112,    87,    -1,    -1,    90,
+      91,    -1,    -1,    -1,   129,   130,   131,   132,   133,   134,
+     135,   136,   137,   138,   139,   140,   133,   134,   135,   136,
+     137,   138,   139,   140,    -1,    -1,   117,    -1,    -1,    -1,
+     121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   133,    -1,     3,   136,   137,     6,     7,   140,
+     141,   142,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    -1,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    -1,    35,    36,    37,    38,
+      39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    50,    51,    52,    53,    54,    -1,    56,    -1,    -1,
+      59,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    71,    72,    73,   108,   109,   110,   111,   112,
+      -1,   114,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
+      -1,    90,    91,    -1,    -1,    -1,   129,   130,   131,   132,
+     133,   134,   135,   136,   137,   138,   139,   140,    -1,    -1,
+      22,    23,    24,    25,    26,    27,    28,    29,   117,    31,
+      -1,    33,   121,    -1,    36,    37,    38,    39,    -1,    -1,
+      -1,    -1,    -1,    -1,   133,    -1,     3,   136,   137,     6,
+       7,   140,   141,   142,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    -1,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    40,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    50,    51,    52,    53,    54,    -1,    56,
+      -1,    -1,    59,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    71,    72,    73,   108,   109,   110,
+     111,   112,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      87,    -1,    -1,    90,    91,    -1,    -1,    -1,   129,   130,
+     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     117,    -1,    -1,    -1,   121,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   133,    -1,     3,   136,
+     137,     6,     7,   140,   141,   142,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    -1,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    -1,
+      35,    36,    37,    38,    39,    40,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    50,    51,    52,    53,    54,
+      -1,    56,    -1,    -1,    59,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    71,    72,    73,   108,
+     109,   110,   111,   112,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    87,    -1,    -1,    90,    91,    -1,    -1,    -1,
+      -1,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   117,    -1,    -1,    -1,   121,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   133,    -1,
+       3,   136,   137,     6,     7,   140,   141,   142,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    -1,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    40,    41,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    50,    51,    52,
+      53,    54,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    72,
+      73,   108,   109,   110,   111,   112,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    87,    -1,    -1,    90,    91,    -1,
+      -1,    -1,    -1,    -1,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   117,    -1,    -1,    -1,   121,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     133,    -1,     3,   136,   137,     6,     7,   140,   141,   142,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
+      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
+      31,    32,    33,    -1,    35,    36,    37,    38,    39,    40,
+      41,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    50,
+      51,    52,    53,    54,    -1,    56,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      71,    72,    73,   108,   109,   110,   111,   112,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,    90,
+      91,    -1,    -1,    -1,    -1,    -1,    -1,   132,   133,   134,
+     135,   136,   137,   138,   139,   140,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   117,    -1,    -1,    -1,
+     121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   133,    -1,     3,   136,   137,     6,     7,   140,
+     141,   142,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    20,    -1,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    -1,    35,    36,    37,    38,
+      39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    50,    51,    52,    53,    54,    -1,    56,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    71,    72,    73,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
+      -1,    90,    91,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   117,    -1,
+      -1,    -1,   121,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   133,    -1,     3,   136,   137,     6,
+       7,   140,   141,   142,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    20,    -1,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    40,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    50,    51,    52,    53,    54,    -1,    56,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    71,    72,    73,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     4,
+      87,    -1,    -1,    90,    91,    10,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    21,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     117,    -1,    -1,    -1,   121,    -1,    -1,    -1,    43,    44,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   136,
+     137,    -1,    -1,   140,   141,   142,    -1,    -1,    63,    64,
+      65,    66,    -1,    68,    69,    70,    -1,    -1,    -1,    74,
+      75,    76,    -1,    78,    79,    80,    -1,    82,    83,    84,
+      85,    86,    -1,    -1,    -1,    -1,    -1,    92,    -1,    -1,
+      -1,    96,    -1,    98,    99,   100,   101,   102,   103,     3,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     115,    -1,    -1,    -1,    -1,   120,    -1,    -1,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      -1,    35,    36,    37,    38,    39,    40,   142,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    49,    50,    51,    52,    53,
+      54,    -1,    -1,    -1,    58,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    72,    73,
+      -1,    -1,    -1,    -1,    -1,     3,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    87,    -1,    -1,    90,    91,    -1,    -1,
+      -1,    -1,    -1,    -1,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    -1,    35,    36,    37,
+      38,    39,    -1,   117,    -1,    -1,   120,   121,     3,    -1,
+      -1,    -1,   126,    -1,    -1,    -1,   130,    41,    -1,   133,
+      -1,    -1,    -1,    -1,    -1,    -1,   140,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    -1,
+      35,    36,    37,    38,    39,    40,    -1,    -1,    -1,    87,
+      -1,    -1,    90,    91,    49,    50,    51,    52,    53,    54,
+      -1,    -1,    -1,    58,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    71,    72,    73,   117,
+      -1,   105,    -1,   121,   108,   109,   110,   111,   112,    -1,
+     114,    -1,    87,    -1,    -1,    90,    91,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,    -1,    -1,    -1,
+      -1,    -1,   117,    -1,    -1,   120,   121,     3,    -1,    -1,
+      -1,   126,    -1,    -1,    -1,   130,    -1,    -1,   133,    -1,
+      -1,    -1,    -1,    -1,    -1,   140,    22,    23,    24,    25,
+      26,    27,    28,    29,    30,    31,    32,    33,    -1,    35,
+      36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    49,    50,    51,    52,    53,    54,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    71,    72,    73,     3,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    87,    -1,    -1,    90,    91,    -1,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    -1,
+      35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,   117,    -1,    -1,   120,   121,    -1,    -1,    53,    54,
+     126,    -1,    -1,    -1,   130,    -1,    -1,   133,    -1,    -1,
+      -1,    -1,    -1,    -1,   140,    -1,    71,    72,    73,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    87,    -1,    -1,    90,    91,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,     0,     1,    -1,     3,     4,    -1,    -1,    -1,     8,
+       9,    10,   117,    -1,    -1,    -1,   121,    -1,    -1,    -1,
+      -1,    -1,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,   140,    35,    36,    37,    38,
+      39,    -1,    -1,    -1,    43,    44,    -1,    -1,    -1,    -1,
+      -1,    50,    51,    52,    53,    54,    -1,    -1,    57,    -1,
+      -1,    -1,    -1,    -1,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    -1,    -1,    -1,    -1,    78,
+      79,    80,    -1,    82,    83,    84,    85,    86,    87,    88,
+      -1,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   115,     1,   117,     3,
+       4,   120,   121,    -1,     8,     9,    10,   126,   127,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      -1,    35,    36,    37,    38,    39,    -1,    -1,    -1,    43,
+      44,    -1,    -1,    47,    -1,    -1,    50,    51,    52,    53,
+      54,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      -1,    -1,    -1,    -1,    78,    79,    80,    -1,    82,    83,
+      84,    85,    86,    87,    88,    -1,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   115,     1,   117,     3,     4,   120,   121,    -1,     8,
+       9,    10,   126,   127,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    -1,    35,    36,    37,    38,
+      39,    -1,    -1,    -1,    43,    44,    -1,    -1,    47,    -1,
+      -1,    50,    51,    52,    53,    54,    -1,    -1,    57,    -1,
+      -1,    -1,    -1,    -1,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    -1,    -1,    -1,    -1,    78,
+      79,    80,    -1,    82,    83,    84,    85,    86,    87,    88,
+      -1,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   115,     1,   117,     3,
+       4,   120,   121,    -1,     8,     9,    10,   126,   127,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
+      -1,    35,    36,    37,    38,    39,    -1,    -1,    -1,    43,
+      44,    -1,    -1,    47,    -1,    -1,    50,    51,    52,    53,
+      54,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    63,
+      64,    65,    66,    67,    68,    69,    70,    71,    72,    73,
+      -1,    -1,    -1,    -1,    78,    79,    80,    -1,    82,    83,
+      84,    85,    86,    87,    88,    -1,    90,    91,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   115,     1,   117,     3,     4,   120,   121,    -1,     8,
+       9,    10,   126,   127,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    21,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    -1,    35,    36,    37,    38,
+      39,    -1,    -1,    -1,    43,    44,    -1,    -1,    -1,    -1,
+      -1,    50,    51,    52,    53,    54,    -1,    -1,    57,    -1,
+      -1,    -1,    61,    -1,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    -1,    -1,    -1,    -1,    78,
+      79,    80,    -1,    82,    83,    84,    85,    86,    87,    88,
+      -1,    90,    91,    92,    93,    94,    95,    96,    97,    98,
+      99,   100,   101,   102,   103,    -1,    -1,    -1,     1,    -1,
+       3,    -1,    -1,    -1,    -1,    -1,   115,    -1,   117,    -1,
+      -1,   120,   121,    -1,    -1,    -1,    -1,   126,   127,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    49,    50,    51,    52,
+      53,    54,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    72,
+      73,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    87,    -1,    -1,    90,    91,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,     1,    -1,     3,    -1,    -1,    -1,    41,
+      -1,    -1,    -1,    -1,   117,    -1,    -1,   120,   121,    -1,
+      -1,    -1,    -1,   126,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    -1,    35,    36,    37,
+      38,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    49,    50,    51,    52,    53,    54,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    71,    72,    73,   108,   109,   110,   111,
+     112,    -1,   114,    -1,    -1,    -1,    -1,    -1,    -1,    87,
+      -1,    -1,    90,    91,    -1,    -1,    -1,   129,   130,   131,
+     132,   133,   134,   135,   136,   137,   138,   139,   140,    -1,
+       3,    -1,    -1,    -1,    41,    -1,    -1,    -1,    -1,   117,
+      -1,    -1,   120,   121,    -1,    -1,    -1,    -1,   126,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    49,    50,    51,    52,
+      53,    54,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    72,
+      73,   108,   109,   110,   111,   112,    -1,   114,    -1,    -1,
+      -1,    -1,    -1,    -1,    87,    -1,    -1,    90,    91,    -1,
+      -1,    -1,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,    -1,    -1,     3,    -1,    -1,    -1,
+      41,    -1,    -1,    -1,   117,    -1,    13,   120,   121,    -1,
+      -1,    -1,    -1,   126,   127,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    49,    50,    51,    52,    53,    54,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    71,    72,    73,   108,   109,   110,
+     111,   112,    -1,   114,    -1,    -1,    -1,    -1,    -1,    -1,
+      87,    -1,    -1,    90,    91,    -1,    -1,    -1,   129,   130,
+     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
+      -1,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     117,    -1,    -1,   120,   121,    -1,    -1,    -1,    -1,   126,
+      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    -1,    35,    36,    37,    38,    39,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    49,    50,    51,
+      52,    53,    54,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,
+      72,    73,    -1,    -1,    -1,    -1,     1,    -1,     3,    -1,
+      -1,    -1,    -1,    -1,    -1,    87,    -1,    -1,    90,    91,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    -1,
+      35,    36,    37,    38,    39,   117,    -1,    -1,   120,   121,
+      -1,    -1,    -1,    -1,   126,    50,    51,    52,    53,    54,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    71,    72,    73,    -1,
+       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    87,    -1,    -1,    90,    91,    -1,    -1,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    -1,    -1,    -1,
+      -1,    -1,   117,    -1,    -1,    -1,   121,    50,    51,    52,
+      53,    54,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    72,
+      73,    -1,    -1,     3,    -1,    -1,    -1,    -1,    -1,    43,
+      -1,    -1,    -1,    -1,    87,    88,    -1,    90,    91,    -1,
+      -1,    -1,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    -1,    35,    36,    37,    38,    39,
+      -1,    -1,    -1,    -1,   117,    -1,    -1,    -1,   121,   122,
+      50,    51,    52,    53,    54,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    71,    72,    73,   108,   109,   110,   111,   112,    -1,
+     114,    -1,    -1,    -1,    -1,    -1,    -1,    87,    88,    -1,
+      90,    91,    -1,    -1,    -1,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,     3,    -1,   117,     6,     7,
+      -1,   121,   122,    11,    12,    13,    14,    15,    16,    17,
+      18,    19,    20,    -1,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    -1,    35,    36,    37,
+      38,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    50,    51,    52,    53,    54,    -1,    56,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    71,    72,    73,    -1,    -1,     3,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    87,
+      -1,    -1,    90,    91,    -1,    -1,    -1,    22,    23,    24,
+      25,    26,    27,    28,    29,    30,    31,    32,    33,    -1,
+      35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,   117,
+      -1,    -1,    -1,   121,    49,    50,    51,    52,    53,    54,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    71,    72,    73,    -1,
+       3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    87,    -1,    -1,    90,    91,    -1,    -1,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    -1,    35,    36,    37,    38,    39,    40,    -1,    -1,
+      -1,    -1,   117,    -1,    -1,   120,   121,    50,    51,    52,
+      53,    54,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    72,
+      73,    -1,     3,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    87,    -1,    -1,    90,    91,    -1,
+      -1,    22,    23,    24,    25,    26,    27,    28,    29,    30,
+      31,    32,    33,    -1,    35,    36,    37,    38,    39,    -1,
+      -1,    -1,    -1,    -1,   117,    -1,    -1,    -1,   121,    50,
+      51,    52,    53,    54,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      71,    72,    73,    -1,     3,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    87,    88,    -1,    90,
+      91,    -1,    -1,    22,    23,    24,    25,    26,    27,    28,
+      29,    30,    31,    32,    33,    -1,    35,    36,    37,    38,
+      39,    -1,    -1,    -1,    -1,    -1,   117,    -1,    -1,    -1,
+     121,    50,    51,    52,    53,    54,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    71,    72,    73,     3,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
+      -1,    90,    91,    -1,    22,    23,    24,    25,    26,    27,
+      28,    29,    30,    31,    32,    33,    -1,    35,    36,    37,
+      38,    39,    -1,    -1,    -1,    -1,    -1,    -1,   117,    -1,
+      -1,    -1,   121,    -1,    -1,    53,    54,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    71,    72,    73,     3,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    87,
+      -1,    -1,    90,    91,    -1,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,   117,
+      -1,    -1,    -1,   121,    -1,    -1,    53,    54,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    72,    73,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      87,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,   104,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     117,    -1,    -1,    -1,   121,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    53,    54,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    72,    73,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      87,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,   104,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     117,    -1,    -1,    -1,   121,    22,    23,    24,    25,    26,
+      27,    28,    29,    30,    31,    32,    33,    -1,    35,    36,
+      37,    38,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    59,    53,    54,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    72,    73,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    59,    -1,
+      87,    -1,    -1,    90,    91,    -1,    -1,    -1,    -1,    -1,
+      59,    -1,    -1,    -1,   108,   109,   110,   111,   112,    -1,
+     114,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     117,    -1,    -1,    -1,   121,   129,   130,   131,   132,   133,
+     134,   135,   136,   137,   138,   139,   140,   108,   109,   110,
+     111,   112,    59,   114,    -1,    -1,    -1,    -1,    -1,   108,
+     109,   110,   111,   112,    59,   114,    -1,    -1,   129,   130,
+     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   108,   109,   110,   111,   112,    -1,   114,    -1,    -1,
+      -1,    -1,    -1,   108,   109,   110,   111,   112,    -1,   114,
+      -1,    -1,   129,   130,   131,   132,   133,   134,   135,   136,
+     137,   138,   139,   140,   129,   130,   131,   132,   133,   134,
+     135,   136,   137,   138,   139,   140
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const yytype_uint16 yystos[] =
+{
+       0,   123,   124,   125,   146,   147,   329,     1,     3,    22,
+      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
+      33,    35,    36,    37,    38,    39,    49,    50,    51,    52,
+      53,    54,    71,    72,    73,    87,    90,    91,   117,   120,
+     121,   126,   198,   242,   243,   261,   262,   264,   265,   266,
+     267,   268,   269,   298,   299,   314,   317,   319,     1,   243,
+       1,    40,     0,     1,     4,     8,     9,    10,    21,    43,
+      44,    57,    63,    64,    65,    66,    67,    68,    69,    70,
+      78,    79,    80,    82,    83,    84,    85,    86,    92,    93,
+      94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
+     115,   120,   126,   127,   148,   149,   150,   152,   153,   154,
+     155,   156,   159,   160,   162,   163,   164,   165,   166,   167,
+     168,   171,   172,   173,   176,   178,   183,   184,   185,   186,
+     188,   192,   200,   201,   202,   203,   204,   208,   209,   216,
+     217,   229,   230,   237,   238,   329,    53,    72,    49,    49,
+      40,   144,   104,   104,   313,   242,   317,   127,    43,   265,
+     261,    40,    49,    55,    58,    77,   121,   130,   133,   140,
+     142,   250,   251,   253,   255,   256,   257,   258,   317,   329,
+     261,   268,   317,   313,   119,   144,   318,    43,    43,   239,
+     240,   243,   329,   122,    40,     6,    86,   120,   323,    40,
+     326,   329,     1,   263,   264,   314,    40,   326,    40,   170,
+     329,    40,    40,    85,    86,    40,    85,    40,    78,    83,
+      44,    78,    93,   317,    46,   314,   317,    40,     4,    46,
+      40,    40,    43,    46,     4,   323,    40,   182,   263,   180,
+     182,    40,    40,   323,    40,    30,    32,    35,   104,   191,
+     266,   267,   299,   317,   326,    40,   130,   133,   253,   255,
+     258,   317,    21,    86,    88,   198,   263,   299,   317,   120,
+     121,   319,   320,   299,     3,     7,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    40,    56,   133,   136,
+     137,   140,   141,   142,   243,   244,   245,   247,   263,   264,
+     283,   284,   285,   286,   287,   288,   323,   324,   329,   261,
+      40,   130,   133,   239,   256,   258,   317,    40,   255,   317,
+      46,   106,   107,   270,   271,   272,   273,   274,    59,   283,
+     286,   283,     3,    40,    49,   142,   254,   257,   317,    49,
+     254,   257,   258,   261,   317,   250,    40,    58,   250,    40,
+      58,    49,   130,   133,   254,   257,   317,   118,   319,   121,
+     320,    41,    42,   241,   329,   272,   314,   315,   323,   191,
+     299,     6,    46,   315,   327,   315,     0,    43,   253,   255,
+      55,    41,   315,    53,    54,    72,   300,   301,   329,   314,
+     314,   315,    13,   177,   239,   239,   317,    43,    55,   219,
+      55,    46,   314,   179,   327,   314,   239,    46,   252,   253,
+     255,   256,   329,    43,    42,   181,   329,   315,   316,   329,
+     157,   158,   323,   239,   212,   213,   214,   243,   298,   329,
+     317,   317,   133,   323,   130,   133,   258,   314,   317,   327,
+      40,   315,    40,   130,   133,   317,   118,   253,   317,   275,
+     314,   329,    40,   253,    77,   290,   291,   317,   329,    41,
+     314,   318,   105,    48,   113,   283,   285,     3,    40,    49,
+     285,   283,   283,   283,   283,   283,   283,   105,    42,   246,
+     329,    40,   108,   109,   110,   111,   112,   114,   129,   130,
+     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
+      48,   113,     7,   130,   133,   258,   317,   255,   255,    41,
+      41,   130,   133,   255,   317,   118,    58,   283,    59,    40,
+     258,   317,   254,   317,    40,    58,   254,   258,   239,    59,
+     283,   239,    59,   283,   254,    49,   254,   257,    49,   254,
+     257,   118,    49,   130,   133,   254,   261,   318,    43,   127,
+     243,    41,   317,   317,   187,    42,    55,    41,   250,    40,
+     270,    41,   317,    41,    55,    41,    42,   175,    42,    41,
+      41,    43,   263,   147,   317,   218,    41,    41,    41,    41,
+     180,    40,   182,    41,    41,    42,    46,    41,   105,    42,
+     215,   329,    40,    60,   118,    41,   258,   317,    43,   239,
+     118,    81,    89,    90,    91,   130,   133,   259,   260,   261,
+     303,   306,   307,   308,   329,    55,    77,   199,   329,   239,
+     317,   308,   292,    46,    43,    91,   305,   329,   313,   299,
+       3,     3,    41,   105,   130,   133,   140,   258,   104,   263,
+     285,    40,   247,   283,   283,   283,   283,   283,   283,   283,
+     283,   283,   283,   283,   283,   283,   283,   283,   283,   283,
+     283,     3,     3,   317,   118,    41,    41,    41,   118,   253,
+     256,   261,   283,   239,   254,   317,    41,   118,   239,    59,
+     283,    41,    59,    41,    59,   254,   254,    49,   130,   133,
+     254,   257,   254,    49,    49,   254,   243,   241,     4,    46,
+     323,    40,   147,   327,   157,   287,   323,   328,    43,   239,
+      43,    46,     4,   169,   323,     4,    43,    46,   116,   174,
+     253,   323,   325,   315,   323,   328,    41,   243,   253,    46,
+     252,    47,    43,   147,    44,   238,   180,    43,    46,    40,
+      47,   239,   181,   117,   121,   314,   321,    43,   327,   243,
+     174,    92,   210,   214,   239,   161,   261,   253,   323,   118,
+      41,    40,    40,   303,    91,    90,   306,   260,   113,    58,
+     193,   265,    43,    46,    41,   190,   250,    79,   293,   294,
+     302,   329,   206,   290,   317,    40,    40,   283,   283,    41,
+      41,   140,   261,    41,   130,   133,   283,   251,    41,   263,
+     246,    77,    40,    40,    41,    41,   253,   256,    59,    41,
+      41,   254,    41,    59,   259,   259,   254,    49,    49,   254,
+     254,   254,   241,   239,    47,    42,    42,    41,   151,    40,
+     308,    55,    41,    42,   175,   174,   253,   308,    43,    47,
+     323,   263,   314,    43,    55,   325,   239,    41,   144,   119,
+     144,   322,   104,    41,    47,   317,    44,   120,   188,   204,
+     208,   209,   211,   226,   228,   238,   215,    41,   147,   308,
+      43,   239,   283,   191,   104,   194,   329,   154,   276,   277,
+     278,   279,   329,    40,    55,   306,   308,   309,     1,    42,
+      43,    46,   189,    42,    74,    75,    76,   295,   297,     1,
+      43,    67,    74,    75,    76,    79,   126,   142,   152,   153,
+     154,   155,   159,   160,   164,   166,   168,   171,   173,   176,
+     178,   183,   184,   185,   186,   204,   208,   209,   216,   220,
+     224,   225,   226,   227,   228,   229,   231,   232,   235,   238,
+     329,    46,   250,   248,   286,   329,   248,    41,   283,   283,
+     283,    41,    41,    41,    41,   251,   283,   248,   248,    41,
+      41,    41,   254,   254,    41,   327,   327,   259,   220,   239,
+     174,   323,   328,    43,   253,    41,   308,    43,   253,    43,
+     182,    41,   259,   121,   314,   314,   121,   314,   244,     4,
+      46,    55,   104,    88,   122,   263,    61,    43,    41,    41,
+     303,   304,   329,    40,    46,   195,   276,   126,   280,   281,
+     314,    47,    42,   127,   239,   270,    55,    77,   310,   329,
+     253,   294,   317,   296,   223,    46,    77,    77,    77,   142,
+     224,   319,    47,   127,   220,    30,    32,    35,   236,   267,
+     317,   205,    41,    42,   249,   329,    41,   283,   283,    41,
+      41,    41,   250,    47,    41,   175,   308,    43,   253,   174,
+      43,    43,   322,   322,   105,   263,   212,   263,    40,   303,
+     190,   239,    40,    43,   196,   281,   277,    55,    43,   253,
+     127,   278,    41,    43,   272,   311,   312,   317,    43,    46,
+     308,    49,   289,   329,   302,   220,   221,   319,    40,    43,
+     207,   253,    77,    43,   220,   286,    43,    43,    43,   308,
+      43,   252,   105,    40,   130,   133,   258,   239,   189,    41,
+     197,   282,   283,   308,   278,    43,    46,    43,    42,    49,
+      40,    46,   190,   317,   220,    40,   239,   308,   283,    47,
+     249,    43,    43,   239,    40,    40,    40,   133,    41,   308,
+      43,   190,   312,   189,   289,    47,   239,    41,   190,    43,
+     207,    41,   239,   239,   239,    40,   309,   113,   195,   189,
+      49,   222,    41,   233,   308,   189,   234,   308,    41,    41,
+      41,   239,   263,   196,   220,   234,    43,    46,    55,    43,
+      46,    55,   234,   234,   234,    41,   195,   272,   270,   234,
+     196,    43,    43
+};
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		(-2)
+#define YYEOF		0
+
+#define YYACCEPT	goto yyacceptlab
+#define YYABORT		goto yyabortlab
+#define YYERROR		goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+
+#define YYFAIL		goto yyerrlab
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      yytoken = YYTRANSLATE (yychar);				\
+      YYPOPSTACK (1);						\
+      goto yybackup;						\
+    }								\
+  else								\
+    {								\
+      yyerror (YY_("syntax error: cannot back up")); \
+      YYERROR;							\
+    }								\
+while (YYID (0))
+
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (YYID (0))
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+	      (Loc).first_line, (Loc).first_column,	\
+	      (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (YYLEX_PARAM)
+#else
+# define YYLEX yylex ()
+#endif
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)			\
+do {						\
+  if (yydebug)					\
+    YYFPRINTF Args;				\
+} while (YYID (0))
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+do {									  \
+  if (yydebug)								  \
+    {									  \
+      YYFPRINTF (stderr, "%s ", Title);					  \
+      yy_symbol_print (stderr,						  \
+		  Type, Value); \
+      YYFPRINTF (stderr, "\n");						  \
+    }									  \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+#endif
+{
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+  YYUSE (yyoutput);
+# endif
+  switch (yytype)
+    {
+      default:
+	break;
+    }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+#endif
+{
+  if (yytype < YYNTOKENS)
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+#else
+static void
+yy_stack_print (bottom, top)
+    yytype_int16 *bottom;
+    yytype_int16 *top;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (YYID (0))
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
+#else
+static void
+yy_reduce_print (yyvsp, yyrule)
+    YYSTYPE *yyvsp;
+    int yyrule;
+#endif
+{
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+	     yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      fprintf (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+		       &(yyvsp[(yyi + 1) - (yynrhs)])
+		       		       );
+      fprintf (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (yyvsp, Rule); \
+} while (YYID (0))
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef	YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static YYSIZE_T
+yystrlen (const char *yystr)
+#else
+static YYSIZE_T
+yystrlen (yystr)
+    const char *yystr;
+#endif
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+#else
+static char *
+yystpcpy (yydest, yysrc)
+    char *yydest;
+    const char *yysrc;
+#endif
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+	switch (*++yyp)
+	  {
+	  case '\'':
+	  case ',':
+	    goto do_not_strip_quotes;
+
+	  case '\\':
+	    if (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
+
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into YYRESULT an error message about the unexpected token
+   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
+   including the terminating null byte.  If YYRESULT is null, do not
+   copy anything; just return the number of bytes that would be
+   copied.  As a special case, return 0 if an ordinary "syntax error"
+   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
+   size calculation.  */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
+{
+  int yyn = yypact[yystate];
+
+  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+    return 0;
+  else
+    {
+      int yytype = YYTRANSLATE (yychar);
+      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+      YYSIZE_T yysize = yysize0;
+      YYSIZE_T yysize1;
+      int yysize_overflow = 0;
+      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+      int yyx;
+
+# if 0
+      /* This is so xgettext sees the translatable formats that are
+	 constructed on the fly.  */
+      YY_("syntax error, unexpected %s");
+      YY_("syntax error, unexpected %s, expecting %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+      char *yyfmt;
+      char const *yyf;
+      static char const yyunexpected[] = "syntax error, unexpected %s";
+      static char const yyexpecting[] = ", expecting %s";
+      static char const yyor[] = " or %s";
+      char yyformat[sizeof yyunexpected
+		    + sizeof yyexpecting - 1
+		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+		       * (sizeof yyor - 1))];
+      char const *yyprefix = yyexpecting;
+
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+	 YYCHECK.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      int yycount = 1;
+
+      yyarg[0] = yytname[yytype];
+      yyfmt = yystpcpy (yyformat, yyunexpected);
+
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+	  {
+	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+	      {
+		yycount = 1;
+		yysize = yysize0;
+		yyformat[sizeof yyunexpected - 1] = '\0';
+		break;
+	      }
+	    yyarg[yycount++] = yytname[yyx];
+	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+	    yysize_overflow |= (yysize1 < yysize);
+	    yysize = yysize1;
+	    yyfmt = yystpcpy (yyfmt, yyprefix);
+	    yyprefix = yyor;
+	  }
+
+      yyf = YY_(yyformat);
+      yysize1 = yysize + yystrlen (yyf);
+      yysize_overflow |= (yysize1 < yysize);
+      yysize = yysize1;
+
+      if (yysize_overflow)
+	return YYSIZE_MAXIMUM;
+
+      if (yyresult)
+	{
+	  /* Avoid sprintf, as that infringes on the user's name space.
+	     Don't have undefined behavior even if the translation
+	     produced a string with the wrong number of "%s"s.  */
+	  char *yyp = yyresult;
+	  int yyi = 0;
+	  while ((*yyp = *yyf) != '\0')
+	    {
+	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		{
+		  yyp += yytnamerr (yyp, yyarg[yyi++]);
+		  yyf += 2;
+		}
+	      else
+		{
+		  yyp++;
+		  yyf++;
+		}
+	    }
+	}
+      return yysize;
+    }
+}
+#endif /* YYERROR_VERBOSE */
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+#else
+static void
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
+    int yytype;
+    YYSTYPE *yyvaluep;
+#endif
+{
+  YYUSE (yyvaluep);
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  switch (yytype)
+    {
+
+      default:
+	break;
+    }
+}
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
+
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
+
+
+
+/* The look-ahead symbol.  */
+int yychar;
+
+/* The semantic value of the look-ahead symbol.  */
+YYSTYPE yylval;
+
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+    void *YYPARSE_PARAM;
+#endif
+#else /* ! YYPARSE_PARAM */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void)
+#else
+int
+yyparse ()
+
+#endif
+#endif
+{
+  
+  int yystate;
+  int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  yytype_int16 yyssa[YYINITDEPTH];
+  yytype_int16 *yyss = yyssa;
+  yytype_int16 *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  YYSTYPE *yyvsp;
+
+
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss;
+  yyvsp = yyvs;
+
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+	/* Give user a chance to reallocate the stack.  Use copies of
+	   these so that the &'s don't force the real ones into
+	   memory.  */
+	YYSTYPE *yyvs1 = yyvs;
+	yytype_int16 *yyss1 = yyss;
+
+
+	/* Each stack pointer address is followed by the size of the
+	   data in use in that stack, in bytes.  This used to be a
+	   conditional around just the two extra args, but that might
+	   be undefined if yyoverflow is a macro.  */
+	yyoverflow (YY_("memory exhausted"),
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+
+		    &yystacksize);
+
+	yyss = yyss1;
+	yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+	yystacksize = YYMAXDEPTH;
+
+      {
+	yytype_int16 *yyss1 = yyss;
+	union yyalloc *yyptr =
+	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+	if (! yyptr)
+	  goto yyexhaustedlab;
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+
+#  undef YYSTACK_RELOCATE
+	if (yyss1 != yyssa)
+	  YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+		  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+	YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     look-ahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to look-ahead token.  */
+  yyn = yypact[yystate];
+  if (yyn == YYPACT_NINF)
+    goto yydefault;
+
+  /* Not known => get a look-ahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = YYLEX;
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yyn == 0 || yyn == YYTABLE_NINF)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  yystate = yyn;
+  *++yyvsp = yylval;
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 2:
+#line 1730 "parser.y"
+    {
+                   if (!classes) classes = NewHash();
+		   Setattr((yyvsp[(1) - (1)].node),"classes",classes); 
+		   Setattr((yyvsp[(1) - (1)].node),"name",ModuleName);
+		   
+		   if ((!module_node) && ModuleName) {
+		     module_node = new_node("module");
+		     Setattr(module_node,"name",ModuleName);
+		   }
+		   Setattr((yyvsp[(1) - (1)].node),"module",module_node);
+	           top = (yyvsp[(1) - (1)].node);
+               ;}
+    break;
+
+  case 3:
+#line 1742 "parser.y"
+    {
+                 top = Copy(Getattr((yyvsp[(2) - (3)].p),"type"));
+		 Delete((yyvsp[(2) - (3)].p));
+               ;}
+    break;
+
+  case 4:
+#line 1746 "parser.y"
+    {
+                 top = 0;
+               ;}
+    break;
+
+  case 5:
+#line 1749 "parser.y"
+    {
+                 top = (yyvsp[(2) - (3)].p);
+               ;}
+    break;
+
+  case 6:
+#line 1752 "parser.y"
+    {
+                 top = 0;
+               ;}
+    break;
+
+  case 7:
+#line 1755 "parser.y"
+    {
+                 top = (yyvsp[(3) - (5)].pl);
+               ;}
+    break;
+
+  case 8:
+#line 1758 "parser.y"
+    {
+                 top = 0;
+               ;}
+    break;
+
+  case 9:
+#line 1763 "parser.y"
+    {  
+                   /* add declaration to end of linked list (the declaration isn't always a single declaration, sometimes it is a linked list itself) */
+                   if (currentDeclComment != NULL) {
+		     set_comment((yyvsp[(2) - (2)].node), currentDeclComment);
+		     currentDeclComment = NULL;
+                   }                                      
+                   appendChild((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));
+                   (yyval.node) = (yyvsp[(1) - (2)].node);
+               ;}
+    break;
+
+  case 10:
+#line 1772 "parser.y"
+    {
+                   currentDeclComment = (yyvsp[(2) - (2)].str); 
+                   (yyval.node) = (yyvsp[(1) - (2)].node);
+               ;}
+    break;
+
+  case 11:
+#line 1776 "parser.y"
+    {
+                   Node *node = lastChild((yyvsp[(1) - (2)].node));
+                   if (node) {
+                     set_comment(node, (yyvsp[(2) - (2)].str));
+                   }
+                   (yyval.node) = (yyvsp[(1) - (2)].node);
+               ;}
+    break;
+
+  case 12:
+#line 1783 "parser.y"
+    {
+                   (yyval.node) = new_node("top");
+               ;}
+    break;
+
+  case 13:
+#line 1788 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 14:
+#line 1789 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 15:
+#line 1790 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 16:
+#line 1791 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 17:
+#line 1792 "parser.y"
+    {
+                  (yyval.node) = 0;
+		  if (cparse_unknown_directive) {
+		      Swig_error(cparse_file, cparse_line, "Unknown directive '%s'.\n", cparse_unknown_directive);
+		  } else {
+		      Swig_error(cparse_file, cparse_line, "Syntax error in input(1).\n");
+		  }
+		  Exit(EXIT_FAILURE);
+               ;}
+    break;
+
+  case 18:
+#line 1802 "parser.y"
+    { 
+                  if ((yyval.node)) {
+   		      add_symbols((yyval.node));
+                  }
+                  (yyval.node) = (yyvsp[(1) - (1)].node); 
+	       ;}
+    break;
+
+  case 19:
+#line 1818 "parser.y"
+    {
+                  (yyval.node) = 0;
+                  skip_decl();
+               ;}
+    break;
+
+  case 20:
+#line 1828 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 21:
+#line 1829 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 22:
+#line 1830 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 23:
+#line 1831 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 24:
+#line 1832 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 25:
+#line 1833 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 26:
+#line 1834 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 27:
+#line 1835 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 28:
+#line 1836 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 29:
+#line 1837 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 30:
+#line 1838 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 31:
+#line 1839 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 32:
+#line 1840 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 33:
+#line 1841 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 34:
+#line 1842 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 35:
+#line 1843 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 36:
+#line 1844 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 37:
+#line 1845 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 38:
+#line 1846 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 39:
+#line 1847 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 40:
+#line 1848 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 41:
+#line 1855 "parser.y"
+    {
+               Node *cls;
+	       String *clsname;
+	       extendmode = 1;
+	       cplus_mode = CPLUS_PUBLIC;
+	       if (!classes) classes = NewHash();
+	       if (!classes_typedefs) classes_typedefs = NewHash();
+	       clsname = make_class_name((yyvsp[(4) - (5)].str));
+	       cls = Getattr(classes,clsname);
+	       if (!cls) {
+	         cls = Getattr(classes_typedefs, clsname);
+		 if (!cls) {
+		   /* No previous definition. Create a new scope */
+		   Node *am = Getattr(Swig_extend_hash(),clsname);
+		   if (!am) {
+		     Swig_symbol_newscope();
+		     Swig_symbol_setscopename((yyvsp[(4) - (5)].str));
+		     prev_symtab = 0;
+		   } else {
+		     prev_symtab = Swig_symbol_setscope(Getattr(am,"symtab"));
+		   }
+		   current_class = 0;
+		 } else {
+		   /* Previous typedef class definition.  Use its symbol table.
+		      Deprecated, just the real name should be used. 
+		      Note that %extend before the class typedef never worked, only %extend after the class typedef. */
+		   prev_symtab = Swig_symbol_setscope(Getattr(cls, "symtab"));
+		   current_class = cls;
+		   SWIG_WARN_NODE_BEGIN(cls);
+		   Swig_warning(WARN_PARSE_EXTEND_NAME, cparse_file, cparse_line, "Deprecated %%extend name used - the %s name '%s' should be used instead of the typedef name '%s'.\n", Getattr(cls, "kind"), SwigType_namestr(Getattr(cls, "name")), (yyvsp[(4) - (5)].str));
+		   SWIG_WARN_NODE_END(cls);
+		 }
+	       } else {
+		 /* Previous class definition.  Use its symbol table */
+		 prev_symtab = Swig_symbol_setscope(Getattr(cls,"symtab"));
+		 current_class = cls;
+	       }
+	       Classprefix = NewString((yyvsp[(4) - (5)].str));
+	       Namespaceprefix= Swig_symbol_qualifiedscopename(0);
+	       Delete(clsname);
+	     ;}
+    break;
+
+  case 42:
+#line 1895 "parser.y"
+    {
+               String *clsname;
+	       extendmode = 0;
+               (yyval.node) = new_node("extend");
+	       Setattr((yyval.node),"symtab",Swig_symbol_popscope());
+	       if (prev_symtab) {
+		 Swig_symbol_setscope(prev_symtab);
+	       }
+	       Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+               clsname = make_class_name((yyvsp[(4) - (8)].str));
+	       Setattr((yyval.node),"name",clsname);
+
+	       mark_nodes_as_extend((yyvsp[(7) - (8)].node));
+	       if (current_class) {
+		 /* We add the extension to the previously defined class */
+		 appendChild((yyval.node), (yyvsp[(7) - (8)].node));
+		 appendChild(current_class,(yyval.node));
+	       } else {
+		 /* We store the extensions in the extensions hash */
+		 Node *am = Getattr(Swig_extend_hash(),clsname);
+		 if (am) {
+		   /* Append the members to the previous extend methods */
+		   appendChild(am, (yyvsp[(7) - (8)].node));
+		 } else {
+		   appendChild((yyval.node), (yyvsp[(7) - (8)].node));
+		   Setattr(Swig_extend_hash(),clsname,(yyval.node));
+		 }
+	       }
+	       current_class = 0;
+	       Delete(Classprefix);
+	       Delete(clsname);
+	       Classprefix = 0;
+	       prev_symtab = 0;
+	       (yyval.node) = 0;
+
+	     ;}
+    break;
+
+  case 43:
+#line 1937 "parser.y"
+    {
+                    (yyval.node) = new_node("apply");
+                    Setattr((yyval.node),"pattern",Getattr((yyvsp[(2) - (5)].p),"pattern"));
+		    appendChild((yyval.node),(yyvsp[(4) - (5)].p));
+               ;}
+    break;
+
+  case 44:
+#line 1947 "parser.y"
+    {
+		 (yyval.node) = new_node("clear");
+		 appendChild((yyval.node),(yyvsp[(2) - (3)].p));
+               ;}
+    break;
+
+  case 45:
+#line 1961 "parser.y"
+    {
+		   if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) {
+		     SwigType *type = NewSwigType((yyvsp[(4) - (5)].dtype).type);
+		     (yyval.node) = new_node("constant");
+		     Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id));
+		     Setattr((yyval.node),"type",type);
+		     Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val);
+		     if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval);
+		     Setattr((yyval.node),"storage","%constant");
+		     SetFlag((yyval.node),"feature:immutable");
+		     add_symbols((yyval.node));
+		     Delete(type);
+		   } else {
+		     if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) {
+		       Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line,"Unsupported constant value (ignored)\n");
+		     }
+		     (yyval.node) = 0;
+		   }
+
+	       ;}
+    break;
+
+  case 46:
+#line 1981 "parser.y"
+    {
+		 if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) {
+		   SwigType_push((yyvsp[(2) - (5)].type),(yyvsp[(3) - (5)].decl).type);
+		   /* Sneaky callback function trick */
+		   if (SwigType_isfunction((yyvsp[(2) - (5)].type))) {
+		     SwigType_add_pointer((yyvsp[(2) - (5)].type));
+		   }
+		   (yyval.node) = new_node("constant");
+		   Setattr((yyval.node),"name",(yyvsp[(3) - (5)].decl).id);
+		   Setattr((yyval.node),"type",(yyvsp[(2) - (5)].type));
+		   Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val);
+		   if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval);
+		   Setattr((yyval.node),"storage","%constant");
+		   SetFlag((yyval.node),"feature:immutable");
+		   add_symbols((yyval.node));
+		 } else {
+		   if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) {
+		     Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line, "Unsupported constant value\n");
+		   }
+		   (yyval.node) = 0;
+		 }
+               ;}
+    break;
+
+  case 47:
+#line 2005 "parser.y"
+    {
+		 if (((yyvsp[(8) - (9)].dtype).type != T_ERROR) && ((yyvsp[(8) - (9)].dtype).type != T_SYMBOL)) {
+		   SwigType_add_function((yyvsp[(2) - (9)].type), (yyvsp[(5) - (9)].pl));
+		   SwigType_push((yyvsp[(2) - (9)].type), (yyvsp[(7) - (9)].dtype).qualifier);
+		   SwigType_push((yyvsp[(2) - (9)].type), (yyvsp[(3) - (9)].decl).type);
+		   /* Sneaky callback function trick */
+		   if (SwigType_isfunction((yyvsp[(2) - (9)].type))) {
+		     SwigType_add_pointer((yyvsp[(2) - (9)].type));
+		   }
+		   (yyval.node) = new_node("constant");
+		   Setattr((yyval.node), "name", (yyvsp[(3) - (9)].decl).id);
+		   Setattr((yyval.node), "type", (yyvsp[(2) - (9)].type));
+		   Setattr((yyval.node), "value", (yyvsp[(8) - (9)].dtype).val);
+		   if ((yyvsp[(8) - (9)].dtype).rawval) Setattr((yyval.node), "rawval", (yyvsp[(8) - (9)].dtype).rawval);
+		   Setattr((yyval.node), "storage", "%constant");
+		   SetFlag((yyval.node), "feature:immutable");
+		   add_symbols((yyval.node));
+		 } else {
+		   if ((yyvsp[(8) - (9)].dtype).type == T_ERROR) {
+		     Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line, "Unsupported constant value\n");
+		   }
+		   (yyval.node) = 0;
+		 }
+	       ;}
+    break;
+
+  case 48:
+#line 2029 "parser.y"
+    {
+		 Swig_warning(WARN_PARSE_BAD_VALUE,cparse_file,cparse_line,"Bad constant value (ignored).\n");
+		 (yyval.node) = 0;
+	       ;}
+    break;
+
+  case 49:
+#line 2033 "parser.y"
+    {
+		 Swig_error(cparse_file,cparse_line,"Missing semicolon (';') after %%constant.\n");
+		 Exit(EXIT_FAILURE);
+	       ;}
+    break;
+
+  case 50:
+#line 2044 "parser.y"
+    {
+		 char temp[64];
+		 Replace((yyvsp[(2) - (2)].str),"$file",cparse_file, DOH_REPLACE_ANY);
+		 sprintf(temp,"%d", cparse_line);
+		 Replace((yyvsp[(2) - (2)].str),"$line",temp,DOH_REPLACE_ANY);
+		 Printf(stderr,"%s\n", (yyvsp[(2) - (2)].str));
+		 Delete((yyvsp[(2) - (2)].str));
+                 (yyval.node) = 0;
+	       ;}
+    break;
+
+  case 51:
+#line 2053 "parser.y"
+    {
+		 char temp[64];
+		 String *s = (yyvsp[(2) - (2)].str);
+		 Replace(s,"$file",cparse_file, DOH_REPLACE_ANY);
+		 sprintf(temp,"%d", cparse_line);
+		 Replace(s,"$line",temp,DOH_REPLACE_ANY);
+		 Printf(stderr,"%s\n", s);
+		 Delete(s);
+                 (yyval.node) = 0;
+               ;}
+    break;
+
+  case 52:
+#line 2072 "parser.y"
+    {
+                    skip_balanced('{','}');
+		    (yyval.node) = 0;
+		    Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated.  Use %%exception instead.\n");
+	       ;}
+    break;
+
+  case 53:
+#line 2078 "parser.y"
+    {
+                    skip_balanced('{','}');
+		    (yyval.node) = 0;
+		    Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated.  Use %%exception instead.\n");
+               ;}
+    break;
+
+  case 54:
+#line 2084 "parser.y"
+    {
+		 (yyval.node) = 0;
+		 Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated.  Use %%exception instead.\n");
+               ;}
+    break;
+
+  case 55:
+#line 2089 "parser.y"
+    {
+		 (yyval.node) = 0;
+		 Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated.  Use %%exception instead.\n");
+	       ;}
+    break;
+
+  case 56:
+#line 2096 "parser.y"
+    {		 
+                 (yyval.node) = NewHash();
+                 Setattr((yyval.node),"value",(yyvsp[(1) - (4)].str));
+		 Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (4)].p),"type"));
+               ;}
+    break;
+
+  case 57:
+#line 2103 "parser.y"
+    {
+                 (yyval.node) = NewHash();
+                 Setattr((yyval.node),"value",(yyvsp[(1) - (1)].str));
+              ;}
+    break;
+
+  case 58:
+#line 2107 "parser.y"
+    {
+                (yyval.node) = (yyvsp[(1) - (1)].node);
+              ;}
+    break;
+
+  case 59:
+#line 2120 "parser.y"
+    {
+                   Hash *p = (yyvsp[(5) - (7)].node);
+		   (yyval.node) = new_node("fragment");
+		   Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value"));
+		   Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type"));
+		   Setattr((yyval.node),"section",Getattr(p,"name"));
+		   Setattr((yyval.node),"kwargs",nextSibling(p));
+		   Setattr((yyval.node),"code",(yyvsp[(7) - (7)].str));
+                 ;}
+    break;
+
+  case 60:
+#line 2129 "parser.y"
+    {
+		   Hash *p = (yyvsp[(5) - (7)].node);
+		   String *code;
+                   skip_balanced('{','}');
+		   (yyval.node) = new_node("fragment");
+		   Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value"));
+		   Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type"));
+		   Setattr((yyval.node),"section",Getattr(p,"name"));
+		   Setattr((yyval.node),"kwargs",nextSibling(p));
+		   Delitem(scanner_ccode,0);
+		   Delitem(scanner_ccode,DOH_END);
+		   code = Copy(scanner_ccode);
+		   Setattr((yyval.node),"code",code);
+		   Delete(code);
+                 ;}
+    break;
+
+  case 61:
+#line 2144 "parser.y"
+    {
+		   (yyval.node) = new_node("fragment");
+		   Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (5)].node),"value"));
+		   Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (5)].node),"type"));
+		   Setattr((yyval.node),"emitonly","1");
+		 ;}
+    break;
+
+  case 62:
+#line 2157 "parser.y"
+    {
+                     (yyvsp[(1) - (4)].loc).filename = Copy(cparse_file);
+		     (yyvsp[(1) - (4)].loc).line = cparse_line;
+		     scanner_set_location((yyvsp[(3) - (4)].str),1);
+                     if ((yyvsp[(2) - (4)].node)) { 
+		       String *maininput = Getattr((yyvsp[(2) - (4)].node), "maininput");
+		       if (maininput)
+		         scanner_set_main_input_file(NewString(maininput));
+		     }
+               ;}
+    break;
+
+  case 63:
+#line 2166 "parser.y"
+    {
+                     String *mname = 0;
+                     (yyval.node) = (yyvsp[(6) - (7)].node);
+		     scanner_set_location((yyvsp[(1) - (7)].loc).filename,(yyvsp[(1) - (7)].loc).line+1);
+		     if (strcmp((yyvsp[(1) - (7)].loc).type,"include") == 0) set_nodeType((yyval.node),"include");
+		     if (strcmp((yyvsp[(1) - (7)].loc).type,"import") == 0) {
+		       mname = (yyvsp[(2) - (7)].node) ? Getattr((yyvsp[(2) - (7)].node),"module") : 0;
+		       set_nodeType((yyval.node),"import");
+		       if (import_mode) --import_mode;
+		     }
+		     
+		     Setattr((yyval.node),"name",(yyvsp[(3) - (7)].str));
+		     /* Search for the module (if any) */
+		     {
+			 Node *n = firstChild((yyval.node));
+			 while (n) {
+			     if (Strcmp(nodeType(n),"module") == 0) {
+			         if (mname) {
+				   Setattr(n,"name", mname);
+				   mname = 0;
+				 }
+				 Setattr((yyval.node),"module",Getattr(n,"name"));
+				 break;
+			     }
+			     n = nextSibling(n);
+			 }
+			 if (mname) {
+			   /* There is no module node in the import
+			      node, ie, you imported a .h file
+			      directly.  We are forced then to create
+			      a new import node with a module node.
+			   */			      
+			   Node *nint = new_node("import");
+			   Node *mnode = new_node("module");
+			   Setattr(mnode,"name", mname);
+                           Setattr(mnode,"options",(yyvsp[(2) - (7)].node));
+			   appendChild(nint,mnode);
+			   Delete(mnode);
+			   appendChild(nint,firstChild((yyval.node)));
+			   (yyval.node) = nint;
+			   Setattr((yyval.node),"module",mname);
+			 }
+		     }
+		     Setattr((yyval.node),"options",(yyvsp[(2) - (7)].node));
+               ;}
+    break;
+
+  case 64:
+#line 2213 "parser.y"
+    { (yyval.loc).type = "include"; ;}
+    break;
+
+  case 65:
+#line 2214 "parser.y"
+    { (yyval.loc).type = "import"; ++import_mode;;}
+    break;
+
+  case 66:
+#line 2221 "parser.y"
+    {
+                 String *cpps;
+		 if (Namespaceprefix) {
+		   Swig_error(cparse_file, cparse_start_line, "%%inline directive inside a namespace is disallowed.\n");
+		   (yyval.node) = 0;
+		 } else {
+		   (yyval.node) = new_node("insert");
+		   Setattr((yyval.node),"code",(yyvsp[(2) - (2)].str));
+		   /* Need to run through the preprocessor */
+		   Seek((yyvsp[(2) - (2)].str),0,SEEK_SET);
+		   Setline((yyvsp[(2) - (2)].str),cparse_start_line);
+		   Setfile((yyvsp[(2) - (2)].str),cparse_file);
+		   cpps = Preprocessor_parse((yyvsp[(2) - (2)].str));
+		   start_inline(Char(cpps), cparse_start_line);
+		   Delete((yyvsp[(2) - (2)].str));
+		   Delete(cpps);
+		 }
+		 
+	       ;}
+    break;
+
+  case 67:
+#line 2240 "parser.y"
+    {
+                 String *cpps;
+		 int start_line = cparse_line;
+		 skip_balanced('{','}');
+		 if (Namespaceprefix) {
+		   Swig_error(cparse_file, cparse_start_line, "%%inline directive inside a namespace is disallowed.\n");
+		   
+		   (yyval.node) = 0;
+		 } else {
+		   String *code;
+                   (yyval.node) = new_node("insert");
+		   Delitem(scanner_ccode,0);
+		   Delitem(scanner_ccode,DOH_END);
+		   code = Copy(scanner_ccode);
+		   Setattr((yyval.node),"code", code);
+		   Delete(code);		   
+		   cpps=Copy(scanner_ccode);
+		   start_inline(Char(cpps), start_line);
+		   Delete(cpps);
+		 }
+               ;}
+    break;
+
+  case 68:
+#line 2271 "parser.y"
+    {
+                 (yyval.node) = new_node("insert");
+		 Setattr((yyval.node),"code",(yyvsp[(1) - (1)].str));
+	       ;}
+    break;
+
+  case 69:
+#line 2275 "parser.y"
+    {
+		 String *code = NewStringEmpty();
+		 (yyval.node) = new_node("insert");
+		 Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id));
+		 Setattr((yyval.node),"code",code);
+		 if (Swig_insert_file((yyvsp[(5) - (5)].str),code) < 0) {
+		   Swig_error(cparse_file, cparse_line, "Couldn't find '%s'.\n", (yyvsp[(5) - (5)].str));
+		   (yyval.node) = 0;
+		 } 
+               ;}
+    break;
+
+  case 70:
+#line 2285 "parser.y"
+    {
+		 (yyval.node) = new_node("insert");
+		 Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id));
+		 Setattr((yyval.node),"code",(yyvsp[(5) - (5)].str));
+               ;}
+    break;
+
+  case 71:
+#line 2290 "parser.y"
+    {
+		 String *code;
+                 skip_balanced('{','}');
+		 (yyval.node) = new_node("insert");
+		 Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id));
+		 Delitem(scanner_ccode,0);
+		 Delitem(scanner_ccode,DOH_END);
+		 code = Copy(scanner_ccode);
+		 Setattr((yyval.node),"code", code);
+		 Delete(code);
+	       ;}
+    break;
+
+  case 72:
+#line 2308 "parser.y"
+    {
+                 (yyval.node) = new_node("module");
+		 if ((yyvsp[(2) - (3)].node)) {
+		   Setattr((yyval.node),"options",(yyvsp[(2) - (3)].node));
+		   if (Getattr((yyvsp[(2) - (3)].node),"directors")) {
+		     Wrapper_director_mode_set(1);
+		     if (!cparse_cplusplus) {
+		       Swig_error(cparse_file, cparse_line, "Directors are not supported for C code and require the -c++ option\n");
+		     }
+		   } 
+		   if (Getattr((yyvsp[(2) - (3)].node),"dirprot")) {
+		     Wrapper_director_protected_mode_set(1);
+		   } 
+		   if (Getattr((yyvsp[(2) - (3)].node),"allprotected")) {
+		     Wrapper_all_protected_mode_set(1);
+		   } 
+		   if (Getattr((yyvsp[(2) - (3)].node),"templatereduce")) {
+		     template_reduce = 1;
+		   }
+		   if (Getattr((yyvsp[(2) - (3)].node),"notemplatereduce")) {
+		     template_reduce = 0;
+		   }
+		 }
+		 if (!ModuleName) ModuleName = NewString((yyvsp[(3) - (3)].id));
+		 if (!import_mode) {
+		   /* first module included, we apply global
+		      ModuleName, which can be modify by -module */
+		   String *mname = Copy(ModuleName);
+		   Setattr((yyval.node),"name",mname);
+		   Delete(mname);
+		 } else { 
+		   /* import mode, we just pass the idstring */
+		   Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id));   
+		 }		 
+		 if (!module_node) module_node = (yyval.node);
+	       ;}
+    break;
+
+  case 73:
+#line 2351 "parser.y"
+    {
+                 Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated.  Use %%rename instead.\n");
+		 Delete(yyrename);
+                 yyrename = NewString((yyvsp[(3) - (4)].id));
+		 (yyval.node) = 0;
+               ;}
+    break;
+
+  case 74:
+#line 2357 "parser.y"
+    {
+		 Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated.  Use %%rename instead.\n");
+		 (yyval.node) = 0;
+		 Swig_error(cparse_file,cparse_line,"Missing argument to %%name directive.\n");
+	       ;}
+    break;
+
+  case 75:
+#line 2370 "parser.y"
+    {
+                 (yyval.node) = new_node("native");
+		 Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id));
+		 Setattr((yyval.node),"wrap:name",(yyvsp[(6) - (7)].id));
+	         add_symbols((yyval.node));
+	       ;}
+    break;
+
+  case 76:
+#line 2376 "parser.y"
+    {
+		 if (!SwigType_isfunction((yyvsp[(7) - (8)].decl).type)) {
+		   Swig_error(cparse_file,cparse_line,"%%native declaration '%s' is not a function.\n", (yyvsp[(7) - (8)].decl).id);
+		   (yyval.node) = 0;
+		 } else {
+		     Delete(SwigType_pop_function((yyvsp[(7) - (8)].decl).type));
+		     /* Need check for function here */
+		     SwigType_push((yyvsp[(6) - (8)].type),(yyvsp[(7) - (8)].decl).type);
+		     (yyval.node) = new_node("native");
+	             Setattr((yyval.node),"name",(yyvsp[(3) - (8)].id));
+		     Setattr((yyval.node),"wrap:name",(yyvsp[(7) - (8)].decl).id);
+		     Setattr((yyval.node),"type",(yyvsp[(6) - (8)].type));
+		     Setattr((yyval.node),"parms",(yyvsp[(7) - (8)].decl).parms);
+		     Setattr((yyval.node),"decl",(yyvsp[(7) - (8)].decl).type);
+		 }
+	         add_symbols((yyval.node));
+	       ;}
+    break;
+
+  case 77:
+#line 2402 "parser.y"
+    {
+                 (yyval.node) = new_node("pragma");
+		 Setattr((yyval.node),"lang",(yyvsp[(2) - (5)].id));
+		 Setattr((yyval.node),"name",(yyvsp[(3) - (5)].id));
+		 Setattr((yyval.node),"value",(yyvsp[(5) - (5)].str));
+	       ;}
+    break;
+
+  case 78:
+#line 2408 "parser.y"
+    {
+		(yyval.node) = new_node("pragma");
+		Setattr((yyval.node),"lang",(yyvsp[(2) - (3)].id));
+		Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id));
+	      ;}
+    break;
+
+  case 79:
+#line 2415 "parser.y"
+    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
+    break;
+
+  case 80:
+#line 2416 "parser.y"
+    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
+    break;
+
+  case 81:
+#line 2419 "parser.y"
+    { (yyval.id) = (yyvsp[(2) - (3)].id); ;}
+    break;
+
+  case 82:
+#line 2420 "parser.y"
+    { (yyval.id) = (char *) "swig"; ;}
+    break;
+
+  case 83:
+#line 2427 "parser.y"
+    {
+                SwigType *t = (yyvsp[(2) - (4)].decl).type;
+		Hash *kws = NewHash();
+		String *fixname;
+		fixname = feature_identifier_fix((yyvsp[(2) - (4)].decl).id);
+		Setattr(kws,"name",(yyvsp[(3) - (4)].id));
+		if (!Len(t)) t = 0;
+		/* Special declarator check */
+		if (t) {
+		  if (SwigType_isfunction(t)) {
+		    SwigType *decl = SwigType_pop_function(t);
+		    if (SwigType_ispointer(t)) {
+		      String *nname = NewStringf("*%s",fixname);
+		      if ((yyvsp[(1) - (4)].intvalue)) {
+			Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(2) - (4)].decl).parms);
+		      } else {
+			Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws);
+		      }
+		      Delete(nname);
+		    } else {
+		      if ((yyvsp[(1) - (4)].intvalue)) {
+			Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(2) - (4)].decl).parms);
+		      } else {
+			Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws);
+		      }
+		    }
+		    Delete(decl);
+		  } else if (SwigType_ispointer(t)) {
+		    String *nname = NewStringf("*%s",fixname);
+		    if ((yyvsp[(1) - (4)].intvalue)) {
+		      Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(2) - (4)].decl).parms);
+		    } else {
+		      Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws);
+		    }
+		    Delete(nname);
+		  }
+		} else {
+		  if ((yyvsp[(1) - (4)].intvalue)) {
+		    Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(2) - (4)].decl).parms);
+		  } else {
+		    Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws);
+		  }
+		}
+                (yyval.node) = 0;
+		scanner_clear_rename();
+              ;}
+    break;
+
+  case 84:
+#line 2473 "parser.y"
+    {
+		String *fixname;
+		Hash *kws = (yyvsp[(3) - (7)].node);
+		SwigType *t = (yyvsp[(5) - (7)].decl).type;
+		fixname = feature_identifier_fix((yyvsp[(5) - (7)].decl).id);
+		if (!Len(t)) t = 0;
+		/* Special declarator check */
+		if (t) {
+		  if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier);
+		  if (SwigType_isfunction(t)) {
+		    SwigType *decl = SwigType_pop_function(t);
+		    if (SwigType_ispointer(t)) {
+		      String *nname = NewStringf("*%s",fixname);
+		      if ((yyvsp[(1) - (7)].intvalue)) {
+			Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(5) - (7)].decl).parms);
+		      } else {
+			Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws);
+		      }
+		      Delete(nname);
+		    } else {
+		      if ((yyvsp[(1) - (7)].intvalue)) {
+			Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(5) - (7)].decl).parms);
+		      } else {
+			Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws);
+		      }
+		    }
+		    Delete(decl);
+		  } else if (SwigType_ispointer(t)) {
+		    String *nname = NewStringf("*%s",fixname);
+		    if ((yyvsp[(1) - (7)].intvalue)) {
+		      Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(5) - (7)].decl).parms);
+		    } else {
+		      Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws);
+		    }
+		    Delete(nname);
+		  }
+		} else {
+		  if ((yyvsp[(1) - (7)].intvalue)) {
+		    Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(5) - (7)].decl).parms);
+		  } else {
+		    Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws);
+		  }
+		}
+                (yyval.node) = 0;
+		scanner_clear_rename();
+              ;}
+    break;
+
+  case 85:
+#line 2519 "parser.y"
+    {
+		if ((yyvsp[(1) - (6)].intvalue)) {
+		  Swig_name_rename_add(Namespaceprefix,(yyvsp[(5) - (6)].str),0,(yyvsp[(3) - (6)].node),0);
+		} else {
+		  Swig_name_namewarn_add(Namespaceprefix,(yyvsp[(5) - (6)].str),0,(yyvsp[(3) - (6)].node));
+		}
+		(yyval.node) = 0;
+		scanner_clear_rename();
+              ;}
+    break;
+
+  case 86:
+#line 2530 "parser.y"
+    {
+		    (yyval.intvalue) = 1;
+                ;}
+    break;
+
+  case 87:
+#line 2533 "parser.y"
+    {
+                    (yyval.intvalue) = 0;
+                ;}
+    break;
+
+  case 88:
+#line 2560 "parser.y"
+    {
+                    String *val = (yyvsp[(7) - (7)].str) ? NewString((yyvsp[(7) - (7)].str)) : NewString("1");
+                    new_feature((yyvsp[(3) - (7)].id), val, 0, (yyvsp[(5) - (7)].decl).id, (yyvsp[(5) - (7)].decl).type, (yyvsp[(5) - (7)].decl).parms, (yyvsp[(6) - (7)].dtype).qualifier);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 89:
+#line 2566 "parser.y"
+    {
+                    String *val = Len((yyvsp[(5) - (9)].str)) ? (yyvsp[(5) - (9)].str) : 0;
+                    new_feature((yyvsp[(3) - (9)].id), val, 0, (yyvsp[(7) - (9)].decl).id, (yyvsp[(7) - (9)].decl).type, (yyvsp[(7) - (9)].decl).parms, (yyvsp[(8) - (9)].dtype).qualifier);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 90:
+#line 2572 "parser.y"
+    {
+                    String *val = (yyvsp[(8) - (8)].str) ? NewString((yyvsp[(8) - (8)].str)) : NewString("1");
+                    new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(4) - (8)].node), (yyvsp[(6) - (8)].decl).id, (yyvsp[(6) - (8)].decl).type, (yyvsp[(6) - (8)].decl).parms, (yyvsp[(7) - (8)].dtype).qualifier);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 91:
+#line 2578 "parser.y"
+    {
+                    String *val = Len((yyvsp[(5) - (10)].str)) ? (yyvsp[(5) - (10)].str) : 0;
+                    new_feature((yyvsp[(3) - (10)].id), val, (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].decl).id, (yyvsp[(8) - (10)].decl).type, (yyvsp[(8) - (10)].decl).parms, (yyvsp[(9) - (10)].dtype).qualifier);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 92:
+#line 2586 "parser.y"
+    {
+                    String *val = (yyvsp[(5) - (5)].str) ? NewString((yyvsp[(5) - (5)].str)) : NewString("1");
+                    new_feature((yyvsp[(3) - (5)].id), val, 0, 0, 0, 0, 0);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 93:
+#line 2592 "parser.y"
+    {
+                    String *val = Len((yyvsp[(5) - (7)].str)) ? (yyvsp[(5) - (7)].str) : 0;
+                    new_feature((yyvsp[(3) - (7)].id), val, 0, 0, 0, 0, 0);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 94:
+#line 2598 "parser.y"
+    {
+                    String *val = (yyvsp[(6) - (6)].str) ? NewString((yyvsp[(6) - (6)].str)) : NewString("1");
+                    new_feature((yyvsp[(3) - (6)].id), val, (yyvsp[(4) - (6)].node), 0, 0, 0, 0);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 95:
+#line 2604 "parser.y"
+    {
+                    String *val = Len((yyvsp[(5) - (8)].str)) ? (yyvsp[(5) - (8)].str) : 0;
+                    new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(6) - (8)].node), 0, 0, 0, 0);
+                    (yyval.node) = 0;
+                    scanner_clear_rename();
+                  ;}
+    break;
+
+  case 96:
+#line 2612 "parser.y"
+    { (yyval.str) = (yyvsp[(1) - (1)].str); ;}
+    break;
+
+  case 97:
+#line 2613 "parser.y"
+    { (yyval.str) = 0; ;}
+    break;
+
+  case 98:
+#line 2614 "parser.y"
+    { (yyval.str) = (yyvsp[(3) - (5)].pl); ;}
+    break;
+
+  case 99:
+#line 2617 "parser.y"
+    {
+		  (yyval.node) = NewHash();
+		  Setattr((yyval.node),"name",(yyvsp[(2) - (4)].id));
+		  Setattr((yyval.node),"value",(yyvsp[(4) - (4)].str));
+                ;}
+    break;
+
+  case 100:
+#line 2622 "parser.y"
+    {
+		  (yyval.node) = NewHash();
+		  Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id));
+		  Setattr((yyval.node),"value",(yyvsp[(4) - (5)].str));
+                  set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+                ;}
+    break;
+
+  case 101:
+#line 2632 "parser.y"
+    {
+                 Parm *val;
+		 String *name;
+		 SwigType *t;
+		 if (Namespaceprefix) name = NewStringf("%s::%s", Namespaceprefix, (yyvsp[(5) - (7)].decl).id);
+		 else name = NewString((yyvsp[(5) - (7)].decl).id);
+		 val = (yyvsp[(3) - (7)].pl);
+		 if ((yyvsp[(5) - (7)].decl).parms) {
+		   Setmeta(val,"parms",(yyvsp[(5) - (7)].decl).parms);
+		 }
+		 t = (yyvsp[(5) - (7)].decl).type;
+		 if (!Len(t)) t = 0;
+		 if (t) {
+		   if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier);
+		   if (SwigType_isfunction(t)) {
+		     SwigType *decl = SwigType_pop_function(t);
+		     if (SwigType_ispointer(t)) {
+		       String *nname = NewStringf("*%s",name);
+		       Swig_feature_set(Swig_cparse_features(), nname, decl, "feature:varargs", val, 0);
+		       Delete(nname);
+		     } else {
+		       Swig_feature_set(Swig_cparse_features(), name, decl, "feature:varargs", val, 0);
+		     }
+		     Delete(decl);
+		   } else if (SwigType_ispointer(t)) {
+		     String *nname = NewStringf("*%s",name);
+		     Swig_feature_set(Swig_cparse_features(),nname,0,"feature:varargs",val, 0);
+		     Delete(nname);
+		   }
+		 } else {
+		   Swig_feature_set(Swig_cparse_features(),name,0,"feature:varargs",val, 0);
+		 }
+		 Delete(name);
+		 (yyval.node) = 0;
+              ;}
+    break;
+
+  case 102:
+#line 2668 "parser.y"
+    { (yyval.pl) = (yyvsp[(1) - (1)].pl); ;}
+    break;
+
+  case 103:
+#line 2669 "parser.y"
+    { 
+		  int i;
+		  int n;
+		  Parm *p;
+		  n = atoi(Char((yyvsp[(1) - (3)].dtype).val));
+		  if (n <= 0) {
+		    Swig_error(cparse_file, cparse_line,"Argument count in %%varargs must be positive.\n");
+		    (yyval.pl) = 0;
+		  } else {
+		    String *name = Getattr((yyvsp[(3) - (3)].p), "name");
+		    (yyval.pl) = Copy((yyvsp[(3) - (3)].p));
+		    if (name)
+		      Setattr((yyval.pl), "name", NewStringf("%s%d", name, n));
+		    for (i = 1; i < n; i++) {
+		      p = Copy((yyvsp[(3) - (3)].p));
+		      name = Getattr(p, "name");
+		      if (name)
+		        Setattr(p, "name", NewStringf("%s%d", name, n-i));
+		      set_nextSibling(p,(yyval.pl));
+		      Delete((yyval.pl));
+		      (yyval.pl) = p;
+		    }
+		  }
+                ;}
+    break;
+
+  case 104:
+#line 2704 "parser.y"
+    {
+		   (yyval.node) = 0;
+		   if ((yyvsp[(3) - (6)].tmap).method) {
+		     String *code = 0;
+		     (yyval.node) = new_node("typemap");
+		     Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method);
+		     if ((yyvsp[(3) - (6)].tmap).kwargs) {
+		       ParmList *kw = (yyvsp[(3) - (6)].tmap).kwargs;
+                       code = remove_block(kw, (yyvsp[(6) - (6)].str));
+		       Setattr((yyval.node),"kwargs", (yyvsp[(3) - (6)].tmap).kwargs);
+		     }
+		     code = code ? code : NewString((yyvsp[(6) - (6)].str));
+		     Setattr((yyval.node),"code", code);
+		     Delete(code);
+		     appendChild((yyval.node),(yyvsp[(5) - (6)].p));
+		   }
+	       ;}
+    break;
+
+  case 105:
+#line 2721 "parser.y"
+    {
+		 (yyval.node) = 0;
+		 if ((yyvsp[(3) - (6)].tmap).method) {
+		   (yyval.node) = new_node("typemap");
+		   Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method);
+		   appendChild((yyval.node),(yyvsp[(5) - (6)].p));
+		 }
+	       ;}
+    break;
+
+  case 106:
+#line 2729 "parser.y"
+    {
+		   (yyval.node) = 0;
+		   if ((yyvsp[(3) - (8)].tmap).method) {
+		     (yyval.node) = new_node("typemapcopy");
+		     Setattr((yyval.node),"method",(yyvsp[(3) - (8)].tmap).method);
+		     Setattr((yyval.node),"pattern", Getattr((yyvsp[(7) - (8)].p),"pattern"));
+		     appendChild((yyval.node),(yyvsp[(5) - (8)].p));
+		   }
+	       ;}
+    break;
+
+  case 107:
+#line 2742 "parser.y"
+    {
+		 String *name = Getattr((yyvsp[(1) - (1)].node), "name");
+		 Hash *p = nextSibling((yyvsp[(1) - (1)].node));
+		 (yyval.tmap).method = name;
+		 (yyval.tmap).kwargs = p;
+		 if (Getattr((yyvsp[(1) - (1)].node), "value")) {
+		   Swig_error(cparse_file, cparse_line,
+			      "%%typemap method shouldn't have a value specified.\n");
+		 }
+		 while (p) {
+		   if (!Getattr(p, "value")) {
+		     Swig_error(cparse_file, cparse_line,
+				"%%typemap attribute '%s' is missing its value.  If this is specifying the target language, that's no longer supported: use #ifdef SWIG<LANG> instead.\n",
+				Getattr(p, "name"));
+		     /* Set to empty value to avoid segfaults later. */
+		     Setattr(p, "value", NewStringEmpty());
+		   }
+		   p = nextSibling(p);
+		 }
+                ;}
+    break;
+
+  case 108:
+#line 2764 "parser.y"
+    {
+                 (yyval.p) = (yyvsp[(1) - (2)].p);
+		 set_nextSibling((yyval.p),(yyvsp[(2) - (2)].p));
+		;}
+    break;
+
+  case 109:
+#line 2770 "parser.y"
+    {
+                 (yyval.p) = (yyvsp[(2) - (3)].p);
+		 set_nextSibling((yyval.p),(yyvsp[(3) - (3)].p));
+                ;}
+    break;
+
+  case 110:
+#line 2774 "parser.y"
+    { (yyval.p) = 0;;}
+    break;
+
+  case 111:
+#line 2777 "parser.y"
+    {
+                  Parm *parm;
+		  SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type);
+		  (yyval.p) = new_node("typemapitem");
+		  parm = NewParmWithoutFileLineInfo((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id);
+		  Setattr((yyval.p),"pattern",parm);
+		  Setattr((yyval.p),"parms", (yyvsp[(2) - (2)].decl).parms);
+		  Delete(parm);
+		  /*		  $$ = NewParmWithoutFileLineInfo($1,$2.id);
+				  Setattr($$,"parms",$2.parms); */
+                ;}
+    break;
+
+  case 112:
+#line 2788 "parser.y"
+    {
+                  (yyval.p) = new_node("typemapitem");
+		  Setattr((yyval.p),"pattern",(yyvsp[(2) - (3)].pl));
+		  /*		  Setattr($$,"multitype",$2); */
+               ;}
+    break;
+
+  case 113:
+#line 2793 "parser.y"
+    {
+		 (yyval.p) = new_node("typemapitem");
+		 Setattr((yyval.p),"pattern", (yyvsp[(2) - (6)].pl));
+		 /*                 Setattr($$,"multitype",$2); */
+		 Setattr((yyval.p),"parms",(yyvsp[(5) - (6)].pl));
+               ;}
+    break;
+
+  case 114:
+#line 2806 "parser.y"
+    {
+                   (yyval.node) = new_node("types");
+		   Setattr((yyval.node),"parms",(yyvsp[(3) - (5)].pl));
+                   if ((yyvsp[(5) - (5)].str))
+		     Setattr((yyval.node),"convcode",NewString((yyvsp[(5) - (5)].str)));
+               ;}
+    break;
+
+  case 115:
+#line 2818 "parser.y"
+    {
+                  Parm *p, *tp;
+		  Node *n;
+		  Node *outer_class = currentOuterClass;
+		  Symtab *tscope = 0;
+		  int     specialized = 0;
+		  int     variadic = 0;
+
+		  (yyval.node) = 0;
+
+		  tscope = Swig_symbol_current();          /* Get the current scope */
+
+		  /* If the class name is qualified, we need to create or lookup namespace entries */
+		  (yyvsp[(5) - (9)].str) = resolve_create_node_scope((yyvsp[(5) - (9)].str), 0);
+
+		  if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) {
+		    outer_class	= nscope_inner;
+		  }
+
+		  /*
+		    We use the new namespace entry 'nscope' only to
+		    emit the template node. The template parameters are
+		    resolved in the current 'tscope'.
+
+		    This is closer to the C++ (typedef) behavior.
+		  */
+		  n = Swig_cparse_template_locate((yyvsp[(5) - (9)].str),(yyvsp[(7) - (9)].p),tscope);
+
+		  /* Patch the argument types to respect namespaces */
+		  p = (yyvsp[(7) - (9)].p);
+		  while (p) {
+		    SwigType *value = Getattr(p,"value");
+		    if (!value) {
+		      SwigType *ty = Getattr(p,"type");
+		      if (ty) {
+			SwigType *rty = 0;
+			int reduce = template_reduce;
+			if (reduce || !SwigType_ispointer(ty)) {
+			  rty = Swig_symbol_typedef_reduce(ty,tscope);
+			  if (!reduce) reduce = SwigType_ispointer(rty);
+			}
+			ty = reduce ? Swig_symbol_type_qualify(rty,tscope) : Swig_symbol_type_qualify(ty,tscope);
+			Setattr(p,"type",ty);
+			Delete(ty);
+			Delete(rty);
+		      }
+		    } else {
+		      value = Swig_symbol_type_qualify(value,tscope);
+		      Setattr(p,"value",value);
+		      Delete(value);
+		    }
+
+		    p = nextSibling(p);
+		  }
+
+		  /* Look for the template */
+		  {
+                    Node *nn = n;
+                    Node *linklistend = 0;
+                    Node *linkliststart = 0;
+                    while (nn) {
+                      Node *templnode = 0;
+                      if (Strcmp(nodeType(nn),"template") == 0) {
+                        int nnisclass = (Strcmp(Getattr(nn,"templatetype"),"class") == 0); /* if not a templated class it is a templated function */
+                        Parm *tparms = Getattr(nn,"templateparms");
+                        if (!tparms) {
+                          specialized = 1;
+                        } else if (Getattr(tparms,"variadic") && strncmp(Char(Getattr(tparms,"variadic")), "1", 1)==0) {
+                          variadic = 1;
+                        }
+                        if (nnisclass && !variadic && !specialized && (ParmList_len((yyvsp[(7) - (9)].p)) > ParmList_len(tparms))) {
+                          Swig_error(cparse_file, cparse_line, "Too many template parameters. Maximum of %d.\n", ParmList_len(tparms));
+                        } else if (nnisclass && !specialized && ((ParmList_len((yyvsp[(7) - (9)].p)) < (ParmList_numrequired(tparms) - (variadic?1:0))))) { /* Variadic parameter is optional */
+                          Swig_error(cparse_file, cparse_line, "Not enough template parameters specified. %d required.\n", (ParmList_numrequired(tparms)-(variadic?1:0)) );
+                        } else if (!nnisclass && ((ParmList_len((yyvsp[(7) - (9)].p)) != ParmList_len(tparms)))) {
+                          /* must be an overloaded templated method - ignore it as it is overloaded with a different number of template parameters */
+                          nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions */
+                          continue;
+                        } else {
+			  String *tname = Copy((yyvsp[(5) - (9)].str));
+                          int def_supplied = 0;
+                          /* Expand the template */
+			  Node *templ = Swig_symbol_clookup((yyvsp[(5) - (9)].str),0);
+			  Parm *targs = templ ? Getattr(templ,"templateparms") : 0;
+
+                          ParmList *temparms;
+                          if (specialized) temparms = CopyParmList((yyvsp[(7) - (9)].p));
+                          else temparms = CopyParmList(tparms);
+
+                          /* Create typedef's and arguments */
+                          p = (yyvsp[(7) - (9)].p);
+                          tp = temparms;
+                          if (!p && ParmList_len(p) != ParmList_len(temparms)) {
+                            /* we have no template parameters supplied in %template for a template that has default args*/
+                            p = tp;
+                            def_supplied = 1;
+                          }
+
+                          while (p) {
+                            String *value = Getattr(p,"value");
+                            if (def_supplied) {
+                              Setattr(p,"default","1");
+                            }
+                            if (value) {
+                              Setattr(tp,"value",value);
+                            } else {
+                              SwigType *ty = Getattr(p,"type");
+                              if (ty) {
+                                Setattr(tp,"type",ty);
+                              }
+                              Delattr(tp,"value");
+                            }
+			    /* fix default arg values */
+			    if (targs) {
+			      Parm *pi = temparms;
+			      Parm *ti = targs;
+			      String *tv = Getattr(tp,"value");
+			      if (!tv) tv = Getattr(tp,"type");
+			      while(pi != tp && ti && pi) {
+				String *name = Getattr(ti,"name");
+				String *value = Getattr(pi,"value");
+				if (!value) value = Getattr(pi,"type");
+				Replaceid(tv, name, value);
+				pi = nextSibling(pi);
+				ti = nextSibling(ti);
+			      }
+			    }
+                            p = nextSibling(p);
+                            tp = nextSibling(tp);
+                            if (!p && tp) {
+                              p = tp;
+                              def_supplied = 1;
+                            } else if (p && !tp) { /* Variadic template - tp < p */
+			      SWIG_WARN_NODE_BEGIN(nn);
+                              Swig_warning(WARN_CPP11_VARIADIC_TEMPLATE,cparse_file, cparse_line,"Only the first variadic template argument is currently supported.\n");
+			      SWIG_WARN_NODE_END(nn);
+                              break;
+                            }
+                          }
+
+                          templnode = copy_node(nn);
+			  update_nested_classes(templnode); /* update classes nested within template */
+                          /* We need to set the node name based on name used to instantiate */
+                          Setattr(templnode,"name",tname);
+			  Delete(tname);
+                          if (!specialized) {
+                            Delattr(templnode,"sym:typename");
+                          } else {
+                            Setattr(templnode,"sym:typename","1");
+                          }
+			  /* for now, nested %template is allowed only in the same scope as the template declaration */
+                          if ((yyvsp[(3) - (9)].id) && !(nnisclass && ((outer_class && (outer_class != Getattr(nn, "nested:outer")))
+			    ||(extendmode && current_class && (current_class != Getattr(nn, "nested:outer")))))) {
+			    /*
+			       Comment this out for 1.3.28. We need to
+			       re-enable it later but first we need to
+			       move %ignore from using %rename to use
+			       %feature(ignore).
+
+			       String *symname = Swig_name_make(templnode,0,$3,0,0);
+			    */
+			    String *symname = NewString((yyvsp[(3) - (9)].id));
+                            Swig_cparse_template_expand(templnode,symname,temparms,tscope);
+                            Setattr(templnode,"sym:name",symname);
+                          } else {
+                            static int cnt = 0;
+                            String *nname = NewStringf("__dummy_%d__", cnt++);
+                            Swig_cparse_template_expand(templnode,nname,temparms,tscope);
+                            Setattr(templnode,"sym:name",nname);
+                            SetFlag(templnode,"hidden");
+			    Delete(nname);
+                            Setattr(templnode,"feature:onlychildren", "typemap,typemapitem,typemapcopy,typedef,types,fragment,apply");
+			    if ((yyvsp[(3) - (9)].id)) {
+			      Swig_warning(WARN_PARSE_NESTED_TEMPLATE, cparse_file, cparse_line, "Named nested template instantiations not supported. Processing as if no name was given to %%template().\n");
+			    }
+                          }
+                          Delattr(templnode,"templatetype");
+                          Setattr(templnode,"template",nn);
+                          Setfile(templnode,cparse_file);
+                          Setline(templnode,cparse_line);
+                          Delete(temparms);
+			  if (outer_class && nnisclass) {
+			    SetFlag(templnode, "nested");
+			    Setattr(templnode, "nested:outer", outer_class);
+			  }
+                          add_symbols_copy(templnode);
+
+                          if (Strcmp(nodeType(templnode),"class") == 0) {
+
+                            /* Identify pure abstract methods */
+                            Setattr(templnode,"abstracts", pure_abstracts(firstChild(templnode)));
+
+                            /* Set up inheritance in symbol table */
+                            {
+                              Symtab  *csyms;
+                              List *baselist = Getattr(templnode,"baselist");
+                              csyms = Swig_symbol_current();
+                              Swig_symbol_setscope(Getattr(templnode,"symtab"));
+                              if (baselist) {
+                                List *bases = Swig_make_inherit_list(Getattr(templnode,"name"),baselist, Namespaceprefix);
+                                if (bases) {
+                                  Iterator s;
+                                  for (s = First(bases); s.item; s = Next(s)) {
+                                    Symtab *st = Getattr(s.item,"symtab");
+                                    if (st) {
+				      Setfile(st,Getfile(s.item));
+				      Setline(st,Getline(s.item));
+                                      Swig_symbol_inherit(st);
+                                    }
+                                  }
+				  Delete(bases);
+                                }
+                              }
+                              Swig_symbol_setscope(csyms);
+                            }
+
+                            /* Merge in %extend methods for this class.
+			       This only merges methods within %extend for a template specialized class such as
+			         template<typename T> class K {}; %extend K<int> { ... }
+			       The copy_node() call above has already added in the generic %extend methods such as
+			         template<typename T> class K {}; %extend K { ... } */
+
+			    /* !!! This may be broken.  We may have to add the
+			       %extend methods at the beginning of the class */
+                            {
+                              String *stmp = 0;
+                              String *clsname;
+                              Node *am;
+                              if (Namespaceprefix) {
+                                clsname = stmp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
+                              } else {
+                                clsname = Getattr(templnode,"name");
+                              }
+                              am = Getattr(Swig_extend_hash(),clsname);
+                              if (am) {
+                                Symtab *st = Swig_symbol_current();
+                                Swig_symbol_setscope(Getattr(templnode,"symtab"));
+                                /*			    Printf(stdout,"%s: %s %p %p\n", Getattr(templnode,"name"), clsname, Swig_symbol_current(), Getattr(templnode,"symtab")); */
+                                Swig_extend_merge(templnode,am);
+                                Swig_symbol_setscope(st);
+				Swig_extend_append_previous(templnode,am);
+                                Delattr(Swig_extend_hash(),clsname);
+                              }
+			      if (stmp) Delete(stmp);
+                            }
+
+                            /* Add to classes hash */
+			    if (!classes)
+			      classes = NewHash();
+
+			    if (Namespaceprefix) {
+			      String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
+			      Setattr(classes,temp,templnode);
+			      Delete(temp);
+			    } else {
+			      String *qs = Swig_symbol_qualifiedscopename(templnode);
+			      Setattr(classes, qs,templnode);
+			      Delete(qs);
+			    }
+                          }
+                        }
+
+                        /* all the overloaded templated functions are added into a linked list */
+                        if (!linkliststart)
+                          linkliststart = templnode;
+                        if (nscope_inner) {
+                          /* non-global namespace */
+                          if (templnode) {
+                            appendChild(nscope_inner,templnode);
+			    Delete(templnode);
+                            if (nscope) (yyval.node) = nscope;
+                          }
+                        } else {
+                          /* global namespace */
+                          if (!linklistend) {
+                            (yyval.node) = templnode;
+                          } else {
+                            set_nextSibling(linklistend,templnode);
+			    Delete(templnode);
+                          }
+                          linklistend = templnode;
+                        }
+                      }
+                      nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions. If a templated class there will never be a sibling. */
+                    }
+                    update_defaultargs(linkliststart);
+                    update_abstracts(linkliststart);
+		  }
+	          Swig_symbol_setscope(tscope);
+		  Delete(Namespaceprefix);
+		  Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+                ;}
+    break;
+
+  case 116:
+#line 3117 "parser.y"
+    {
+		  Swig_warning(0,cparse_file, cparse_line,"%s\n", (yyvsp[(2) - (2)].str));
+		  (yyval.node) = 0;
+               ;}
+    break;
+
+  case 117:
+#line 3127 "parser.y"
+    {
+                    (yyval.node) = (yyvsp[(1) - (1)].node); 
+                    if ((yyval.node)) {
+   		      add_symbols((yyval.node));
+                      default_arguments((yyval.node));
+   	            }
+                ;}
+    break;
+
+  case 118:
+#line 3134 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 119:
+#line 3135 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 120:
+#line 3139 "parser.y"
+    {
+		  if (Strcmp((yyvsp[(2) - (3)].str),"C") == 0) {
+		    cparse_externc = 1;
+		  }
+		;}
+    break;
+
+  case 121:
+#line 3143 "parser.y"
+    {
+		  cparse_externc = 0;
+		  if (Strcmp((yyvsp[(2) - (6)].str),"C") == 0) {
+		    Node *n = firstChild((yyvsp[(5) - (6)].node));
+		    (yyval.node) = new_node("extern");
+		    Setattr((yyval.node),"name",(yyvsp[(2) - (6)].str));
+		    appendChild((yyval.node),n);
+		    while (n) {
+		      String *s = Getattr(n, "storage");
+		      if (s) {
+			if (Strstr(s, "thread_local")) {
+			  Insert(s,0,"externc ");
+			} else if (!Equal(s, "typedef")) {
+			  Setattr(n,"storage","externc");
+			}
+		      } else {
+			Setattr(n,"storage","externc");
+		      }
+		      n = nextSibling(n);
+		    }
+		  } else {
+		    if (!Equal((yyvsp[(2) - (6)].str),"C++")) {
+		      Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (6)].str));
+		    }
+		    (yyval.node) = new_node("extern");
+		    Setattr((yyval.node),"name",(yyvsp[(2) - (6)].str));
+		    appendChild((yyval.node),firstChild((yyvsp[(5) - (6)].node)));
+		  }
+                ;}
+    break;
+
+  case 122:
+#line 3172 "parser.y"
+    {
+		  (yyval.node) = (yyvsp[(1) - (1)].node);
+		  SWIG_WARN_NODE_BEGIN((yyval.node));
+		  Swig_warning(WARN_CPP11_LAMBDA, cparse_file, cparse_line, "Lambda expressions and closures are not fully supported yet.\n");
+		  SWIG_WARN_NODE_END((yyval.node));
+		;}
+    break;
+
+  case 123:
+#line 3178 "parser.y"
+    {
+		  /* Convert using statement to a typedef statement */
+		  (yyval.node) = new_node("cdecl");
+		  Setattr((yyval.node),"type",(yyvsp[(4) - (6)].type));
+		  Setattr((yyval.node),"storage","typedef");
+		  Setattr((yyval.node),"name",(yyvsp[(2) - (6)].str));
+		  Setattr((yyval.node),"decl",(yyvsp[(5) - (6)].decl).type);
+		  SetFlag((yyval.node),"typealias");
+		  add_symbols((yyval.node));
+		;}
+    break;
+
+  case 124:
+#line 3188 "parser.y"
+    {
+		  /* Convert alias template to a "template" typedef statement */
+		  (yyval.node) = new_node("template");
+		  Setattr((yyval.node),"type",(yyvsp[(8) - (10)].type));
+		  Setattr((yyval.node),"storage","typedef");
+		  Setattr((yyval.node),"name",(yyvsp[(6) - (10)].str));
+		  Setattr((yyval.node),"decl",(yyvsp[(9) - (10)].decl).type);
+		  Setattr((yyval.node),"templateparms",(yyvsp[(3) - (10)].tparms));
+		  Setattr((yyval.node),"templatetype","cdecl");
+		  SetFlag((yyval.node),"aliastemplate");
+		  add_symbols((yyval.node));
+		;}
+    break;
+
+  case 125:
+#line 3200 "parser.y"
+    {
+                   (yyval.node) = (yyvsp[(1) - (1)].node);
+                ;}
+    break;
+
+  case 126:
+#line 3209 "parser.y"
+    {
+	      String *decl = (yyvsp[(3) - (6)].decl).type;
+              (yyval.node) = new_node("cdecl");
+	      if ((yyvsp[(4) - (6)].dtype).qualifier)
+	        decl = add_qualifier_to_declarator((yyvsp[(3) - (6)].decl).type, (yyvsp[(4) - (6)].dtype).qualifier);
+	      Setattr((yyval.node),"refqualifier",(yyvsp[(4) - (6)].dtype).refqualifier);
+	      Setattr((yyval.node),"type",(yyvsp[(2) - (6)].type));
+	      Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id));
+	      Setattr((yyval.node),"name",(yyvsp[(3) - (6)].decl).id);
+	      Setattr((yyval.node),"decl",decl);
+	      Setattr((yyval.node),"parms",(yyvsp[(3) - (6)].decl).parms);
+	      Setattr((yyval.node),"value",(yyvsp[(5) - (6)].dtype).val);
+	      Setattr((yyval.node),"throws",(yyvsp[(4) - (6)].dtype).throws);
+	      Setattr((yyval.node),"throw",(yyvsp[(4) - (6)].dtype).throwf);
+	      Setattr((yyval.node),"noexcept",(yyvsp[(4) - (6)].dtype).nexcept);
+	      Setattr((yyval.node),"final",(yyvsp[(4) - (6)].dtype).final);
+	      if ((yyvsp[(5) - (6)].dtype).val && (yyvsp[(5) - (6)].dtype).type) {
+		/* store initializer type as it might be different to the declared type */
+		SwigType *valuetype = NewSwigType((yyvsp[(5) - (6)].dtype).type);
+		if (Len(valuetype) > 0)
+		  Setattr((yyval.node),"valuetype",valuetype);
+		else
+		  Delete(valuetype);
+	      }
+	      if (!(yyvsp[(6) - (6)].node)) {
+		if (Len(scanner_ccode)) {
+		  String *code = Copy(scanner_ccode);
+		  Setattr((yyval.node),"code",code);
+		  Delete(code);
+		}
+	      } else {
+		Node *n = (yyvsp[(6) - (6)].node);
+		/* Inherit attributes */
+		while (n) {
+		  String *type = Copy((yyvsp[(2) - (6)].type));
+		  Setattr(n,"type",type);
+		  Setattr(n,"storage",(yyvsp[(1) - (6)].id));
+		  n = nextSibling(n);
+		  Delete(type);
+		}
+	      }
+	      if ((yyvsp[(5) - (6)].dtype).bitfield) {
+		Setattr((yyval.node),"bitfield", (yyvsp[(5) - (6)].dtype).bitfield);
+	      }
+
+	      if ((yyvsp[(3) - (6)].decl).id) {
+		/* Look for "::" declarations (ignored) */
+		if (Strstr((yyvsp[(3) - (6)].decl).id, "::")) {
+		  /* This is a special case. If the scope name of the declaration exactly
+		     matches that of the declaration, then we will allow it. Otherwise, delete. */
+		  String *p = Swig_scopename_prefix((yyvsp[(3) - (6)].decl).id);
+		  if (p) {
+		    if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) ||
+			(Classprefix && Strcmp(p, Classprefix) == 0)) {
+		      String *lstr = Swig_scopename_last((yyvsp[(3) - (6)].decl).id);
+		      Setattr((yyval.node), "name", lstr);
+		      Delete(lstr);
+		      set_nextSibling((yyval.node), (yyvsp[(6) - (6)].node));
+		    } else {
+		      Delete((yyval.node));
+		      (yyval.node) = (yyvsp[(6) - (6)].node);
+		    }
+		    Delete(p);
+		  } else {
+		    Delete((yyval.node));
+		    (yyval.node) = (yyvsp[(6) - (6)].node);
+		  }
+		} else {
+		  set_nextSibling((yyval.node), (yyvsp[(6) - (6)].node));
+		}
+	      } else {
+		Swig_error(cparse_file, cparse_line, "Missing symbol name for global declaration\n");
+		(yyval.node) = 0;
+	      }
+
+	      if ((yyvsp[(4) - (6)].dtype).qualifier && (yyvsp[(1) - (6)].id) && Strstr((yyvsp[(1) - (6)].id), "static"))
+		Swig_error(cparse_file, cparse_line, "Static function %s cannot have a qualifier.\n", Swig_name_decl((yyval.node)));
+           ;}
+    break;
+
+  case 127:
+#line 3289 "parser.y"
+    {
+              (yyval.node) = new_node("cdecl");
+	      if ((yyvsp[(4) - (9)].dtype).qualifier) SwigType_push((yyvsp[(3) - (9)].decl).type, (yyvsp[(4) - (9)].dtype).qualifier);
+	      Setattr((yyval.node),"refqualifier",(yyvsp[(4) - (9)].dtype).refqualifier);
+	      Setattr((yyval.node),"type",(yyvsp[(6) - (9)].node));
+	      Setattr((yyval.node),"storage",(yyvsp[(1) - (9)].id));
+	      Setattr((yyval.node),"name",(yyvsp[(3) - (9)].decl).id);
+	      Setattr((yyval.node),"decl",(yyvsp[(3) - (9)].decl).type);
+	      Setattr((yyval.node),"parms",(yyvsp[(3) - (9)].decl).parms);
+	      Setattr((yyval.node),"value",(yyvsp[(4) - (9)].dtype).val);
+	      Setattr((yyval.node),"throws",(yyvsp[(4) - (9)].dtype).throws);
+	      Setattr((yyval.node),"throw",(yyvsp[(4) - (9)].dtype).throwf);
+	      Setattr((yyval.node),"noexcept",(yyvsp[(4) - (9)].dtype).nexcept);
+	      Setattr((yyval.node),"final",(yyvsp[(4) - (9)].dtype).final);
+	      if (!(yyvsp[(9) - (9)].node)) {
+		if (Len(scanner_ccode)) {
+		  String *code = Copy(scanner_ccode);
+		  Setattr((yyval.node),"code",code);
+		  Delete(code);
+		}
+	      } else {
+		Node *n = (yyvsp[(9) - (9)].node);
+		while (n) {
+		  String *type = Copy((yyvsp[(6) - (9)].node));
+		  Setattr(n,"type",type);
+		  Setattr(n,"storage",(yyvsp[(1) - (9)].id));
+		  n = nextSibling(n);
+		  Delete(type);
+		}
+	      }
+	      if ((yyvsp[(4) - (9)].dtype).bitfield) {
+		Setattr((yyval.node),"bitfield", (yyvsp[(4) - (9)].dtype).bitfield);
+	      }
+
+	      if (Strstr((yyvsp[(3) - (9)].decl).id,"::")) {
+                String *p = Swig_scopename_prefix((yyvsp[(3) - (9)].decl).id);
+		if (p) {
+		  if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) ||
+		      (Classprefix && Strcmp(p, Classprefix) == 0)) {
+		    String *lstr = Swig_scopename_last((yyvsp[(3) - (9)].decl).id);
+		    Setattr((yyval.node),"name",lstr);
+		    Delete(lstr);
+		    set_nextSibling((yyval.node), (yyvsp[(9) - (9)].node));
+		  } else {
+		    Delete((yyval.node));
+		    (yyval.node) = (yyvsp[(9) - (9)].node);
+		  }
+		  Delete(p);
+		} else {
+		  Delete((yyval.node));
+		  (yyval.node) = (yyvsp[(9) - (9)].node);
+		}
+	      } else {
+		set_nextSibling((yyval.node), (yyvsp[(9) - (9)].node));
+	      }
+
+	      if ((yyvsp[(4) - (9)].dtype).qualifier && (yyvsp[(1) - (9)].id) && Strstr((yyvsp[(1) - (9)].id), "static"))
+		Swig_error(cparse_file, cparse_line, "Static function %s cannot have a qualifier.\n", Swig_name_decl((yyval.node)));
+           ;}
+    break;
+
+  case 128:
+#line 3352 "parser.y"
+    { 
+                   (yyval.node) = 0;
+                   Clear(scanner_ccode); 
+               ;}
+    break;
+
+  case 129:
+#line 3356 "parser.y"
+    {
+		 (yyval.node) = new_node("cdecl");
+		 if ((yyvsp[(3) - (5)].dtype).qualifier) SwigType_push((yyvsp[(2) - (5)].decl).type,(yyvsp[(3) - (5)].dtype).qualifier);
+		 Setattr((yyval.node),"refqualifier",(yyvsp[(3) - (5)].dtype).refqualifier);
+		 Setattr((yyval.node),"name",(yyvsp[(2) - (5)].decl).id);
+		 Setattr((yyval.node),"decl",(yyvsp[(2) - (5)].decl).type);
+		 Setattr((yyval.node),"parms",(yyvsp[(2) - (5)].decl).parms);
+		 Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val);
+		 Setattr((yyval.node),"throws",(yyvsp[(3) - (5)].dtype).throws);
+		 Setattr((yyval.node),"throw",(yyvsp[(3) - (5)].dtype).throwf);
+		 Setattr((yyval.node),"noexcept",(yyvsp[(3) - (5)].dtype).nexcept);
+		 Setattr((yyval.node),"final",(yyvsp[(3) - (5)].dtype).final);
+		 if ((yyvsp[(4) - (5)].dtype).bitfield) {
+		   Setattr((yyval.node),"bitfield", (yyvsp[(4) - (5)].dtype).bitfield);
+		 }
+		 if (!(yyvsp[(5) - (5)].node)) {
+		   if (Len(scanner_ccode)) {
+		     String *code = Copy(scanner_ccode);
+		     Setattr((yyval.node),"code",code);
+		     Delete(code);
+		   }
+		 } else {
+		   set_nextSibling((yyval.node), (yyvsp[(5) - (5)].node));
+		 }
+	       ;}
+    break;
+
+  case 130:
+#line 3381 "parser.y"
+    { 
+                   skip_balanced('{','}');
+                   (yyval.node) = 0;
+               ;}
+    break;
+
+  case 131:
+#line 3385 "parser.y"
+    {
+		   (yyval.node) = 0;
+		   if (yychar == RPAREN) {
+		       Swig_error(cparse_file, cparse_line, "Unexpected closing parenthesis (')').\n");
+		   } else {
+		       Swig_error(cparse_file, cparse_line, "Syntax error - possibly a missing semicolon (';').\n");
+		   }
+		   Exit(EXIT_FAILURE);
+               ;}
+    break;
+
+  case 132:
+#line 3396 "parser.y"
+    {
+                   (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+              ;}
+    break;
+
+  case 133:
+#line 3401 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 134:
+#line 3402 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 135:
+#line 3403 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 136:
+#line 3407 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 137:
+#line 3408 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].str); ;}
+    break;
+
+  case 138:
+#line 3409 "parser.y"
+    {
+                (yyval.node) = (yyvsp[(1) - (2)].str);
+                SwigType_add_reference((yyval.node));
+              ;}
+    break;
+
+  case 139:
+#line 3413 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 140:
+#line 3424 "parser.y"
+    {
+		  (yyval.node) = new_node("lambda");
+		  Setattr((yyval.node),"name",(yyvsp[(3) - (12)].str));
+		  add_symbols((yyval.node));
+	        ;}
+    break;
+
+  case 141:
+#line 3429 "parser.y"
+    {
+		  (yyval.node) = new_node("lambda");
+		  Setattr((yyval.node),"name",(yyvsp[(3) - (14)].str));
+		  add_symbols((yyval.node));
+		;}
+    break;
+
+  case 142:
+#line 3434 "parser.y"
+    {
+		  (yyval.node) = new_node("lambda");
+		  Setattr((yyval.node),"name",(yyvsp[(3) - (8)].str));
+		  add_symbols((yyval.node));
+		;}
+    break;
+
+  case 143:
+#line 3441 "parser.y"
+    {
+		  skip_balanced('[',']');
+		  (yyval.node) = 0;
+	        ;}
+    break;
+
+  case 144:
+#line 3447 "parser.y"
+    {
+		  skip_balanced('<','>');
+		  (yyval.node) = 0;
+		;}
+    break;
+
+  case 145:
+#line 3451 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 146:
+#line 3454 "parser.y"
+    {
+		  skip_balanced('{','}');
+		  (yyval.node) = 0;
+		;}
+    break;
+
+  case 147:
+#line 3459 "parser.y"
+    {
+		  (yyval.pl) = 0;
+		;}
+    break;
+
+  case 148:
+#line 3462 "parser.y"
+    {
+		  skip_balanced('(',')');
+		;}
+    break;
+
+  case 149:
+#line 3464 "parser.y"
+    {
+		  (yyval.pl) = 0;
+		;}
+    break;
+
+  case 150:
+#line 3475 "parser.y"
+    {
+		   (yyval.node) = (char *)"enum";
+	      ;}
+    break;
+
+  case 151:
+#line 3478 "parser.y"
+    {
+		   (yyval.node) = (char *)"enum class";
+	      ;}
+    break;
+
+  case 152:
+#line 3481 "parser.y"
+    {
+		   (yyval.node) = (char *)"enum struct";
+	      ;}
+    break;
+
+  case 153:
+#line 3490 "parser.y"
+    {
+                   (yyval.node) = (yyvsp[(2) - (2)].type);
+              ;}
+    break;
+
+  case 154:
+#line 3493 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 155:
+#line 3500 "parser.y"
+    {
+		   SwigType *ty = 0;
+		   int scopedenum = (yyvsp[(3) - (5)].id) && !Equal((yyvsp[(2) - (5)].node), "enum");
+		   (yyval.node) = new_node("enumforward");
+		   ty = NewStringf("enum %s", (yyvsp[(3) - (5)].id));
+		   Setattr((yyval.node),"enumkey",(yyvsp[(2) - (5)].node));
+		   if (scopedenum)
+		     SetFlag((yyval.node), "scopedenum");
+		   Setattr((yyval.node),"name",(yyvsp[(3) - (5)].id));
+		   Setattr((yyval.node),"inherit",(yyvsp[(4) - (5)].node));
+		   Setattr((yyval.node),"type",ty);
+		   Setattr((yyval.node),"sym:weak", "1");
+		   add_symbols((yyval.node));
+	      ;}
+    break;
+
+  case 156:
+#line 3522 "parser.y"
+    {
+		  SwigType *ty = 0;
+		  int scopedenum = (yyvsp[(3) - (8)].id) && !Equal((yyvsp[(2) - (8)].node), "enum");
+                  (yyval.node) = new_node("enum");
+		  ty = NewStringf("enum %s", (yyvsp[(3) - (8)].id));
+		  Setattr((yyval.node),"enumkey",(yyvsp[(2) - (8)].node));
+		  if (scopedenum)
+		    SetFlag((yyval.node), "scopedenum");
+		  Setattr((yyval.node),"name",(yyvsp[(3) - (8)].id));
+		  Setattr((yyval.node),"inherit",(yyvsp[(4) - (8)].node));
+		  Setattr((yyval.node),"type",ty);
+		  appendChild((yyval.node),(yyvsp[(6) - (8)].node));
+		  add_symbols((yyval.node));      /* Add to tag space */
+
+		  if (scopedenum) {
+		    Swig_symbol_newscope();
+		    Swig_symbol_setscopename((yyvsp[(3) - (8)].id));
+		    Delete(Namespaceprefix);
+		    Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		  }
+
+		  add_symbols((yyvsp[(6) - (8)].node));      /* Add enum values to appropriate enum or enum class scope */
+
+		  if (scopedenum) {
+		    Setattr((yyval.node),"symtab", Swig_symbol_popscope());
+		    Delete(Namespaceprefix);
+		    Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		  }
+               ;}
+    break;
+
+  case 157:
+#line 3551 "parser.y"
+    {
+		 Node *n;
+		 SwigType *ty = 0;
+		 String   *unnamed = 0;
+		 int       unnamedinstance = 0;
+		 int scopedenum = (yyvsp[(3) - (11)].id) && !Equal((yyvsp[(2) - (11)].node), "enum");
+
+		 (yyval.node) = new_node("enum");
+		 Setattr((yyval.node),"enumkey",(yyvsp[(2) - (11)].node));
+		 if (scopedenum)
+		   SetFlag((yyval.node), "scopedenum");
+		 Setattr((yyval.node),"inherit",(yyvsp[(4) - (11)].node));
+		 if ((yyvsp[(3) - (11)].id)) {
+		   Setattr((yyval.node),"name",(yyvsp[(3) - (11)].id));
+		   ty = NewStringf("enum %s", (yyvsp[(3) - (11)].id));
+		 } else if ((yyvsp[(8) - (11)].decl).id) {
+		   unnamed = make_unnamed();
+		   ty = NewStringf("enum %s", unnamed);
+		   Setattr((yyval.node),"unnamed",unnamed);
+                   /* name is not set for unnamed enum instances, e.g. enum { foo } Instance; */
+		   if ((yyvsp[(1) - (11)].id) && Cmp((yyvsp[(1) - (11)].id),"typedef") == 0) {
+		     Setattr((yyval.node),"name",(yyvsp[(8) - (11)].decl).id);
+                   } else {
+                     unnamedinstance = 1;
+                   }
+		   Setattr((yyval.node),"storage",(yyvsp[(1) - (11)].id));
+		 }
+		 if ((yyvsp[(8) - (11)].decl).id && Cmp((yyvsp[(1) - (11)].id),"typedef") == 0) {
+		   Setattr((yyval.node),"tdname",(yyvsp[(8) - (11)].decl).id);
+                   Setattr((yyval.node),"allows_typedef","1");
+                 }
+		 appendChild((yyval.node),(yyvsp[(6) - (11)].node));
+		 n = new_node("cdecl");
+		 Setattr(n,"type",ty);
+		 Setattr(n,"name",(yyvsp[(8) - (11)].decl).id);
+		 Setattr(n,"storage",(yyvsp[(1) - (11)].id));
+		 Setattr(n,"decl",(yyvsp[(8) - (11)].decl).type);
+		 Setattr(n,"parms",(yyvsp[(8) - (11)].decl).parms);
+		 Setattr(n,"unnamed",unnamed);
+
+                 if (unnamedinstance) {
+		   SwigType *cty = NewString("enum ");
+		   Setattr((yyval.node),"type",cty);
+		   SetFlag((yyval.node),"unnamedinstance");
+		   SetFlag(n,"unnamedinstance");
+		   Delete(cty);
+                 }
+		 if ((yyvsp[(11) - (11)].node)) {
+		   Node *p = (yyvsp[(11) - (11)].node);
+		   set_nextSibling(n,p);
+		   while (p) {
+		     SwigType *cty = Copy(ty);
+		     Setattr(p,"type",cty);
+		     Setattr(p,"unnamed",unnamed);
+		     Setattr(p,"storage",(yyvsp[(1) - (11)].id));
+		     Delete(cty);
+		     p = nextSibling(p);
+		   }
+		 } else {
+		   if (Len(scanner_ccode)) {
+		     String *code = Copy(scanner_ccode);
+		     Setattr(n,"code",code);
+		     Delete(code);
+		   }
+		 }
+
+                 /* Ensure that typedef enum ABC {foo} XYZ; uses XYZ for sym:name, like structs.
+                  * Note that class_rename/yyrename are bit of a mess so used this simple approach to change the name. */
+                 if ((yyvsp[(8) - (11)].decl).id && (yyvsp[(3) - (11)].id) && Cmp((yyvsp[(1) - (11)].id),"typedef") == 0) {
+		   String *name = NewString((yyvsp[(8) - (11)].decl).id);
+                   Setattr((yyval.node), "parser:makename", name);
+		   Delete(name);
+                 }
+
+		 add_symbols((yyval.node));       /* Add enum to tag space */
+		 set_nextSibling((yyval.node),n);
+		 Delete(n);
+
+		 if (scopedenum) {
+		   Swig_symbol_newscope();
+		   Swig_symbol_setscopename((yyvsp[(3) - (11)].id));
+		   Delete(Namespaceprefix);
+		   Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		 }
+
+		 add_symbols((yyvsp[(6) - (11)].node));      /* Add enum values to appropriate enum or enum class scope */
+
+		 if (scopedenum) {
+		   Setattr((yyval.node),"symtab", Swig_symbol_popscope());
+		   Delete(Namespaceprefix);
+		   Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		 }
+
+	         add_symbols(n);
+		 Delete(unnamed);
+	       ;}
+    break;
+
+  case 158:
+#line 3649 "parser.y"
+    {
+                   /* This is a sick hack.  If the ctor_end has parameters,
+                      and the parms parameter only has 1 parameter, this
+                      could be a declaration of the form:
+
+                         type (id)(parms)
+
+			 Otherwise it's an error. */
+                    int err = 0;
+                    (yyval.node) = 0;
+
+		    if ((ParmList_len((yyvsp[(4) - (6)].pl)) == 1) && (!Swig_scopename_check((yyvsp[(2) - (6)].type)))) {
+		      SwigType *ty = Getattr((yyvsp[(4) - (6)].pl),"type");
+		      String *name = Getattr((yyvsp[(4) - (6)].pl),"name");
+		      err = 1;
+		      if (!name) {
+			(yyval.node) = new_node("cdecl");
+			Setattr((yyval.node),"type",(yyvsp[(2) - (6)].type));
+			Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id));
+			Setattr((yyval.node),"name",ty);
+
+			if ((yyvsp[(6) - (6)].decl).have_parms) {
+			  SwigType *decl = NewStringEmpty();
+			  SwigType_add_function(decl,(yyvsp[(6) - (6)].decl).parms);
+			  Setattr((yyval.node),"decl",decl);
+			  Setattr((yyval.node),"parms",(yyvsp[(6) - (6)].decl).parms);
+			  if (Len(scanner_ccode)) {
+			    String *code = Copy(scanner_ccode);
+			    Setattr((yyval.node),"code",code);
+			    Delete(code);
+			  }
+			}
+			if ((yyvsp[(6) - (6)].decl).defarg) {
+			  Setattr((yyval.node),"value",(yyvsp[(6) - (6)].decl).defarg);
+			}
+			Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws);
+			Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf);
+			Setattr((yyval.node),"noexcept",(yyvsp[(6) - (6)].decl).nexcept);
+			Setattr((yyval.node),"final",(yyvsp[(6) - (6)].decl).final);
+			err = 0;
+		      }
+		    }
+		    if (err) {
+		      Swig_error(cparse_file,cparse_line,"Syntax error in input(2).\n");
+		      Exit(EXIT_FAILURE);
+		    }
+                ;}
+    break;
+
+  case 159:
+#line 3702 "parser.y"
+    {  (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 160:
+#line 3703 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 161:
+#line 3704 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 162:
+#line 3705 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 163:
+#line 3706 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 164:
+#line 3707 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 165:
+#line 3716 "parser.y"
+    {
+                   String *prefix;
+                   List *bases = 0;
+		   Node *scope = 0;
+		   String *code;
+		   (yyval.node) = new_node("class");
+		   Setline((yyval.node),cparse_start_line);
+		   Setattr((yyval.node),"kind",(yyvsp[(2) - (6)].id));
+		   if ((yyvsp[(5) - (6)].bases)) {
+		     Setattr((yyval.node),"baselist", Getattr((yyvsp[(5) - (6)].bases),"public"));
+		     Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[(5) - (6)].bases),"protected"));
+		     Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[(5) - (6)].bases),"private"));
+		   }
+		   Setattr((yyval.node),"allows_typedef","1");
+
+		   /* preserve the current scope */
+		   Setattr((yyval.node),"prev_symtab",Swig_symbol_current());
+		  
+		   /* If the class name is qualified.  We need to create or lookup namespace/scope entries */
+		   scope = resolve_create_node_scope((yyvsp[(3) - (6)].str), 1);
+		   /* save nscope_inner to the class - it may be overwritten in nested classes*/
+		   Setattr((yyval.node), "nested:innerscope", nscope_inner);
+		   Setattr((yyval.node), "nested:nscope", nscope);
+		   Setfile(scope,cparse_file);
+		   Setline(scope,cparse_line);
+		   (yyvsp[(3) - (6)].str) = scope;
+		   Setattr((yyval.node),"name",(yyvsp[(3) - (6)].str));
+
+		   if (currentOuterClass) {
+		     SetFlag((yyval.node), "nested");
+		     Setattr((yyval.node), "nested:outer", currentOuterClass);
+		     set_access_mode((yyval.node));
+		   }
+		   Swig_features_get(Swig_cparse_features(), Namespaceprefix, Getattr((yyval.node), "name"), 0, (yyval.node));
+		   /* save yyrename to the class attribute, to be used later in add_symbols()*/
+		   Setattr((yyval.node), "class_rename", make_name((yyval.node), (yyvsp[(3) - (6)].str), 0));
+		   Setattr((yyval.node), "Classprefix", (yyvsp[(3) - (6)].str));
+		   Classprefix = NewString((yyvsp[(3) - (6)].str));
+		   /* Deal with inheritance  */
+		   if ((yyvsp[(5) - (6)].bases))
+		     bases = Swig_make_inherit_list((yyvsp[(3) - (6)].str),Getattr((yyvsp[(5) - (6)].bases),"public"),Namespaceprefix);
+		   prefix = SwigType_istemplate_templateprefix((yyvsp[(3) - (6)].str));
+		   if (prefix) {
+		     String *fbase, *tbase;
+		     if (Namespaceprefix) {
+		       fbase = NewStringf("%s::%s", Namespaceprefix,(yyvsp[(3) - (6)].str));
+		       tbase = NewStringf("%s::%s", Namespaceprefix, prefix);
+		     } else {
+		       fbase = Copy((yyvsp[(3) - (6)].str));
+		       tbase = Copy(prefix);
+		     }
+		     Swig_name_inherit(tbase,fbase);
+		     Delete(fbase);
+		     Delete(tbase);
+		   }
+                   if (strcmp((yyvsp[(2) - (6)].id),"class") == 0) {
+		     cplus_mode = CPLUS_PRIVATE;
+		   } else {
+		     cplus_mode = CPLUS_PUBLIC;
+		   }
+		   if (!cparse_cplusplus) {
+		     set_scope_to_global();
+		   }
+		   Swig_symbol_newscope();
+		   Swig_symbol_setscopename((yyvsp[(3) - (6)].str));
+		   Swig_inherit_base_symbols(bases);
+		   Delete(Namespaceprefix);
+		   Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		   cparse_start_line = cparse_line;
+
+		   /* If there are active template parameters, we need to make sure they are
+                      placed in the class symbol table so we can catch shadows */
+
+		   if (template_parameters) {
+		     Parm *tp = template_parameters;
+		     while(tp) {
+		       String *tpname = Copy(Getattr(tp,"name"));
+		       Node *tn = new_node("templateparm");
+		       Setattr(tn,"name",tpname);
+		       Swig_symbol_cadd(tpname,tn);
+		       tp = nextSibling(tp);
+		       Delete(tpname);
+		     }
+		   }
+		   Delete(prefix);
+		   inclass = 1;
+		   currentOuterClass = (yyval.node);
+		   if (cparse_cplusplusout) {
+		     /* save the structure declaration to declare it in global scope for C++ to see */
+		     code = get_raw_text_balanced('{', '}');
+		     Setattr((yyval.node), "code", code);
+		     Delete(code);
+		   }
+               ;}
+    break;
+
+  case 166:
+#line 3809 "parser.y"
+    {
+		   Node *p;
+		   SwigType *ty;
+		   Symtab *cscope;
+		   Node *am = 0;
+		   String *scpname = 0;
+		   (void) (yyvsp[(6) - (10)].node);
+		   (yyval.node) = currentOuterClass;
+		   currentOuterClass = Getattr((yyval.node), "nested:outer");
+		   nscope_inner = Getattr((yyval.node), "nested:innerscope");
+		   nscope = Getattr((yyval.node), "nested:nscope");
+		   Delattr((yyval.node), "nested:innerscope");
+		   Delattr((yyval.node), "nested:nscope");
+		   if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) { /* actual parent class for this class */
+		     Node* forward_declaration = Swig_symbol_clookup_no_inherit(Getattr((yyval.node),"name"), Getattr(nscope_inner, "symtab"));
+		     if (forward_declaration) {
+		       Setattr((yyval.node), "access", Getattr(forward_declaration, "access"));
+		     }
+		     Setattr((yyval.node), "nested:outer", nscope_inner);
+		     SetFlag((yyval.node), "nested");
+                   }
+		   if (!currentOuterClass)
+		     inclass = 0;
+		   cscope = Getattr((yyval.node), "prev_symtab");
+		   Delattr((yyval.node), "prev_symtab");
+		   
+		   /* Check for pure-abstract class */
+		   Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[(8) - (10)].node)));
+		   
+		   /* This bit of code merges in a previously defined %extend directive (if any) */
+		   {
+		     String *clsname = Swig_symbol_qualifiedscopename(0);
+		     am = Getattr(Swig_extend_hash(), clsname);
+		     if (am) {
+		       Swig_extend_merge((yyval.node), am);
+		       Delattr(Swig_extend_hash(), clsname);
+		     }
+		     Delete(clsname);
+		   }
+		   if (!classes) classes = NewHash();
+		   scpname = Swig_symbol_qualifiedscopename(0);
+		   Setattr(classes, scpname, (yyval.node));
+
+		   appendChild((yyval.node), (yyvsp[(8) - (10)].node));
+		   
+		   if (am) 
+		     Swig_extend_append_previous((yyval.node), am);
+
+		   p = (yyvsp[(10) - (10)].node);
+		   if (p && !nscope_inner) {
+		     if (!cparse_cplusplus && currentOuterClass)
+		       appendChild(currentOuterClass, p);
+		     else
+		      appendSibling((yyval.node), p);
+		   }
+		   
+		   if (nscope_inner) {
+		     ty = NewString(scpname); /* if the class is declared out of scope, let the declarator use fully qualified type*/
+		   } else if (cparse_cplusplus && !cparse_externc) {
+		     ty = NewString((yyvsp[(3) - (10)].str));
+		   } else {
+		     ty = NewStringf("%s %s", (yyvsp[(2) - (10)].id), (yyvsp[(3) - (10)].str));
+		   }
+		   while (p) {
+		     Setattr(p, "storage", (yyvsp[(1) - (10)].id));
+		     Setattr(p, "type" ,ty);
+		     if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) {
+		       SetFlag(p, "hasconsttype");
+		       SetFlag(p, "feature:immutable");
+		     }
+		     p = nextSibling(p);
+		   }
+		   if ((yyvsp[(10) - (10)].node) && Cmp((yyvsp[(1) - (10)].id),"typedef") == 0)
+		     add_typedef_name((yyval.node), (yyvsp[(10) - (10)].node), (yyvsp[(3) - (10)].str), cscope, scpname);
+		   Delete(scpname);
+
+		   if (cplus_mode != CPLUS_PUBLIC) {
+		   /* we 'open' the class at the end, to allow %template
+		      to add new members */
+		     Node *pa = new_node("access");
+		     Setattr(pa, "kind", "public");
+		     cplus_mode = CPLUS_PUBLIC;
+		     appendChild((yyval.node), pa);
+		     Delete(pa);
+		   }
+		   if (currentOuterClass)
+		     restore_access_mode((yyval.node));
+		   Setattr((yyval.node), "symtab", Swig_symbol_popscope());
+		   Classprefix = Getattr((yyval.node), "Classprefix");
+		   Delattr((yyval.node), "Classprefix");
+		   Delete(Namespaceprefix);
+		   Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		   if (cplus_mode == CPLUS_PRIVATE) {
+		     (yyval.node) = 0; /* skip private nested classes */
+		   } else if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested")) {
+		     (yyval.node) = nested_forward_declaration((yyvsp[(1) - (10)].id), (yyvsp[(2) - (10)].id), (yyvsp[(3) - (10)].str), Copy((yyvsp[(3) - (10)].str)), (yyvsp[(10) - (10)].node));
+		   } else if (nscope_inner) {
+		     /* this is tricky */
+		     /* we add the declaration in the original namespace */
+		     if (Strcmp(nodeType(nscope_inner), "class") == 0 && cparse_cplusplus && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested"))
+		       (yyval.node) = nested_forward_declaration((yyvsp[(1) - (10)].id), (yyvsp[(2) - (10)].id), (yyvsp[(3) - (10)].str), Copy((yyvsp[(3) - (10)].str)), (yyvsp[(10) - (10)].node));
+		     appendChild(nscope_inner, (yyval.node));
+		     Swig_symbol_setscope(Getattr(nscope_inner, "symtab"));
+		     Delete(Namespaceprefix);
+		     Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		     yyrename = Copy(Getattr((yyval.node), "class_rename"));
+		     add_symbols((yyval.node));
+		     Delattr((yyval.node), "class_rename");
+		     /* but the variable definition in the current scope */
+		     Swig_symbol_setscope(cscope);
+		     Delete(Namespaceprefix);
+		     Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		     add_symbols((yyvsp[(10) - (10)].node));
+		     if (nscope) {
+		       (yyval.node) = nscope; /* here we return recreated namespace tower instead of the class itself */
+		       if ((yyvsp[(10) - (10)].node)) {
+			 appendSibling((yyval.node), (yyvsp[(10) - (10)].node));
+		       }
+		     } else if (!SwigType_istemplate(ty) && template_parameters == 0) { /* for template we need the class itself */
+		       (yyval.node) = (yyvsp[(10) - (10)].node);
+		     }
+		   } else {
+		     Delete(yyrename);
+		     yyrename = 0;
+		     if (!cparse_cplusplus && currentOuterClass) { /* nested C structs go into global scope*/
+		       Node *outer = currentOuterClass;
+		       while (Getattr(outer, "nested:outer"))
+			 outer = Getattr(outer, "nested:outer");
+		       appendSibling(outer, (yyval.node));
+		       Swig_symbol_setscope(cscope); /* declaration goes in the parent scope */
+		       add_symbols((yyvsp[(10) - (10)].node));
+		       set_scope_to_global();
+		       Delete(Namespaceprefix);
+		       Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		       yyrename = Copy(Getattr((yyval.node), "class_rename"));
+		       add_symbols((yyval.node));
+		       if (!cparse_cplusplusout)
+			 Delattr((yyval.node), "nested:outer");
+		       Delattr((yyval.node), "class_rename");
+		       (yyval.node) = 0;
+		     } else {
+		       yyrename = Copy(Getattr((yyval.node), "class_rename"));
+		       add_symbols((yyval.node));
+		       add_symbols((yyvsp[(10) - (10)].node));
+		       Delattr((yyval.node), "class_rename");
+		     }
+		   }
+		   Delete(ty);
+		   Swig_symbol_setscope(cscope);
+		   Delete(Namespaceprefix);
+		   Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		   Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0;
+	       ;}
+    break;
+
+  case 167:
+#line 3965 "parser.y"
+    {
+	       String *unnamed;
+	       String *code;
+	       unnamed = make_unnamed();
+	       (yyval.node) = new_node("class");
+	       Setline((yyval.node),cparse_start_line);
+	       Setattr((yyval.node),"kind",(yyvsp[(2) - (4)].id));
+	       if ((yyvsp[(3) - (4)].bases)) {
+		 Setattr((yyval.node),"baselist", Getattr((yyvsp[(3) - (4)].bases),"public"));
+		 Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[(3) - (4)].bases),"protected"));
+		 Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[(3) - (4)].bases),"private"));
+	       }
+	       Setattr((yyval.node),"storage",(yyvsp[(1) - (4)].id));
+	       Setattr((yyval.node),"unnamed",unnamed);
+	       Setattr((yyval.node),"allows_typedef","1");
+	       if (currentOuterClass) {
+		 SetFlag((yyval.node), "nested");
+		 Setattr((yyval.node), "nested:outer", currentOuterClass);
+		 set_access_mode((yyval.node));
+	       }
+	       Swig_features_get(Swig_cparse_features(), Namespaceprefix, 0, 0, (yyval.node));
+	       /* save yyrename to the class attribute, to be used later in add_symbols()*/
+	       Setattr((yyval.node), "class_rename", make_name((yyval.node),0,0));
+	       if (strcmp((yyvsp[(2) - (4)].id),"class") == 0) {
+		 cplus_mode = CPLUS_PRIVATE;
+	       } else {
+		 cplus_mode = CPLUS_PUBLIC;
+	       }
+	       Swig_symbol_newscope();
+	       cparse_start_line = cparse_line;
+	       currentOuterClass = (yyval.node);
+	       inclass = 1;
+	       Classprefix = 0;
+	       Delete(Namespaceprefix);
+	       Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+	       /* save the structure declaration to make a typedef for it later*/
+	       code = get_raw_text_balanced('{', '}');
+	       Setattr((yyval.node), "code", code);
+	       Delete(code);
+	     ;}
+    break;
+
+  case 168:
+#line 4004 "parser.y"
+    {
+	       String *unnamed;
+               List *bases = 0;
+	       String *name = 0;
+	       Node *n;
+	       Classprefix = 0;
+	       (void)(yyvsp[(5) - (8)].node);
+	       (yyval.node) = currentOuterClass;
+	       currentOuterClass = Getattr((yyval.node), "nested:outer");
+	       if (!currentOuterClass)
+		 inclass = 0;
+	       else
+		 restore_access_mode((yyval.node));
+	       unnamed = Getattr((yyval.node),"unnamed");
+               /* Check for pure-abstract class */
+	       Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[(6) - (8)].node)));
+	       n = (yyvsp[(8) - (8)].node);
+	       if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested")) {
+		 String *name = n ? Copy(Getattr(n, "name")) : 0;
+		 (yyval.node) = nested_forward_declaration((yyvsp[(1) - (8)].id), (yyvsp[(2) - (8)].id), 0, name, n);
+		 Swig_symbol_popscope();
+	         Delete(Namespaceprefix);
+		 Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+	       } else if (n) {
+	         appendSibling((yyval.node),n);
+		 /* If a proper typedef name was given, we'll use it to set the scope name */
+		 name = try_to_find_a_name_for_unnamed_structure((yyvsp[(1) - (8)].id), n);
+		 if (name) {
+		   String *scpname = 0;
+		   SwigType *ty;
+		   Setattr((yyval.node),"tdname",name);
+		   Setattr((yyval.node),"name",name);
+		   Swig_symbol_setscopename(name);
+		   if ((yyvsp[(3) - (8)].bases))
+		     bases = Swig_make_inherit_list(name,Getattr((yyvsp[(3) - (8)].bases),"public"),Namespaceprefix);
+		   Swig_inherit_base_symbols(bases);
+
+		     /* If a proper name was given, we use that as the typedef, not unnamed */
+		   Clear(unnamed);
+		   Append(unnamed, name);
+		   if (cparse_cplusplus && !cparse_externc) {
+		     ty = NewString(name);
+		   } else {
+		     ty = NewStringf("%s %s", (yyvsp[(2) - (8)].id),name);
+		   }
+		   while (n) {
+		     Setattr(n,"storage",(yyvsp[(1) - (8)].id));
+		     Setattr(n, "type", ty);
+		     if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) {
+		       SetFlag(n,"hasconsttype");
+		       SetFlag(n,"feature:immutable");
+		     }
+		     n = nextSibling(n);
+		   }
+		   n = (yyvsp[(8) - (8)].node);
+
+		   /* Check for previous extensions */
+		   {
+		     String *clsname = Swig_symbol_qualifiedscopename(0);
+		     Node *am = Getattr(Swig_extend_hash(),clsname);
+		     if (am) {
+		       /* Merge the extension into the symbol table */
+		       Swig_extend_merge((yyval.node),am);
+		       Swig_extend_append_previous((yyval.node),am);
+		       Delattr(Swig_extend_hash(),clsname);
+		     }
+		     Delete(clsname);
+		   }
+		   if (!classes) classes = NewHash();
+		   scpname = Swig_symbol_qualifiedscopename(0);
+		   Setattr(classes,scpname,(yyval.node));
+		   Delete(scpname);
+		 } else { /* no suitable name was found for a struct */
+		   Setattr((yyval.node), "nested:unnamed", Getattr(n, "name")); /* save the name of the first declarator for later use in name generation*/
+		   while (n) { /* attach unnamed struct to the declarators, so that they would receive proper type later*/
+		     Setattr(n, "nested:unnamedtype", (yyval.node));
+		     Setattr(n, "storage", (yyvsp[(1) - (8)].id));
+		     n = nextSibling(n);
+		   }
+		   n = (yyvsp[(8) - (8)].node);
+		   Swig_symbol_setscopename("<unnamed>");
+		 }
+		 appendChild((yyval.node),(yyvsp[(6) - (8)].node));
+		 /* Pop the scope */
+		 Setattr((yyval.node),"symtab",Swig_symbol_popscope());
+		 if (name) {
+		   Delete(yyrename);
+		   yyrename = Copy(Getattr((yyval.node), "class_rename"));
+		   Delete(Namespaceprefix);
+		   Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		   add_symbols((yyval.node));
+		   add_symbols(n);
+		   Delattr((yyval.node), "class_rename");
+		 }else if (cparse_cplusplus)
+		   (yyval.node) = 0; /* ignore unnamed structs for C++ */
+	         Delete(unnamed);
+	       } else { /* unnamed struct w/o declarator*/
+		 Swig_symbol_popscope();
+	         Delete(Namespaceprefix);
+		 Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		 add_symbols((yyvsp[(6) - (8)].node));
+		 Delete((yyval.node));
+		 (yyval.node) = (yyvsp[(6) - (8)].node); /* pass member list to outer class/namespace (instead of self)*/
+	       }
+	       Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0;
+              ;}
+    break;
+
+  case 169:
+#line 4112 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 170:
+#line 4113 "parser.y"
+    {
+                        (yyval.node) = new_node("cdecl");
+                        Setattr((yyval.node),"name",(yyvsp[(1) - (4)].decl).id);
+                        Setattr((yyval.node),"decl",(yyvsp[(1) - (4)].decl).type);
+                        Setattr((yyval.node),"parms",(yyvsp[(1) - (4)].decl).parms);
+			set_nextSibling((yyval.node), (yyvsp[(4) - (4)].node));
+                    ;}
+    break;
+
+  case 171:
+#line 4125 "parser.y"
+    {
+              if ((yyvsp[(1) - (4)].id) && (Strcmp((yyvsp[(1) - (4)].id),"friend") == 0)) {
+		/* Ignore */
+                (yyval.node) = 0; 
+	      } else {
+		(yyval.node) = new_node("classforward");
+		Setattr((yyval.node),"kind",(yyvsp[(2) - (4)].id));
+		Setattr((yyval.node),"name",(yyvsp[(3) - (4)].str));
+		Setattr((yyval.node),"sym:weak", "1");
+		add_symbols((yyval.node));
+	      }
+             ;}
+    break;
+
+  case 172:
+#line 4143 "parser.y"
+    { 
+		    if (currentOuterClass)
+		      Setattr(currentOuterClass, "template_parameters", template_parameters);
+		    template_parameters = (yyvsp[(3) - (4)].tparms); 
+		    parsing_template_declaration = 1;
+		  ;}
+    break;
+
+  case 173:
+#line 4148 "parser.y"
+    {
+			String *tname = 0;
+			int     error = 0;
+
+			/* check if we get a namespace node with a class declaration, and retrieve the class */
+			Symtab *cscope = Swig_symbol_current();
+			Symtab *sti = 0;
+			Node *ntop = (yyvsp[(6) - (6)].node);
+			Node *ni = ntop;
+			SwigType *ntype = ni ? nodeType(ni) : 0;
+			while (ni && Strcmp(ntype,"namespace") == 0) {
+			  sti = Getattr(ni,"symtab");
+			  ni = firstChild(ni);
+			  ntype = nodeType(ni);
+			}
+			if (sti) {
+			  Swig_symbol_setscope(sti);
+			  Delete(Namespaceprefix);
+			  Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+			  (yyvsp[(6) - (6)].node) = ni;
+			}
+
+			(yyval.node) = (yyvsp[(6) - (6)].node);
+			if ((yyval.node)) tname = Getattr((yyval.node),"name");
+			
+			/* Check if the class is a template specialization */
+			if (((yyval.node)) && (Strchr(tname,'<')) && (!is_operator(tname))) {
+			  /* If a specialization.  Check if defined. */
+			  Node *tempn = 0;
+			  {
+			    String *tbase = SwigType_templateprefix(tname);
+			    tempn = Swig_symbol_clookup_local(tbase,0);
+			    if (!tempn || (Strcmp(nodeType(tempn),"template") != 0)) {
+			      SWIG_WARN_NODE_BEGIN(tempn);
+			      Swig_warning(WARN_PARSE_TEMPLATE_SP_UNDEF, Getfile((yyval.node)),Getline((yyval.node)),"Specialization of non-template '%s'.\n", tbase);
+			      SWIG_WARN_NODE_END(tempn);
+			      tempn = 0;
+			      error = 1;
+			    }
+			    Delete(tbase);
+			  }
+			  Setattr((yyval.node),"specialization","1");
+			  Setattr((yyval.node),"templatetype",nodeType((yyval.node)));
+			  set_nodeType((yyval.node),"template");
+			  /* Template partial specialization */
+			  if (tempn && ((yyvsp[(3) - (6)].tparms)) && ((yyvsp[(6) - (6)].node))) {
+			    List   *tlist;
+			    String *targs = SwigType_templateargs(tname);
+			    tlist = SwigType_parmlist(targs);
+			    /*			  Printf(stdout,"targs = '%s' %s\n", targs, tlist); */
+			    if (!Getattr((yyval.node),"sym:weak")) {
+			      Setattr((yyval.node),"sym:typename","1");
+			    }
+			    
+			    if (Len(tlist) != ParmList_len(Getattr(tempn,"templateparms"))) {
+			      Swig_error(Getfile((yyval.node)),Getline((yyval.node)),"Inconsistent argument count in template partial specialization. %d %d\n", Len(tlist), ParmList_len(Getattr(tempn,"templateparms")));
+			      
+			    } else {
+
+			    /* This code builds the argument list for the partial template
+			       specialization.  This is a little hairy, but the idea is as
+			       follows:
+
+			       $3 contains a list of arguments supplied for the template.
+			       For example template<class T>.
+
+			       tlist is a list of the specialization arguments--which may be
+			       different.  For example class<int,T>.
+
+			       tp is a copy of the arguments in the original template definition.
+       
+			       The patching algorithm walks through the list of supplied
+			       arguments ($3), finds the position in the specialization arguments
+			       (tlist), and then patches the name in the argument list of the
+			       original template.
+			    */
+
+			    {
+			      String *pn;
+			      Parm *p, *p1;
+			      int i, nargs;
+			      Parm *tp = CopyParmList(Getattr(tempn,"templateparms"));
+			      nargs = Len(tlist);
+			      p = (yyvsp[(3) - (6)].tparms);
+			      while (p) {
+				for (i = 0; i < nargs; i++){
+				  pn = Getattr(p,"name");
+				  if (Strcmp(pn,SwigType_base(Getitem(tlist,i))) == 0) {
+				    int j;
+				    Parm *p1 = tp;
+				    for (j = 0; j < i; j++) {
+				      p1 = nextSibling(p1);
+				    }
+				    Setattr(p1,"name",pn);
+				    Setattr(p1,"partialarg","1");
+				  }
+				}
+				p = nextSibling(p);
+			      }
+			      p1 = tp;
+			      i = 0;
+			      while (p1) {
+				if (!Getattr(p1,"partialarg")) {
+				  Delattr(p1,"name");
+				  Setattr(p1,"type", Getitem(tlist,i));
+				} 
+				i++;
+				p1 = nextSibling(p1);
+			      }
+			      Setattr((yyval.node),"templateparms",tp);
+			      Delete(tp);
+			    }
+  #if 0
+			    /* Patch the parameter list */
+			    if (tempn) {
+			      Parm *p,*p1;
+			      ParmList *tp = CopyParmList(Getattr(tempn,"templateparms"));
+			      p = (yyvsp[(3) - (6)].tparms);
+			      p1 = tp;
+			      while (p && p1) {
+				String *pn = Getattr(p,"name");
+				Printf(stdout,"pn = '%s'\n", pn);
+				if (pn) Setattr(p1,"name",pn);
+				else Delattr(p1,"name");
+				pn = Getattr(p,"type");
+				if (pn) Setattr(p1,"type",pn);
+				p = nextSibling(p);
+				p1 = nextSibling(p1);
+			      }
+			      Setattr((yyval.node),"templateparms",tp);
+			      Delete(tp);
+			    } else {
+			      Setattr((yyval.node),"templateparms",(yyvsp[(3) - (6)].tparms));
+			    }
+  #endif
+			    Delattr((yyval.node),"specialization");
+			    Setattr((yyval.node),"partialspecialization","1");
+			    /* Create a specialized name for matching */
+			    {
+			      Parm *p = (yyvsp[(3) - (6)].tparms);
+			      String *fname = NewString(Getattr((yyval.node),"name"));
+			      String *ffname = 0;
+			      ParmList *partialparms = 0;
+
+			      char   tmp[32];
+			      int    i, ilen;
+			      while (p) {
+				String *n = Getattr(p,"name");
+				if (!n) {
+				  p = nextSibling(p);
+				  continue;
+				}
+				ilen = Len(tlist);
+				for (i = 0; i < ilen; i++) {
+				  if (Strstr(Getitem(tlist,i),n)) {
+				    sprintf(tmp,"$%d",i+1);
+				    Replaceid(fname,n,tmp);
+				  }
+				}
+				p = nextSibling(p);
+			      }
+			      /* Patch argument names with typedef */
+			      {
+				Iterator tt;
+				Parm *parm_current = 0;
+				List *tparms = SwigType_parmlist(fname);
+				ffname = SwigType_templateprefix(fname);
+				Append(ffname,"<(");
+				for (tt = First(tparms); tt.item; ) {
+				  SwigType *rtt = Swig_symbol_typedef_reduce(tt.item,0);
+				  SwigType *ttr = Swig_symbol_type_qualify(rtt,0);
+
+				  Parm *newp = NewParmWithoutFileLineInfo(ttr, 0);
+				  if (partialparms)
+				    set_nextSibling(parm_current, newp);
+				  else
+				    partialparms = newp;
+				  parm_current = newp;
+
+				  Append(ffname,ttr);
+				  tt = Next(tt);
+				  if (tt.item) Putc(',',ffname);
+				  Delete(rtt);
+				  Delete(ttr);
+				}
+				Delete(tparms);
+				Append(ffname,")>");
+			      }
+			      {
+				Node *new_partial = NewHash();
+				String *partials = Getattr(tempn,"partials");
+				if (!partials) {
+				  partials = NewList();
+				  Setattr(tempn,"partials",partials);
+				  Delete(partials);
+				}
+				/*			      Printf(stdout,"partial: fname = '%s', '%s'\n", fname, Swig_symbol_typedef_reduce(fname,0)); */
+				Setattr(new_partial, "partialparms", partialparms);
+				Setattr(new_partial, "templcsymname", ffname);
+				Append(partials, new_partial);
+			      }
+			      Setattr((yyval.node),"partialargs",ffname);
+			      Swig_symbol_cadd(ffname,(yyval.node));
+			    }
+			    }
+			    Delete(tlist);
+			    Delete(targs);
+			  } else {
+			    /* An explicit template specialization */
+			    /* add default args from primary (unspecialized) template */
+			    String *ty = Swig_symbol_template_deftype(tname,0);
+			    String *fname = Swig_symbol_type_qualify(ty,0);
+			    Swig_symbol_cadd(fname,(yyval.node));
+			    Delete(ty);
+			    Delete(fname);
+			  }
+			}  else if ((yyval.node)) {
+			  Setattr((yyval.node),"templatetype",nodeType((yyvsp[(6) - (6)].node)));
+			  set_nodeType((yyval.node),"template");
+			  Setattr((yyval.node),"templateparms", (yyvsp[(3) - (6)].tparms));
+			  if (!Getattr((yyval.node),"sym:weak")) {
+			    Setattr((yyval.node),"sym:typename","1");
+			  }
+			  add_symbols((yyval.node));
+			  default_arguments((yyval.node));
+			  /* We also place a fully parameterized version in the symbol table */
+			  {
+			    Parm *p;
+			    String *fname = NewStringf("%s<(", Getattr((yyval.node),"name"));
+			    p = (yyvsp[(3) - (6)].tparms);
+			    while (p) {
+			      String *n = Getattr(p,"name");
+			      if (!n) n = Getattr(p,"type");
+			      Append(fname,n);
+			      p = nextSibling(p);
+			      if (p) Putc(',',fname);
+			    }
+			    Append(fname,")>");
+			    Swig_symbol_cadd(fname,(yyval.node));
+			  }
+			}
+			(yyval.node) = ntop;
+			Swig_symbol_setscope(cscope);
+			Delete(Namespaceprefix);
+			Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+			if (error || (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0)) {
+			  (yyval.node) = 0;
+			}
+			if (currentOuterClass)
+			  template_parameters = Getattr(currentOuterClass, "template_parameters");
+			else
+			  template_parameters = 0;
+			parsing_template_declaration = 0;
+                ;}
+    break;
+
+  case 174:
+#line 4404 "parser.y"
+    {
+		  Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n");
+                  (yyval.node) = 0; 
+		;}
+    break;
+
+  case 175:
+#line 4410 "parser.y"
+    {
+			Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n");
+                  (yyval.node) = 0; 
+		;}
+    break;
+
+  case 176:
+#line 4416 "parser.y"
+    {
+		  Swig_warning(WARN_PARSE_EXTERN_TEMPLATE, cparse_file, cparse_line, "Extern template ignored.\n");
+                  (yyval.node) = 0; 
+                ;}
+    break;
+
+  case 177:
+#line 4422 "parser.y"
+    {
+			Swig_warning(WARN_PARSE_EXTERN_TEMPLATE, cparse_file, cparse_line, "Extern template ignored.\n");
+                  (yyval.node) = 0; 
+		;}
+    break;
+
+  case 178:
+#line 4428 "parser.y"
+    {
+		  (yyval.node) = (yyvsp[(1) - (1)].node);
+                ;}
+    break;
+
+  case 179:
+#line 4431 "parser.y"
+    {
+                   (yyval.node) = (yyvsp[(1) - (1)].node);
+                ;}
+    break;
+
+  case 180:
+#line 4434 "parser.y"
+    {
+                   (yyval.node) = (yyvsp[(1) - (1)].node);
+                ;}
+    break;
+
+  case 181:
+#line 4437 "parser.y"
+    {
+		  (yyval.node) = 0;
+                ;}
+    break;
+
+  case 182:
+#line 4440 "parser.y"
+    {
+                  (yyval.node) = (yyvsp[(1) - (1)].node);
+                ;}
+    break;
+
+  case 183:
+#line 4443 "parser.y"
+    {
+                  (yyval.node) = (yyvsp[(1) - (1)].node);
+                ;}
+    break;
+
+  case 184:
+#line 4448 "parser.y"
+    {
+		   /* Rip out the parameter names */
+		  Parm *p = (yyvsp[(1) - (1)].pl);
+		  (yyval.tparms) = (yyvsp[(1) - (1)].pl);
+
+		  while (p) {
+		    String *name = Getattr(p,"name");
+		    if (!name) {
+		      /* Hmmm. Maybe it's a 'class T' parameter */
+		      char *type = Char(Getattr(p,"type"));
+		      /* Template template parameter */
+		      if (strncmp(type,"template<class> ",16) == 0) {
+			type += 16;
+		      }
+		      if ((strncmp(type,"class ",6) == 0) || (strncmp(type,"typename ", 9) == 0)) {
+			char *t = strchr(type,' ');
+			Setattr(p,"name", t+1);
+		      } else 
+                      /* Variadic template args */
+		      if ((strncmp(type,"class... ",9) == 0) || (strncmp(type,"typename... ", 12) == 0)) {
+			char *t = strchr(type,' ');
+			Setattr(p,"name", t+1);
+			Setattr(p,"variadic", "1");
+		      } else {
+			/*
+			 Swig_error(cparse_file, cparse_line, "Missing template parameter name\n");
+			 $$.rparms = 0;
+			 $$.parms = 0;
+			 break; */
+		      }
+		    }
+		    p = nextSibling(p);
+		  }
+                 ;}
+    break;
+
+  case 185:
+#line 4484 "parser.y"
+    {
+                      set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl));
+                      (yyval.pl) = (yyvsp[(1) - (2)].p);
+                   ;}
+    break;
+
+  case 186:
+#line 4488 "parser.y"
+    { (yyval.pl) = 0; ;}
+    break;
+
+  case 187:
+#line 4491 "parser.y"
+    {
+		    (yyval.p) = NewParmWithoutFileLineInfo(NewString((yyvsp[(1) - (1)].id)), 0);
+                  ;}
+    break;
+
+  case 188:
+#line 4494 "parser.y"
+    {
+                    (yyval.p) = (yyvsp[(1) - (1)].p);
+                  ;}
+    break;
+
+  case 189:
+#line 4499 "parser.y"
+    {
+                         set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl));
+                         (yyval.pl) = (yyvsp[(2) - (3)].p);
+                       ;}
+    break;
+
+  case 190:
+#line 4503 "parser.y"
+    { (yyval.pl) = 0; ;}
+    break;
+
+  case 191:
+#line 4508 "parser.y"
+    {
+                  String *uname = Swig_symbol_type_qualify((yyvsp[(2) - (3)].str),0);
+		  String *name = Swig_scopename_last((yyvsp[(2) - (3)].str));
+                  (yyval.node) = new_node("using");
+		  Setattr((yyval.node),"uname",uname);
+		  Setattr((yyval.node),"name", name);
+		  Delete(uname);
+		  Delete(name);
+		  add_symbols((yyval.node));
+             ;}
+    break;
+
+  case 192:
+#line 4518 "parser.y"
+    {
+	       Node *n = Swig_symbol_clookup((yyvsp[(3) - (4)].str),0);
+	       if (!n) {
+		 Swig_error(cparse_file, cparse_line, "Nothing known about namespace '%s'\n", (yyvsp[(3) - (4)].str));
+		 (yyval.node) = 0;
+	       } else {
+
+		 while (Strcmp(nodeType(n),"using") == 0) {
+		   n = Getattr(n,"node");
+		 }
+		 if (n) {
+		   if (Strcmp(nodeType(n),"namespace") == 0) {
+		     Symtab *current = Swig_symbol_current();
+		     Symtab *symtab = Getattr(n,"symtab");
+		     (yyval.node) = new_node("using");
+		     Setattr((yyval.node),"node",n);
+		     Setattr((yyval.node),"namespace", (yyvsp[(3) - (4)].str));
+		     if (current != symtab) {
+		       Swig_symbol_inherit(symtab);
+		     }
+		   } else {
+		     Swig_error(cparse_file, cparse_line, "'%s' is not a namespace.\n", (yyvsp[(3) - (4)].str));
+		     (yyval.node) = 0;
+		   }
+		 } else {
+		   (yyval.node) = 0;
+		 }
+	       }
+             ;}
+    break;
+
+  case 193:
+#line 4549 "parser.y"
+    { 
+                Hash *h;
+		Node *parent_ns = 0;
+		List *scopes = Swig_scopename_tolist((yyvsp[(2) - (3)].str));
+		int ilen = Len(scopes);
+		int i;
+
+/*
+Printf(stdout, "==== Namespace %s creation...\n", $2);
+*/
+		(yyval.node) = 0;
+		for (i = 0; i < ilen; i++) {
+		  Node *ns = new_node("namespace");
+		  Symtab *current_symtab = Swig_symbol_current();
+		  String *scopename = Getitem(scopes, i);
+		  Setattr(ns, "name", scopename);
+		  (yyval.node) = ns;
+		  if (parent_ns)
+		    appendChild(parent_ns, ns);
+		  parent_ns = ns;
+		  h = Swig_symbol_clookup(scopename, 0);
+		  if (h && (current_symtab == Getattr(h, "sym:symtab")) && (Strcmp(nodeType(h), "namespace") == 0)) {
+/*
+Printf(stdout, "  Scope %s [found C++17 style]\n", scopename);
+*/
+		    if (Getattr(h, "alias")) {
+		      h = Getattr(h, "namespace");
+		      Swig_warning(WARN_PARSE_NAMESPACE_ALIAS, cparse_file, cparse_line, "Namespace alias '%s' not allowed here. Assuming '%s'\n",
+				   scopename, Getattr(h, "name"));
+		      scopename = Getattr(h, "name");
+		    }
+		    Swig_symbol_setscope(Getattr(h, "symtab"));
+		  } else {
+/*
+Printf(stdout, "  Scope %s [creating single scope C++17 style]\n", scopename);
+*/
+		    h = Swig_symbol_newscope();
+		    Swig_symbol_setscopename(scopename);
+		  }
+		  Delete(Namespaceprefix);
+		  Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		}
+		Delete(scopes);
+             ;}
+    break;
+
+  case 194:
+#line 4592 "parser.y"
+    {
+		Node *n = (yyvsp[(4) - (6)].node);
+		Node *top_ns = 0;
+		do {
+		  Setattr(n, "symtab", Swig_symbol_popscope());
+		  Delete(Namespaceprefix);
+		  Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+		  add_symbols(n);
+		  top_ns = n;
+		  n = parentNode(n);
+		} while(n);
+		appendChild((yyvsp[(4) - (6)].node), firstChild((yyvsp[(5) - (6)].node)));
+		Delete((yyvsp[(5) - (6)].node));
+		(yyval.node) = top_ns;
+             ;}
+    break;
+
+  case 195:
+#line 4607 "parser.y"
+    {
+	       Hash *h;
+	       (yyvsp[(1) - (2)].node) = Swig_symbol_current();
+	       h = Swig_symbol_clookup("    ",0);
+	       if (h && (Strcmp(nodeType(h),"namespace") == 0)) {
+		 Swig_symbol_setscope(Getattr(h,"symtab"));
+	       } else {
+		 Swig_symbol_newscope();
+		 /* we don't use "__unnamed__", but a long 'empty' name */
+		 Swig_symbol_setscopename("    ");
+	       }
+	       Namespaceprefix = 0;
+             ;}
+    break;
+
+  case 196:
+#line 4619 "parser.y"
+    {
+	       (yyval.node) = (yyvsp[(4) - (5)].node);
+	       set_nodeType((yyval.node),"namespace");
+	       Setattr((yyval.node),"unnamed","1");
+	       Setattr((yyval.node),"symtab", Swig_symbol_popscope());
+	       Swig_symbol_setscope((yyvsp[(1) - (5)].node));
+	       Delete(Namespaceprefix);
+	       Namespaceprefix = Swig_symbol_qualifiedscopename(0);
+	       add_symbols((yyval.node));
+             ;}
+    break;
+
+  case 197:
+#line 4629 "parser.y"
+    {
+	       /* Namespace alias */
+	       Node *n;
+	       (yyval.node) = new_node("namespace");
+	       Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id));
+	       Setattr((yyval.node),"alias",(yyvsp[(4) - (5)].str));
+	       n = Swig_symbol_clookup((yyvsp[(4) - (5)].str),0);
+	       if (!n) {
+		 Swig_error(cparse_file, cparse_line, "Unknown namespace '%s'\n", (yyvsp[(4) - (5)].str));
+		 (yyval.node) = 0;
+	       } else {
+		 if (Strcmp(nodeType(n),"namespace") != 0) {
+		   Swig_error(cparse_file, cparse_line, "'%s' is not a namespace\n",(yyvsp[(4) - (5)].str));
+		   (yyval.node) = 0;
+		 } else {
+		   while (Getattr(n,"alias")) {
+		     n = Getattr(n,"namespace");
+		   }
+		   Setattr((yyval.node),"namespace",n);
+		   add_symbols((yyval.node));
+		   /* Set up a scope alias */
+		   Swig_symbol_alias((yyvsp[(2) - (5)].id),Getattr(n,"symtab"));
+		 }
+	       }
+             ;}
+    break;
+
+  case 198:
+#line 4656 "parser.y"
+    {
+                   (yyval.node) = (yyvsp[(1) - (2)].node);
+                   /* Insert cpp_member (including any siblings) to the front of the cpp_members linked list */
+		   if ((yyval.node)) {
+		     Node *p = (yyval.node);
+		     Node *pp =0;
+		     while (p) {
+		       pp = p;
+		       p = nextSibling(p);
+		     }
+		     set_nextSibling(pp,(yyvsp[(2) - (2)].node));
+		     if ((yyvsp[(2) - (2)].node))
+		       set_previousSibling((yyvsp[(2) - (2)].node), pp);
+		   } else {
+		     (yyval.node) = (yyvsp[(2) - (2)].node);
+		   }
+             ;}
+    break;
+
+  case 199:
+#line 4673 "parser.y"
+    { 
+	       extendmode = 1;
+	       if (cplus_mode != CPLUS_PUBLIC) {
+		 Swig_error(cparse_file,cparse_line,"%%extend can only be used in a public section\n");
+	       }
+             ;}
+    break;
+
+  case 200:
+#line 4678 "parser.y"
+    {
+	       extendmode = 0;
+	     ;}
+    break;
+
+  case 201:
+#line 4680 "parser.y"
+    {
+	       (yyval.node) = new_node("extend");
+	       mark_nodes_as_extend((yyvsp[(4) - (7)].node));
+	       appendChild((yyval.node),(yyvsp[(4) - (7)].node));
+	       set_nextSibling((yyval.node),(yyvsp[(7) - (7)].node));
+	     ;}
+    break;
+
+  case 202:
+#line 4686 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 203:
+#line 4687 "parser.y"
+    { (yyval.node) = 0;;}
+    break;
+
+  case 204:
+#line 4688 "parser.y"
+    {
+	       Swig_error(cparse_file,cparse_line,"Syntax error in input(3).\n");
+	       Exit(EXIT_FAILURE);
+	       ;}
+    break;
+
+  case 205:
+#line 4691 "parser.y"
+    { 
+		 (yyval.node) = (yyvsp[(3) - (3)].node);
+   	     ;}
+    break;
+
+  case 206:
+#line 4702 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 207:
+#line 4703 "parser.y"
+    { 
+                 (yyval.node) = (yyvsp[(1) - (1)].node); 
+		 if (extendmode && current_class) {
+		   String *symname;
+		   symname= make_name((yyval.node),Getattr((yyval.node),"name"), Getattr((yyval.node),"decl"));
+		   if (Strcmp(symname,Getattr((yyval.node),"name")) == 0) {
+		     /* No renaming operation.  Set name to class name */
+		     Delete(yyrename);
+		     yyrename = NewString(Getattr(current_class,"sym:name"));
+		   } else {
+		     Delete(yyrename);
+		     yyrename = symname;
+		   }
+		 }
+		 add_symbols((yyval.node));
+                 default_arguments((yyval.node));
+             ;}
+    break;
+
+  case 208:
+#line 4720 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 209:
+#line 4721 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 210:
+#line 4722 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 211:
+#line 4723 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 212:
+#line 4724 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 213:
+#line 4725 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 214:
+#line 4726 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 215:
+#line 4727 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 216:
+#line 4728 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 217:
+#line 4729 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 218:
+#line 4730 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 219:
+#line 4731 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 220:
+#line 4732 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 221:
+#line 4733 "parser.y"
+    {(yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 222:
+#line 4734 "parser.y"
+    {(yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 223:
+#line 4735 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 224:
+#line 4737 "parser.y"
+    {
+		(yyval.node) = (yyvsp[(1) - (1)].node);
+	     ;}
+    break;
+
+  case 225:
+#line 4740 "parser.y"
+    {
+	         (yyval.node) = (yyvsp[(2) - (2)].node);
+		 set_comment((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].str));
+	     ;}
+    break;
+
+  case 226:
+#line 4744 "parser.y"
+    {
+	         (yyval.node) = (yyvsp[(1) - (2)].node);
+		 set_comment((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].str));
+	     ;}
+    break;
+
+  case 227:
+#line 4756 "parser.y"
+    {
+              if (inclass || extendmode) {
+		SwigType *decl = NewStringEmpty();
+		(yyval.node) = new_node("constructor");
+		Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id));
+		Setattr((yyval.node),"name",(yyvsp[(2) - (6)].type));
+		Setattr((yyval.node),"parms",(yyvsp[(4) - (6)].pl));
+		SwigType_add_function(decl,(yyvsp[(4) - (6)].pl));
+		Setattr((yyval.node),"decl",decl);
+		Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws);
+		Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf);
+		Setattr((yyval.node),"noexcept",(yyvsp[(6) - (6)].decl).nexcept);
+		Setattr((yyval.node),"final",(yyvsp[(6) - (6)].decl).final);
+		if (Len(scanner_ccode)) {
+		  String *code = Copy(scanner_ccode);
+		  Setattr((yyval.node),"code",code);
+		  Delete(code);
+		}
+		SetFlag((yyval.node),"feature:new");
+		if ((yyvsp[(6) - (6)].decl).defarg)
+		  Setattr((yyval.node),"value",(yyvsp[(6) - (6)].decl).defarg);
+	      } else {
+		(yyval.node) = 0;
+              }
+              ;}
+    break;
+
+  case 228:
+#line 4785 "parser.y"
+    {
+               String *name = NewStringf("%s",(yyvsp[(2) - (6)].str));
+	       if (*(Char(name)) != '~') Insert(name,0,"~");
+               (yyval.node) = new_node("destructor");
+	       Setattr((yyval.node),"name",name);
+	       Delete(name);
+	       if (Len(scanner_ccode)) {
+		 String *code = Copy(scanner_ccode);
+		 Setattr((yyval.node),"code",code);
+		 Delete(code);
+	       }
+	       {
+		 String *decl = NewStringEmpty();
+		 SwigType_add_function(decl,(yyvsp[(4) - (6)].pl));
+		 Setattr((yyval.node),"decl",decl);
+		 Delete(decl);
+	       }
+	       Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].dtype).throws);
+	       Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].dtype).throwf);
+	       Setattr((yyval.node),"noexcept",(yyvsp[(6) - (6)].dtype).nexcept);
+	       Setattr((yyval.node),"final",(yyvsp[(6) - (6)].dtype).final);
+	       if ((yyvsp[(6) - (6)].dtype).val)
+	         Setattr((yyval.node),"value",(yyvsp[(6) - (6)].dtype).val);
+	       if ((yyvsp[(6) - (6)].dtype).qualifier)
+		 Swig_error(cparse_file, cparse_line, "Destructor %s %s cannot have a qualifier.\n", Swig_name_decl((yyval.node)), SwigType_str((yyvsp[(6) - (6)].dtype).qualifier, 0));
+	       add_symbols((yyval.node));
+	      ;}
+    break;
+
+  case 229:
+#line 4815 "parser.y"
+    {
+		String *name;
+		(yyval.node) = new_node("destructor");
+		Setattr((yyval.node),"storage","virtual");
+	        name = NewStringf("%s",(yyvsp[(3) - (7)].str));
+		if (*(Char(name)) != '~') Insert(name,0,"~");
+		Setattr((yyval.node),"name",name);
+		Delete(name);
+		Setattr((yyval.node),"throws",(yyvsp[(7) - (7)].dtype).throws);
+		Setattr((yyval.node),"throw",(yyvsp[(7) - (7)].dtype).throwf);
+		Setattr((yyval.node),"noexcept",(yyvsp[(7) - (7)].dtype).nexcept);
+		Setattr((yyval.node),"final",(yyvsp[(7) - (7)].dtype).final);
+		if ((yyvsp[(7) - (7)].dtype).val)
+		  Setattr((yyval.node),"value",(yyvsp[(7) - (7)].dtype).val);
+		if (Len(scanner_ccode)) {
+		  String *code = Copy(scanner_ccode);
+		  Setattr((yyval.node),"code",code);
+		  Delete(code);
+		}
+		{
+		  String *decl = NewStringEmpty();
+		  SwigType_add_function(decl,(yyvsp[(5) - (7)].pl));
+		  Setattr((yyval.node),"decl",decl);
+		  Delete(decl);
+		}
+		if ((yyvsp[(7) - (7)].dtype).qualifier)
+		  Swig_error(cparse_file, cparse_line, "Destructor %s %s cannot have a qualifier.\n", Swig_name_decl((yyval.node)), SwigType_str((yyvsp[(7) - (7)].dtype).qualifier, 0));
+		add_symbols((yyval.node));
+	      ;}
+    break;
+
+  case 230:
+#line 4848 "parser.y"
+    {
+                 (yyval.node) = new_node("cdecl");
+                 Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type));
+		 Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str));
+		 Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id));
+
+		 SwigType_add_function((yyvsp[(4) - (8)].type),(yyvsp[(6) - (8)].pl));
+		 if ((yyvsp[(8) - (8)].dtype).qualifier) {
+		   SwigType_push((yyvsp[(4) - (8)].type),(yyvsp[(8) - (8)].dtype).qualifier);
+		 }
+		 if ((yyvsp[(8) - (8)].dtype).val) {
+		   Setattr((yyval.node),"value",(yyvsp[(8) - (8)].dtype).val);
+		 }
+		 Setattr((yyval.node),"refqualifier",(yyvsp[(8) - (8)].dtype).refqualifier);
+		 Setattr((yyval.node),"decl",(yyvsp[(4) - (8)].type));
+		 Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl));
+		 Setattr((yyval.node),"conversion_operator","1");
+		 add_symbols((yyval.node));
+              ;}
+    break;
+
+  case 231:
+#line 4867 "parser.y"
+    {
+		 SwigType *decl;
+                 (yyval.node) = new_node("cdecl");
+                 Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type));
+		 Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str));
+		 Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id));
+		 decl = NewStringEmpty();
+		 SwigType_add_reference(decl);
+		 SwigType_add_function(decl,(yyvsp[(6) - (8)].pl));
+		 if ((yyvsp[(8) - (8)].dtype).qualifier) {
+		   SwigType_push(decl,(yyvsp[(8) - (8)].dtype).qualifier);
+		 }
+		 if ((yyvsp[(8) - (8)].dtype).val) {
+		   Setattr((yyval.node),"value",(yyvsp[(8) - (8)].dtype).val);
+		 }
+		 Setattr((yyval.node),"refqualifier",(yyvsp[(8) - (8)].dtype).refqualifier);
+		 Setattr((yyval.node),"decl",decl);
+		 Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl));
+		 Setattr((yyval.node),"conversion_operator","1");
+		 add_symbols((yyval.node));
+	       ;}
+    break;
+
+  case 232:
+#line 4888 "parser.y"
+    {
+		 SwigType *decl;
+                 (yyval.node) = new_node("cdecl");
+                 Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type));
+		 Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str));
+		 Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id));
+		 decl = NewStringEmpty();
+		 SwigType_add_rvalue_reference(decl);
+		 SwigType_add_function(decl,(yyvsp[(6) - (8)].pl));
+		 if ((yyvsp[(8) - (8)].dtype).qualifier) {
+		   SwigType_push(decl,(yyvsp[(8) - (8)].dtype).qualifier);
+		 }
+		 if ((yyvsp[(8) - (8)].dtype).val) {
+		   Setattr((yyval.node),"value",(yyvsp[(8) - (8)].dtype).val);
+		 }
+		 Setattr((yyval.node),"refqualifier",(yyvsp[(8) - (8)].dtype).refqualifier);
+		 Setattr((yyval.node),"decl",decl);
+		 Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl));
+		 Setattr((yyval.node),"conversion_operator","1");
+		 add_symbols((yyval.node));
+	       ;}
+    break;
+
+  case 233:
+#line 4910 "parser.y"
+    {
+		 SwigType *decl;
+                 (yyval.node) = new_node("cdecl");
+                 Setattr((yyval.node),"type",(yyvsp[(3) - (9)].type));
+		 Setattr((yyval.node),"name",(yyvsp[(2) - (9)].str));
+		 Setattr((yyval.node),"storage",(yyvsp[(1) - (9)].id));
+		 decl = NewStringEmpty();
+		 SwigType_add_pointer(decl);
+		 SwigType_add_reference(decl);
+		 SwigType_add_function(decl,(yyvsp[(7) - (9)].pl));
+		 if ((yyvsp[(9) - (9)].dtype).qualifier) {
+		   SwigType_push(decl,(yyvsp[(9) - (9)].dtype).qualifier);
+		 }
+		 if ((yyvsp[(9) - (9)].dtype).val) {
+		   Setattr((yyval.node),"value",(yyvsp[(9) - (9)].dtype).val);
+		 }
+		 Setattr((yyval.node),"refqualifier",(yyvsp[(9) - (9)].dtype).refqualifier);
+		 Setattr((yyval.node),"decl",decl);
+		 Setattr((yyval.node),"parms",(yyvsp[(7) - (9)].pl));
+		 Setattr((yyval.node),"conversion_operator","1");
+		 add_symbols((yyval.node));
+	       ;}
+    break;
+
+  case 234:
+#line 4933 "parser.y"
+    {
+		String *t = NewStringEmpty();
+		(yyval.node) = new_node("cdecl");
+		Setattr((yyval.node),"type",(yyvsp[(3) - (7)].type));
+		Setattr((yyval.node),"name",(yyvsp[(2) - (7)].str));
+		 Setattr((yyval.node),"storage",(yyvsp[(1) - (7)].id));
+		SwigType_add_function(t,(yyvsp[(5) - (7)].pl));
+		if ((yyvsp[(7) - (7)].dtype).qualifier) {
+		  SwigType_push(t,(yyvsp[(7) - (7)].dtype).qualifier);
+		}
+		if ((yyvsp[(7) - (7)].dtype).val) {
+		  Setattr((yyval.node),"value",(yyvsp[(7) - (7)].dtype).val);
+		}
+		Setattr((yyval.node),"refqualifier",(yyvsp[(7) - (7)].dtype).refqualifier);
+		Setattr((yyval.node),"decl",t);
+		Setattr((yyval.node),"parms",(yyvsp[(5) - (7)].pl));
+		Setattr((yyval.node),"conversion_operator","1");
+		add_symbols((yyval.node));
+              ;}
+    break;
+
+  case 235:
+#line 4956 "parser.y"
+    {
+                 skip_balanced('{','}');
+                 (yyval.node) = 0;
+               ;}
+    break;
+
+  case 236:
+#line 4964 "parser.y"
+    {
+                skip_balanced('(',')');
+                (yyval.node) = 0;
+              ;}
+    break;
+
+  case 237:
+#line 4971 "parser.y"
+    { 
+                (yyval.node) = new_node("access");
+		Setattr((yyval.node),"kind","public");
+                cplus_mode = CPLUS_PUBLIC;
+              ;}
+    break;
+
+  case 238:
+#line 4978 "parser.y"
+    { 
+                (yyval.node) = new_node("access");
+                Setattr((yyval.node),"kind","private");
+		cplus_mode = CPLUS_PRIVATE;
+	      ;}
+    break;
+
+  case 239:
+#line 4986 "parser.y"
+    { 
+		(yyval.node) = new_node("access");
+		Setattr((yyval.node),"kind","protected");
+		cplus_mode = CPLUS_PROTECTED;
+	      ;}
+    break;
+
+  case 240:
+#line 4994 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 241:
+#line 4997 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 242:
+#line 5001 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 243:
+#line 5004 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 244:
+#line 5005 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 245:
+#line 5006 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 246:
+#line 5007 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 247:
+#line 5008 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 248:
+#line 5009 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 249:
+#line 5010 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 250:
+#line 5011 "parser.y"
+    { (yyval.node) = (yyvsp[(1) - (1)].node); ;}
+    break;
+
+  case 251:
+#line 5014 "parser.y"
+    {
+	            Clear(scanner_ccode);
+		    (yyval.dtype).val = 0;
+		    (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier;
+		    (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier;
+		    (yyval.dtype).bitfield = 0;
+		    (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws;
+		    (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf;
+		    (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept;
+		    (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final;
+               ;}
+    break;
+
+  case 252:
+#line 5025 "parser.y"
+    {
+	            Clear(scanner_ccode);
+		    (yyval.dtype).val = (yyvsp[(3) - (4)].dtype).val;
+		    (yyval.dtype).qualifier = (yyvsp[(1) - (4)].dtype).qualifier;
+		    (yyval.dtype).refqualifier = (yyvsp[(1) - (4)].dtype).refqualifier;
+		    (yyval.dtype).bitfield = 0;
+		    (yyval.dtype).throws = (yyvsp[(1) - (4)].dtype).throws;
+		    (yyval.dtype).throwf = (yyvsp[(1) - (4)].dtype).throwf;
+		    (yyval.dtype).nexcept = (yyvsp[(1) - (4)].dtype).nexcept;
+		    (yyval.dtype).final = (yyvsp[(1) - (4)].dtype).final;
+               ;}
+    break;
+
+  case 253:
+#line 5036 "parser.y"
+    { 
+		    skip_balanced('{','}'); 
+		    (yyval.dtype).val = 0;
+		    (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier;
+		    (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier;
+		    (yyval.dtype).bitfield = 0;
+		    (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws;
+		    (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf;
+		    (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept;
+		    (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final;
+	       ;}
+    break;
+
+  case 254:
+#line 5049 "parser.y"
+    { 
+                     Clear(scanner_ccode);
+                     (yyval.dtype).val = 0;
+                     (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier;
+                     (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier;
+                     (yyval.dtype).bitfield = 0;
+                     (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws;
+                     (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf;
+                     (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept;
+                     (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final;
+                ;}
+    break;
+
+  case 255:
+#line 5060 "parser.y"
+    { 
+                     Clear(scanner_ccode);
+                     (yyval.dtype).val = (yyvsp[(3) - (4)].dtype).val;
+                     (yyval.dtype).qualifier = (yyvsp[(1) - (4)].dtype).qualifier;
+                     (yyval.dtype).refqualifier = (yyvsp[(1) - (4)].dtype).refqualifier;
+                     (yyval.dtype).bitfield = 0;
+                     (yyval.dtype).throws = (yyvsp[(1) - (4)].dtype).throws; 
+                     (yyval.dtype).throwf = (yyvsp[(1) - (4)].dtype).throwf; 
+                     (yyval.dtype).nexcept = (yyvsp[(1) - (4)].dtype).nexcept;
+                     (yyval.dtype).final = (yyvsp[(1) - (4)].dtype).final;
+               ;}
+    break;
+
+  case 256:
+#line 5071 "parser.y"
+    { 
+                     skip_balanced('{','}');
+                     (yyval.dtype).val = 0;
+                     (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier;
+                     (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier;
+                     (yyval.dtype).bitfield = 0;
+                     (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; 
+                     (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; 
+                     (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept;
+                     (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final;
+               ;}
+    break;
+
+  case 257:
+#line 5085 "parser.y"
+    { ;}
+    break;
+
+  case 258:
+#line 5088 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type);
+                  /* Printf(stdout,"primitive = '%s'\n", $$);*/
+                ;}
+    break;
+
+  case 259:
+#line 5091 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 260:
+#line 5092 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 261:
+#line 5096 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 262:
+#line 5098 "parser.y"
+    {
+		  (yyval.type) = (yyvsp[(1) - (1)].str);
+               ;}
+    break;
+
+  case 263:
+#line 5106 "parser.y"
+    {
+                   if (Strcmp((yyvsp[(2) - (2)].str),"C") == 0) {
+		     (yyval.id) = "externc";
+                   } else if (Strcmp((yyvsp[(2) - (2)].str),"C++") == 0) {
+		     (yyval.id) = "extern";
+		   } else {
+		     Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (2)].str));
+		     (yyval.id) = 0;
+		   }
+               ;}
+    break;
+
+  case 264:
+#line 5118 "parser.y"
+    { (yyval.id) = "extern"; ;}
+    break;
+
+  case 265:
+#line 5119 "parser.y"
+    { (yyval.id) = (yyvsp[(1) - (1)].id); ;}
+    break;
+
+  case 266:
+#line 5120 "parser.y"
+    {
+                if (Equal((yyvsp[(1) - (2)].id), "extern")) {
+                  (yyval.id) = "extern thread_local";
+                } else {
+                  (yyval.id) = "externc thread_local";
+                }
+	       ;}
+    break;
+
+  case 267:
+#line 5127 "parser.y"
+    { (yyval.id) = "typedef"; ;}
+    break;
+
+  case 268:
+#line 5128 "parser.y"
+    { (yyval.id) = "static"; ;}
+    break;
+
+  case 269:
+#line 5129 "parser.y"
+    { (yyval.id) = "typedef"; ;}
+    break;
+
+  case 270:
+#line 5130 "parser.y"
+    { (yyval.id) = "virtual"; ;}
+    break;
+
+  case 271:
+#line 5131 "parser.y"
+    { (yyval.id) = "friend"; ;}
+    break;
+
+  case 272:
+#line 5132 "parser.y"
+    { (yyval.id) = "explicit"; ;}
+    break;
+
+  case 273:
+#line 5133 "parser.y"
+    { (yyval.id) = "constexpr"; ;}
+    break;
+
+  case 274:
+#line 5134 "parser.y"
+    { (yyval.id) = "explicit constexpr"; ;}
+    break;
+
+  case 275:
+#line 5135 "parser.y"
+    { (yyval.id) = "explicit constexpr"; ;}
+    break;
+
+  case 276:
+#line 5136 "parser.y"
+    { (yyval.id) = "static constexpr"; ;}
+    break;
+
+  case 277:
+#line 5137 "parser.y"
+    { (yyval.id) = "static constexpr"; ;}
+    break;
+
+  case 278:
+#line 5138 "parser.y"
+    { (yyval.id) = "thread_local"; ;}
+    break;
+
+  case 279:
+#line 5139 "parser.y"
+    { (yyval.id) = "static thread_local"; ;}
+    break;
+
+  case 280:
+#line 5140 "parser.y"
+    { (yyval.id) = "static thread_local"; ;}
+    break;
+
+  case 281:
+#line 5141 "parser.y"
+    { (yyval.id) = "extern thread_local"; ;}
+    break;
+
+  case 282:
+#line 5142 "parser.y"
+    { (yyval.id) = "extern thread_local"; ;}
+    break;
+
+  case 283:
+#line 5143 "parser.y"
+    { (yyval.id) = 0; ;}
+    break;
+
+  case 284:
+#line 5150 "parser.y"
+    {
+                 Parm *p;
+		 (yyval.pl) = (yyvsp[(1) - (1)].pl);
+		 p = (yyvsp[(1) - (1)].pl);
+                 while (p) {
+		   Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY);
+		   p = nextSibling(p);
+                 }
+               ;}
+    break;
+
+  case 285:
+#line 5161 "parser.y"
+    {
+                  set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl));
+                  (yyval.pl) = (yyvsp[(1) - (2)].p);
+		;}
+    break;
+
+  case 286:
+#line 5165 "parser.y"
+    {
+		  (yyval.pl) = 0;
+		  previousNode = currentNode;
+		  currentNode=0;
+	       ;}
+    break;
+
+  case 287:
+#line 5172 "parser.y"
+    {
+                 set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl));
+		 (yyval.pl) = (yyvsp[(2) - (3)].p);
+                ;}
+    break;
+
+  case 288:
+#line 5176 "parser.y"
+    {
+		 set_comment(previousNode, (yyvsp[(2) - (4)].str));
+                 set_nextSibling((yyvsp[(3) - (4)].p), (yyvsp[(4) - (4)].pl));
+		 (yyval.pl) = (yyvsp[(3) - (4)].p);
+               ;}
+    break;
+
+  case 289:
+#line 5181 "parser.y"
+    { (yyval.pl) = 0; ;}
+    break;
+
+  case 290:
+#line 5185 "parser.y"
+    {
+                   SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type);
+		   (yyval.p) = NewParmWithoutFileLineInfo((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id);
+		   previousNode = currentNode;
+		   currentNode = (yyval.p);
+		   Setfile((yyval.p),cparse_file);
+		   Setline((yyval.p),cparse_line);
+		   if ((yyvsp[(2) - (2)].decl).defarg) {
+		     Setattr((yyval.p),"value",(yyvsp[(2) - (2)].decl).defarg);
+		   }
+		;}
+    break;
+
+  case 291:
+#line 5197 "parser.y"
+    {
+                  (yyval.p) = NewParmWithoutFileLineInfo(NewStringf("template<class> %s %s", (yyvsp[(5) - (7)].id),(yyvsp[(6) - (7)].str)), 0);
+		  previousNode = currentNode;
+		  currentNode = (yyval.p);
+		  Setfile((yyval.p),cparse_file);
+		  Setline((yyval.p),cparse_line);
+                  if ((yyvsp[(7) - (7)].dtype).val) {
+                    Setattr((yyval.p),"value",(yyvsp[(7) - (7)].dtype).val);
+                  }
+                ;}
+    break;
+
+  case 292:
+#line 5207 "parser.y"
+    {
+		  SwigType *t = NewString("v(...)");
+		  (yyval.p) = NewParmWithoutFileLineInfo(t, 0);
+		  previousNode = currentNode;
+		  currentNode = (yyval.p);
+		  Setfile((yyval.p),cparse_file);
+		  Setline((yyval.p),cparse_line);
+		;}
+    break;
+
+  case 293:
+#line 5217 "parser.y"
+    {
+		  (yyval.p) = (yyvsp[(1) - (1)].p);
+		;}
+    break;
+
+  case 294:
+#line 5220 "parser.y"
+    {
+		  (yyval.p) = (yyvsp[(2) - (2)].p);
+		  set_comment((yyvsp[(2) - (2)].p), (yyvsp[(1) - (2)].str));
+		;}
+    break;
+
+  case 295:
+#line 5224 "parser.y"
+    {
+		  (yyval.p) = (yyvsp[(1) - (2)].p);
+		  set_comment((yyvsp[(1) - (2)].p), (yyvsp[(2) - (2)].str));
+		;}
+    break;
+
+  case 296:
+#line 5230 "parser.y"
+    {
+                 Parm *p;
+		 (yyval.p) = (yyvsp[(1) - (1)].p);
+		 p = (yyvsp[(1) - (1)].p);
+                 while (p) {
+		   if (Getattr(p,"type")) {
+		     Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY);
+		   }
+		   p = nextSibling(p);
+                 }
+               ;}
+    break;
+
+  case 297:
+#line 5243 "parser.y"
+    {
+                  set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].p));
+                  (yyval.p) = (yyvsp[(1) - (2)].p);
+		;}
+    break;
+
+  case 298:
+#line 5247 "parser.y"
+    { (yyval.p) = 0; ;}
+    break;
+
+  case 299:
+#line 5250 "parser.y"
+    {
+                 set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].p));
+		 (yyval.p) = (yyvsp[(2) - (3)].p);
+                ;}
+    break;
+
+  case 300:
+#line 5254 "parser.y"
+    { (yyval.p) = 0; ;}
+    break;
+
+  case 301:
+#line 5258 "parser.y"
+    {
+		  (yyval.p) = (yyvsp[(1) - (1)].p);
+		  {
+		    /* We need to make a possible adjustment for integer parameters. */
+		    SwigType *type;
+		    Node     *n = 0;
+
+		    while (!n) {
+		      type = Getattr((yyvsp[(1) - (1)].p),"type");
+		      n = Swig_symbol_clookup(type,0);     /* See if we can find a node that matches the typename */
+		      if ((n) && (Strcmp(nodeType(n),"cdecl") == 0)) {
+			SwigType *decl = Getattr(n,"decl");
+			if (!SwigType_isfunction(decl)) {
+			  String *value = Getattr(n,"value");
+			  if (value) {
+			    String *v = Copy(value);
+			    Setattr((yyvsp[(1) - (1)].p),"type",v);
+			    Delete(v);
+			    n = 0;
+			  }
+			}
+		      } else {
+			break;
+		      }
+		    }
+		  }
+
+               ;}
+    break;
+
+  case 302:
+#line 5286 "parser.y"
+    {
+                  (yyval.p) = NewParmWithoutFileLineInfo(0,0);
+                  Setfile((yyval.p),cparse_file);
+		  Setline((yyval.p),cparse_line);
+		  Setattr((yyval.p),"value",(yyvsp[(1) - (1)].dtype).val);
+               ;}
+    break;
+
+  case 303:
+#line 5294 "parser.y"
+    {
+		 (yyval.dtype) = (yyvsp[(1) - (2)].dtype);
+		 Printf((yyval.dtype).val, "%s", (yyvsp[(2) - (2)].dtype));
+	       ;}
+    break;
+
+  case 304:
+#line 5298 "parser.y"
+    { (yyval.dtype).val = NewStringEmpty(); ;}
+    break;
+
+  case 305:
+#line 5301 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf(",%s%s", (yyvsp[(2) - (3)].dtype), (yyvsp[(3) - (3)].dtype));
+		 (yyval.dtype).type = 0;
+	       ;}
+    break;
+
+  case 306:
+#line 5305 "parser.y"
+    { (yyval.dtype).val = NewStringEmpty(); ;}
+    break;
+
+  case 307:
+#line 5308 "parser.y"
+    { 
+                  (yyval.dtype) = (yyvsp[(2) - (2)].dtype); 
+		  if ((yyvsp[(2) - (2)].dtype).type == T_ERROR) {
+		    Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n");
+		    (yyval.dtype).val = 0;
+		    (yyval.dtype).rawval = 0;
+		    (yyval.dtype).bitfield = 0;
+		    (yyval.dtype).throws = 0;
+		    (yyval.dtype).throwf = 0;
+		    (yyval.dtype).nexcept = 0;
+		    (yyval.dtype).final = 0;
+		  }
+               ;}
+    break;
+
+  case 308:
+#line 5321 "parser.y"
+    { 
+		  (yyval.dtype) = (yyvsp[(2) - (5)].dtype);
+		  if ((yyvsp[(2) - (5)].dtype).type == T_ERROR) {
+		    Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n");
+		    (yyval.dtype) = (yyvsp[(2) - (5)].dtype);
+		    (yyval.dtype).val = 0;
+		    (yyval.dtype).rawval = 0;
+		    (yyval.dtype).bitfield = 0;
+		    (yyval.dtype).throws = 0;
+		    (yyval.dtype).throwf = 0;
+		    (yyval.dtype).nexcept = 0;
+		    (yyval.dtype).final = 0;
+		  } else {
+		    (yyval.dtype).val = NewStringf("%s[%s]",(yyvsp[(2) - (5)].dtype).val,(yyvsp[(4) - (5)].dtype).val); 
+		  }		  
+               ;}
+    break;
+
+  case 309:
+#line 5337 "parser.y"
+    {
+		 skip_balanced('{','}');
+		 (yyval.dtype).val = NewString(scanner_ccode);
+		 (yyval.dtype).rawval = 0;
+                 (yyval.dtype).type = T_INT;
+		 (yyval.dtype).bitfield = 0;
+		 (yyval.dtype).throws = 0;
+		 (yyval.dtype).throwf = 0;
+		 (yyval.dtype).nexcept = 0;
+		 (yyval.dtype).final = 0;
+	       ;}
+    break;
+
+  case 310:
+#line 5348 "parser.y"
+    { 
+		 (yyval.dtype).val = 0;
+		 (yyval.dtype).rawval = 0;
+		 (yyval.dtype).type = 0;
+		 (yyval.dtype).bitfield = (yyvsp[(2) - (2)].dtype).val;
+		 (yyval.dtype).throws = 0;
+		 (yyval.dtype).throwf = 0;
+		 (yyval.dtype).nexcept = 0;
+		 (yyval.dtype).final = 0;
+	       ;}
+    break;
+
+  case 311:
+#line 5358 "parser.y"
+    {
+                 (yyval.dtype).val = 0;
+                 (yyval.dtype).rawval = 0;
+                 (yyval.dtype).type = T_INT;
+		 (yyval.dtype).bitfield = 0;
+		 (yyval.dtype).throws = 0;
+		 (yyval.dtype).throwf = 0;
+		 (yyval.dtype).nexcept = 0;
+		 (yyval.dtype).final = 0;
+               ;}
+    break;
+
+  case 312:
+#line 5370 "parser.y"
+    {
+                 (yyval.decl) = (yyvsp[(1) - (2)].decl);
+		 (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val;
+            ;}
+    break;
+
+  case 313:
+#line 5374 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(1) - (2)].decl);
+	      (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val;
+            ;}
+    break;
+
+  case 314:
+#line 5378 "parser.y"
+    {
+   	      (yyval.decl).type = 0;
+              (yyval.decl).id = 0;
+	      (yyval.decl).defarg = (yyvsp[(1) - (1)].dtype).rawval ? (yyvsp[(1) - (1)].dtype).rawval : (yyvsp[(1) - (1)].dtype).val;
+            ;}
+    break;
+
+  case 315:
+#line 5385 "parser.y"
+    {
+	      SwigType *t;
+	      (yyval.decl) = (yyvsp[(1) - (5)].decl);
+	      t = NewStringEmpty();
+	      SwigType_add_function(t,(yyvsp[(3) - (5)].pl));
+	      if ((yyvsp[(5) - (5)].dtype).qualifier)
+	        SwigType_push(t, (yyvsp[(5) - (5)].dtype).qualifier);
+	      if (!(yyval.decl).have_parms) {
+		(yyval.decl).parms = (yyvsp[(3) - (5)].pl);
+		(yyval.decl).have_parms = 1;
+	      }
+	      if (!(yyval.decl).type) {
+		(yyval.decl).type = t;
+	      } else {
+		SwigType_push(t, (yyval.decl).type);
+		Delete((yyval.decl).type);
+		(yyval.decl).type = t;
+	      }
+	      (yyval.decl).defarg = 0;
+	    ;}
+    break;
+
+  case 316:
+#line 5407 "parser.y"
+    {
+                 (yyval.decl) = (yyvsp[(1) - (1)].decl);
+		 if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
+		   Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
+		 } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) {
+		   SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type);
+		   if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
+		     Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
+		   } else {
+		     (yyval.decl).parms = 0;
+		   }
+		   SwigType_push((yyvsp[(1) - (1)].decl).type,ta);
+		   Delete(ta);
+		 } else {
+		   (yyval.decl).parms = 0;
+		 }
+            ;}
+    break;
+
+  case 317:
+#line 5424 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(1) - (1)].decl);
+	      if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
+		Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
+	      } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) {
+		SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type);
+		if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) {
+		  Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type));
+		} else {
+		  (yyval.decl).parms = 0;
+		}
+		SwigType_push((yyvsp[(1) - (1)].decl).type,ta);
+		Delete(ta);
+	      } else {
+		(yyval.decl).parms = 0;
+	      }
+            ;}
+    break;
+
+  case 318:
+#line 5443 "parser.y"
+    {
+	      SwigType *t;
+	      (yyval.decl) = (yyvsp[(1) - (5)].decl);
+	      t = NewStringEmpty();
+	      SwigType_add_function(t, (yyvsp[(3) - (5)].pl));
+	      if ((yyvsp[(5) - (5)].dtype).qualifier)
+	        SwigType_push(t, (yyvsp[(5) - (5)].dtype).qualifier);
+	      if (!(yyval.decl).have_parms) {
+		(yyval.decl).parms = (yyvsp[(3) - (5)].pl);
+		(yyval.decl).have_parms = 1;
+	      }
+	      if (!(yyval.decl).type) {
+		(yyval.decl).type = t;
+	      } else {
+		SwigType_push(t, (yyval.decl).type);
+		Delete((yyval.decl).type);
+		(yyval.decl).type = t;
+	      }
+	    ;}
+    break;
+
+  case 319:
+#line 5462 "parser.y"
+    {
+   	      (yyval.decl).type = 0;
+              (yyval.decl).id = 0;
+	      (yyval.decl).parms = 0;
+	      ;}
+    break;
+
+  case 320:
+#line 5469 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(2) - (2)].decl);
+	      if ((yyval.decl).type) {
+		SwigType_push((yyvsp[(1) - (2)].type),(yyval.decl).type);
+		Delete((yyval.decl).type);
+	      }
+	      (yyval.decl).type = (yyvsp[(1) - (2)].type);
+           ;}
+    break;
+
+  case 321:
+#line 5477 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(3) - (3)].decl);
+	      SwigType_add_reference((yyvsp[(1) - (3)].type));
+              if ((yyval.decl).type) {
+		SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type);
+		Delete((yyval.decl).type);
+	      }
+	      (yyval.decl).type = (yyvsp[(1) - (3)].type);
+           ;}
+    break;
+
+  case 322:
+#line 5486 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(3) - (3)].decl);
+	      SwigType_add_rvalue_reference((yyvsp[(1) - (3)].type));
+              if ((yyval.decl).type) {
+		SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type);
+		Delete((yyval.decl).type);
+	      }
+	      (yyval.decl).type = (yyvsp[(1) - (3)].type);
+           ;}
+    break;
+
+  case 323:
+#line 5495 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(1) - (1)].decl);
+	      if (!(yyval.decl).type) (yyval.decl).type = NewStringEmpty();
+           ;}
+    break;
+
+  case 324:
+#line 5499 "parser.y"
+    {
+	     (yyval.decl) = (yyvsp[(2) - (2)].decl);
+	     (yyval.decl).type = NewStringEmpty();
+	     SwigType_add_reference((yyval.decl).type);
+	     if ((yyvsp[(2) - (2)].decl).type) {
+	       SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type);
+	       Delete((yyvsp[(2) - (2)].decl).type);
+	     }
+           ;}
+    break;
+
+  case 325:
+#line 5508 "parser.y"
+    {
+	     /* Introduced in C++11, move operator && */
+             /* Adds one S/R conflict */
+	     (yyval.decl) = (yyvsp[(2) - (2)].decl);
+	     (yyval.decl).type = NewStringEmpty();
+	     SwigType_add_rvalue_reference((yyval.decl).type);
+	     if ((yyvsp[(2) - (2)].decl).type) {
+	       SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type);
+	       Delete((yyvsp[(2) - (2)].decl).type);
+	     }
+           ;}
+    break;
+
+  case 326:
+#line 5519 "parser.y"
+    { 
+	     SwigType *t = NewStringEmpty();
+
+	     (yyval.decl) = (yyvsp[(3) - (3)].decl);
+	     SwigType_add_memberpointer(t,(yyvsp[(1) - (3)].str));
+	     if ((yyval.decl).type) {
+	       SwigType_push(t,(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     }
+	     (yyval.decl).type = t;
+	     ;}
+    break;
+
+  case 327:
+#line 5530 "parser.y"
+    { 
+	     SwigType *t = NewStringEmpty();
+	     (yyval.decl) = (yyvsp[(4) - (4)].decl);
+	     SwigType_add_memberpointer(t,(yyvsp[(2) - (4)].str));
+	     SwigType_push((yyvsp[(1) - (4)].type),t);
+	     if ((yyval.decl).type) {
+	       SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     }
+	     (yyval.decl).type = (yyvsp[(1) - (4)].type);
+	     Delete(t);
+	   ;}
+    break;
+
+  case 328:
+#line 5542 "parser.y"
+    { 
+	     (yyval.decl) = (yyvsp[(5) - (5)].decl);
+	     SwigType_add_memberpointer((yyvsp[(1) - (5)].type),(yyvsp[(2) - (5)].str));
+	     SwigType_add_reference((yyvsp[(1) - (5)].type));
+	     if ((yyval.decl).type) {
+	       SwigType_push((yyvsp[(1) - (5)].type),(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     }
+	     (yyval.decl).type = (yyvsp[(1) - (5)].type);
+	   ;}
+    break;
+
+  case 329:
+#line 5552 "parser.y"
+    { 
+	     SwigType *t = NewStringEmpty();
+	     (yyval.decl) = (yyvsp[(4) - (4)].decl);
+	     SwigType_add_memberpointer(t,(yyvsp[(1) - (4)].str));
+	     SwigType_add_reference(t);
+	     if ((yyval.decl).type) {
+	       SwigType_push(t,(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     } 
+	     (yyval.decl).type = t;
+	   ;}
+    break;
+
+  case 330:
+#line 5566 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(3) - (3)].decl);
+	      if ((yyval.decl).type) {
+		SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type);
+		Delete((yyval.decl).type);
+	      }
+	      (yyval.decl).type = (yyvsp[(1) - (3)].type);
+           ;}
+    break;
+
+  case 331:
+#line 5574 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(4) - (4)].decl);
+	      SwigType_add_reference((yyvsp[(1) - (4)].type));
+              if ((yyval.decl).type) {
+		SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type);
+		Delete((yyval.decl).type);
+	      }
+	      (yyval.decl).type = (yyvsp[(1) - (4)].type);
+           ;}
+    break;
+
+  case 332:
+#line 5583 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(4) - (4)].decl);
+	      SwigType_add_rvalue_reference((yyvsp[(1) - (4)].type));
+              if ((yyval.decl).type) {
+		SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type);
+		Delete((yyval.decl).type);
+	      }
+	      (yyval.decl).type = (yyvsp[(1) - (4)].type);
+           ;}
+    break;
+
+  case 333:
+#line 5592 "parser.y"
+    {
+              (yyval.decl) = (yyvsp[(2) - (2)].decl);
+	      if (!(yyval.decl).type) (yyval.decl).type = NewStringEmpty();
+           ;}
+    break;
+
+  case 334:
+#line 5596 "parser.y"
+    {
+	     (yyval.decl) = (yyvsp[(3) - (3)].decl);
+	     (yyval.decl).type = NewStringEmpty();
+	     SwigType_add_reference((yyval.decl).type);
+	     if ((yyvsp[(3) - (3)].decl).type) {
+	       SwigType_push((yyval.decl).type,(yyvsp[(3) - (3)].decl).type);
+	       Delete((yyvsp[(3) - (3)].decl).type);
+	     }
+           ;}
+    break;
+
+  case 335:
+#line 5605 "parser.y"
+    {
+	     /* Introduced in C++11, move operator && */
+             /* Adds one S/R conflict */
+	     (yyval.decl) = (yyvsp[(3) - (3)].decl);
+	     (yyval.decl).type = NewStringEmpty();
+	     SwigType_add_rvalue_reference((yyval.decl).type);
+	     if ((yyvsp[(3) - (3)].decl).type) {
+	       SwigType_push((yyval.decl).type,(yyvsp[(3) - (3)].decl).type);
+	       Delete((yyvsp[(3) - (3)].decl).type);
+	     }
+           ;}
+    break;
+
+  case 336:
+#line 5616 "parser.y"
+    {
+	     SwigType *t = NewStringEmpty();
+
+	     (yyval.decl) = (yyvsp[(4) - (4)].decl);
+	     SwigType_add_memberpointer(t,(yyvsp[(1) - (4)].str));
+	     if ((yyval.decl).type) {
+	       SwigType_push(t,(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     }
+	     (yyval.decl).type = t;
+	     ;}
+    break;
+
+  case 337:
+#line 5627 "parser.y"
+    {
+	     SwigType *t = NewStringEmpty();
+	     (yyval.decl) = (yyvsp[(5) - (5)].decl);
+	     SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str));
+	     SwigType_push((yyvsp[(1) - (5)].type),t);
+	     if ((yyval.decl).type) {
+	       SwigType_push((yyvsp[(1) - (5)].type),(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     }
+	     (yyval.decl).type = (yyvsp[(1) - (5)].type);
+	     Delete(t);
+	   ;}
+    break;
+
+  case 338:
+#line 5639 "parser.y"
+    {
+	     (yyval.decl) = (yyvsp[(6) - (6)].decl);
+	     SwigType_add_memberpointer((yyvsp[(1) - (6)].type),(yyvsp[(2) - (6)].str));
+	     SwigType_add_reference((yyvsp[(1) - (6)].type));
+	     if ((yyval.decl).type) {
+	       SwigType_push((yyvsp[(1) - (6)].type),(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     }
+	     (yyval.decl).type = (yyvsp[(1) - (6)].type);
+	   ;}
+    break;
+
+  case 339:
+#line 5649 "parser.y"
+    {
+	     (yyval.decl) = (yyvsp[(6) - (6)].decl);
+	     SwigType_add_memberpointer((yyvsp[(1) - (6)].type),(yyvsp[(2) - (6)].str));
+	     SwigType_add_rvalue_reference((yyvsp[(1) - (6)].type));
+	     if ((yyval.decl).type) {
+	       SwigType_push((yyvsp[(1) - (6)].type),(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     }
+	     (yyval.decl).type = (yyvsp[(1) - (6)].type);
+	   ;}
+    break;
+
+  case 340:
+#line 5659 "parser.y"
+    {
+	     SwigType *t = NewStringEmpty();
+	     (yyval.decl) = (yyvsp[(5) - (5)].decl);
+	     SwigType_add_memberpointer(t,(yyvsp[(1) - (5)].str));
+	     SwigType_add_reference(t);
+	     if ((yyval.decl).type) {
+	       SwigType_push(t,(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     } 
+	     (yyval.decl).type = t;
+	   ;}
+    break;
+
+  case 341:
+#line 5670 "parser.y"
+    {
+	     SwigType *t = NewStringEmpty();
+	     (yyval.decl) = (yyvsp[(5) - (5)].decl);
+	     SwigType_add_memberpointer(t,(yyvsp[(1) - (5)].str));
+	     SwigType_add_rvalue_reference(t);
+	     if ((yyval.decl).type) {
+	       SwigType_push(t,(yyval.decl).type);
+	       Delete((yyval.decl).type);
+	     } 
+	     (yyval.decl).type = t;
+	   ;}
+    break;
+
+  case 342:
+#line 5683 "parser.y"
+    {
+                /* Note: This is non-standard C.  Template declarator is allowed to follow an identifier */
+                 (yyval.decl).id = Char((yyvsp[(1) - (1)].str));
+		 (yyval.decl).type = 0;
+		 (yyval.decl).parms = 0;
+		 (yyval.decl).have_parms = 0;
+                  ;}
+    break;
+
+  case 343:
+#line 5690 "parser.y"
+    {
+                  (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str)));
+                  (yyval.decl).type = 0;
+                  (yyval.decl).parms = 0;
+                  (yyval.decl).have_parms = 0;
+                  ;}
+    break;
+
+  case 344:
+#line 5698 "parser.y"
+    {
+                  (yyval.decl).id = Char((yyvsp[(2) - (3)].str));
+                  (yyval.decl).type = 0;
+                  (yyval.decl).parms = 0;
+                  (yyval.decl).have_parms = 0;
+                  ;}
+    break;
+
+  case 345:
+#line 5714 "parser.y"
+    {
+		    (yyval.decl) = (yyvsp[(3) - (4)].decl);
+		    if ((yyval.decl).type) {
+		      SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = (yyvsp[(2) - (4)].type);
+                  ;}
+    break;
+
+  case 346:
+#line 5722 "parser.y"
+    {
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(4) - (5)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str));
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+		    ;}
+    break;
+
+  case 347:
+#line 5733 "parser.y"
+    { 
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(1) - (3)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_array(t,"");
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+                  ;}
+    break;
+
+  case 348:
+#line 5744 "parser.y"
+    { 
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(1) - (4)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val);
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+                  ;}
+    break;
+
+  case 349:
+#line 5755 "parser.y"
+    {
+		    SwigType *t;
+                    (yyval.decl) = (yyvsp[(1) - (4)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_function(t,(yyvsp[(3) - (4)].pl));
+		    if (!(yyval.decl).have_parms) {
+		      (yyval.decl).parms = (yyvsp[(3) - (4)].pl);
+		      (yyval.decl).have_parms = 1;
+		    }
+		    if (!(yyval.decl).type) {
+		      (yyval.decl).type = t;
+		    } else {
+		      SwigType_push(t, (yyval.decl).type);
+		      Delete((yyval.decl).type);
+		      (yyval.decl).type = t;
+		    }
+		  ;}
+    break;
+
+  case 350:
+#line 5774 "parser.y"
+    {
+                /* Note: This is non-standard C.  Template declarator is allowed to follow an identifier */
+                 (yyval.decl).id = Char((yyvsp[(1) - (1)].str));
+		 (yyval.decl).type = 0;
+		 (yyval.decl).parms = 0;
+		 (yyval.decl).have_parms = 0;
+                  ;}
+    break;
+
+  case 351:
+#line 5782 "parser.y"
+    {
+                  (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str)));
+                  (yyval.decl).type = 0;
+                  (yyval.decl).parms = 0;
+                  (yyval.decl).have_parms = 0;
+                  ;}
+    break;
+
+  case 352:
+#line 5799 "parser.y"
+    {
+		    (yyval.decl) = (yyvsp[(3) - (4)].decl);
+		    if ((yyval.decl).type) {
+		      SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = (yyvsp[(2) - (4)].type);
+                  ;}
+    break;
+
+  case 353:
+#line 5807 "parser.y"
+    {
+                    (yyval.decl) = (yyvsp[(3) - (4)].decl);
+		    if (!(yyval.decl).type) {
+		      (yyval.decl).type = NewStringEmpty();
+		    }
+		    SwigType_add_reference((yyval.decl).type);
+                  ;}
+    break;
+
+  case 354:
+#line 5814 "parser.y"
+    {
+                    (yyval.decl) = (yyvsp[(3) - (4)].decl);
+		    if (!(yyval.decl).type) {
+		      (yyval.decl).type = NewStringEmpty();
+		    }
+		    SwigType_add_rvalue_reference((yyval.decl).type);
+                  ;}
+    break;
+
+  case 355:
+#line 5821 "parser.y"
+    {
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(4) - (5)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str));
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+		  ;}
+    break;
+
+  case 356:
+#line 5832 "parser.y"
+    {
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(5) - (6)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_memberpointer(t, (yyvsp[(2) - (6)].str));
+		    SwigType_push(t, (yyvsp[(4) - (6)].str));
+		    if ((yyval.decl).type) {
+		      SwigType_push(t, (yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+		  ;}
+    break;
+
+  case 357:
+#line 5844 "parser.y"
+    {
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(4) - (5)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_memberpointer(t, (yyvsp[(2) - (5)].str));
+		    if ((yyval.decl).type) {
+		      SwigType_push(t, (yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+		  ;}
+    break;
+
+  case 358:
+#line 5855 "parser.y"
+    {
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(5) - (6)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_memberpointer(t, (yyvsp[(2) - (6)].str));
+		    SwigType_push(t, (yyvsp[(4) - (6)].str));
+		    if ((yyval.decl).type) {
+		      SwigType_push(t, (yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+		  ;}
+    break;
+
+  case 359:
+#line 5867 "parser.y"
+    { 
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(1) - (3)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_array(t,"");
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+                  ;}
+    break;
+
+  case 360:
+#line 5878 "parser.y"
+    { 
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(1) - (4)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val);
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+                  ;}
+    break;
+
+  case 361:
+#line 5889 "parser.y"
+    {
+		    SwigType *t;
+                    (yyval.decl) = (yyvsp[(1) - (4)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_function(t,(yyvsp[(3) - (4)].pl));
+		    if (!(yyval.decl).have_parms) {
+		      (yyval.decl).parms = (yyvsp[(3) - (4)].pl);
+		      (yyval.decl).have_parms = 1;
+		    }
+		    if (!(yyval.decl).type) {
+		      (yyval.decl).type = t;
+		    } else {
+		      SwigType_push(t, (yyval.decl).type);
+		      Delete((yyval.decl).type);
+		      (yyval.decl).type = t;
+		    }
+		  ;}
+    break;
+
+  case 362:
+#line 5909 "parser.y"
+    {
+		    SwigType *t;
+                    Append((yyvsp[(1) - (5)].str), " "); /* intervening space is mandatory */
+                    Append((yyvsp[(1) - (5)].str), Char((yyvsp[(2) - (5)].id)));
+		    (yyval.decl).id = Char((yyvsp[(1) - (5)].str));
+		    t = NewStringEmpty();
+		    SwigType_add_function(t,(yyvsp[(4) - (5)].pl));
+		    if (!(yyval.decl).have_parms) {
+		      (yyval.decl).parms = (yyvsp[(4) - (5)].pl);
+		      (yyval.decl).have_parms = 1;
+		    }
+		    if (!(yyval.decl).type) {
+		      (yyval.decl).type = t;
+		    } else {
+		      SwigType_push(t, (yyval.decl).type);
+		      Delete((yyval.decl).type);
+		      (yyval.decl).type = t;
+		    }
+		  ;}
+    break;
+
+  case 363:
+#line 5930 "parser.y"
+    {
+		    (yyval.decl).type = (yyvsp[(1) - (1)].type);
+                    (yyval.decl).id = 0;
+		    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+                  ;}
+    break;
+
+  case 364:
+#line 5936 "parser.y"
+    { 
+                     (yyval.decl) = (yyvsp[(2) - (2)].decl);
+                     SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type);
+		     (yyval.decl).type = (yyvsp[(1) - (2)].type);
+		     Delete((yyvsp[(2) - (2)].decl).type);
+                  ;}
+    break;
+
+  case 365:
+#line 5942 "parser.y"
+    {
+		    (yyval.decl).type = (yyvsp[(1) - (2)].type);
+		    SwigType_add_reference((yyval.decl).type);
+		    (yyval.decl).id = 0;
+		    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+		  ;}
+    break;
+
+  case 366:
+#line 5949 "parser.y"
+    {
+		    (yyval.decl).type = (yyvsp[(1) - (2)].type);
+		    SwigType_add_rvalue_reference((yyval.decl).type);
+		    (yyval.decl).id = 0;
+		    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+		  ;}
+    break;
+
+  case 367:
+#line 5956 "parser.y"
+    {
+		    (yyval.decl) = (yyvsp[(3) - (3)].decl);
+		    SwigType_add_reference((yyvsp[(1) - (3)].type));
+		    if ((yyval.decl).type) {
+		      SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = (yyvsp[(1) - (3)].type);
+                  ;}
+    break;
+
+  case 368:
+#line 5965 "parser.y"
+    {
+		    (yyval.decl) = (yyvsp[(3) - (3)].decl);
+		    SwigType_add_rvalue_reference((yyvsp[(1) - (3)].type));
+		    if ((yyval.decl).type) {
+		      SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = (yyvsp[(1) - (3)].type);
+                  ;}
+    break;
+
+  case 369:
+#line 5974 "parser.y"
+    {
+		    (yyval.decl) = (yyvsp[(1) - (1)].decl);
+                  ;}
+    break;
+
+  case 370:
+#line 5977 "parser.y"
+    {
+		    (yyval.decl) = (yyvsp[(2) - (2)].decl);
+		    (yyval.decl).type = NewStringEmpty();
+		    SwigType_add_reference((yyval.decl).type);
+		    if ((yyvsp[(2) - (2)].decl).type) {
+		      SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type);
+		      Delete((yyvsp[(2) - (2)].decl).type);
+		    }
+                  ;}
+    break;
+
+  case 371:
+#line 5986 "parser.y"
+    {
+		    (yyval.decl) = (yyvsp[(2) - (2)].decl);
+		    (yyval.decl).type = NewStringEmpty();
+		    SwigType_add_rvalue_reference((yyval.decl).type);
+		    if ((yyvsp[(2) - (2)].decl).type) {
+		      SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type);
+		      Delete((yyvsp[(2) - (2)].decl).type);
+		    }
+                  ;}
+    break;
+
+  case 372:
+#line 5995 "parser.y"
+    {
+                    (yyval.decl).id = 0;
+                    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+                    (yyval.decl).type = NewStringEmpty();
+		    SwigType_add_reference((yyval.decl).type);
+                  ;}
+    break;
+
+  case 373:
+#line 6002 "parser.y"
+    {
+                    (yyval.decl).id = 0;
+                    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+                    (yyval.decl).type = NewStringEmpty();
+		    SwigType_add_rvalue_reference((yyval.decl).type);
+                  ;}
+    break;
+
+  case 374:
+#line 6009 "parser.y"
+    { 
+		    (yyval.decl).type = NewStringEmpty();
+                    SwigType_add_memberpointer((yyval.decl).type,(yyvsp[(1) - (2)].str));
+                    (yyval.decl).id = 0;
+                    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+      	          ;}
+    break;
+
+  case 375:
+#line 6016 "parser.y"
+    {
+		    (yyval.decl).type = NewStringEmpty();
+		    SwigType_add_memberpointer((yyval.decl).type, (yyvsp[(1) - (3)].str));
+		    SwigType_push((yyval.decl).type, (yyvsp[(3) - (3)].str));
+		    (yyval.decl).id = 0;
+		    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+		  ;}
+    break;
+
+  case 376:
+#line 6024 "parser.y"
+    { 
+		    SwigType *t = NewStringEmpty();
+                    (yyval.decl).type = (yyvsp[(1) - (3)].type);
+		    (yyval.decl).id = 0;
+		    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+		    SwigType_add_memberpointer(t,(yyvsp[(2) - (3)].str));
+		    SwigType_push((yyval.decl).type,t);
+		    Delete(t);
+                  ;}
+    break;
+
+  case 377:
+#line 6034 "parser.y"
+    { 
+		    (yyval.decl) = (yyvsp[(4) - (4)].decl);
+		    SwigType_add_memberpointer((yyvsp[(1) - (4)].type),(yyvsp[(2) - (4)].str));
+		    if ((yyval.decl).type) {
+		      SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = (yyvsp[(1) - (4)].type);
+                  ;}
+    break;
+
+  case 378:
+#line 6045 "parser.y"
+    { 
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(1) - (3)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_array(t,"");
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+                  ;}
+    break;
+
+  case 379:
+#line 6056 "parser.y"
+    { 
+		    SwigType *t;
+		    (yyval.decl) = (yyvsp[(1) - (4)].decl);
+		    t = NewStringEmpty();
+		    SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val);
+		    if ((yyval.decl).type) {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		    }
+		    (yyval.decl).type = t;
+                  ;}
+    break;
+
+  case 380:
+#line 6067 "parser.y"
+    { 
+		    (yyval.decl).type = NewStringEmpty();
+		    (yyval.decl).id = 0;
+		    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+		    SwigType_add_array((yyval.decl).type,"");
+                  ;}
+    break;
+
+  case 381:
+#line 6074 "parser.y"
+    { 
+		    (yyval.decl).type = NewStringEmpty();
+		    (yyval.decl).id = 0;
+		    (yyval.decl).parms = 0;
+		    (yyval.decl).have_parms = 0;
+		    SwigType_add_array((yyval.decl).type,(yyvsp[(2) - (3)].dtype).val);
+		  ;}
+    break;
+
+  case 382:
+#line 6081 "parser.y"
+    {
+                    (yyval.decl) = (yyvsp[(2) - (3)].decl);
+		  ;}
+    break;
+
+  case 383:
+#line 6084 "parser.y"
+    {
+		    SwigType *t;
+                    (yyval.decl) = (yyvsp[(1) - (4)].decl);
+		    t = NewStringEmpty();
+                    SwigType_add_function(t,(yyvsp[(3) - (4)].pl));
+		    if (!(yyval.decl).type) {
+		      (yyval.decl).type = t;
+		    } else {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		      (yyval.decl).type = t;
+		    }
+		    if (!(yyval.decl).have_parms) {
+		      (yyval.decl).parms = (yyvsp[(3) - (4)].pl);
+		      (yyval.decl).have_parms = 1;
+		    }
+		  ;}
+    break;
+
+  case 384:
+#line 6101 "parser.y"
+    {
+		    SwigType *t;
+                    (yyval.decl) = (yyvsp[(1) - (5)].decl);
+		    t = NewStringEmpty();
+                    SwigType_add_function(t,(yyvsp[(3) - (5)].pl));
+		    SwigType_push(t, (yyvsp[(5) - (5)].dtype).qualifier);
+		    if (!(yyval.decl).type) {
+		      (yyval.decl).type = t;
+		    } else {
+		      SwigType_push(t,(yyval.decl).type);
+		      Delete((yyval.decl).type);
+		      (yyval.decl).type = t;
+		    }
+		    if (!(yyval.decl).have_parms) {
+		      (yyval.decl).parms = (yyvsp[(3) - (5)].pl);
+		      (yyval.decl).have_parms = 1;
+		    }
+		  ;}
+    break;
+
+  case 385:
+#line 6119 "parser.y"
+    {
+                    (yyval.decl).type = NewStringEmpty();
+                    SwigType_add_function((yyval.decl).type,(yyvsp[(2) - (3)].pl));
+		    (yyval.decl).parms = (yyvsp[(2) - (3)].pl);
+		    (yyval.decl).have_parms = 1;
+		    (yyval.decl).id = 0;
+                  ;}
+    break;
+
+  case 386:
+#line 6129 "parser.y"
+    { 
+             (yyval.type) = NewStringEmpty();
+             SwigType_add_pointer((yyval.type));
+	     SwigType_push((yyval.type),(yyvsp[(2) - (3)].str));
+	     SwigType_push((yyval.type),(yyvsp[(3) - (3)].type));
+	     Delete((yyvsp[(3) - (3)].type));
+           ;}
+    break;
+
+  case 387:
+#line 6136 "parser.y"
+    {
+	     (yyval.type) = NewStringEmpty();
+	     SwigType_add_pointer((yyval.type));
+	     SwigType_push((yyval.type),(yyvsp[(2) - (2)].type));
+	     Delete((yyvsp[(2) - (2)].type));
+	   ;}
+    break;
+
+  case 388:
+#line 6142 "parser.y"
+    { 
+	     (yyval.type) = NewStringEmpty();
+	     SwigType_add_pointer((yyval.type));
+	     SwigType_push((yyval.type),(yyvsp[(2) - (2)].str));
+           ;}
+    break;
+
+  case 389:
+#line 6147 "parser.y"
+    {
+	     (yyval.type) = NewStringEmpty();
+	     SwigType_add_pointer((yyval.type));
+           ;}
+    break;
+
+  case 390:
+#line 6154 "parser.y"
+    {
+		  (yyval.dtype).qualifier = (yyvsp[(1) - (1)].str);
+		  (yyval.dtype).refqualifier = 0;
+	       ;}
+    break;
+
+  case 391:
+#line 6158 "parser.y"
+    {
+		  (yyval.dtype).qualifier = (yyvsp[(1) - (2)].str);
+		  (yyval.dtype).refqualifier = (yyvsp[(2) - (2)].str);
+		  SwigType_push((yyval.dtype).qualifier, (yyvsp[(2) - (2)].str));
+	       ;}
+    break;
+
+  case 392:
+#line 6163 "parser.y"
+    {
+		  (yyval.dtype).qualifier = NewStringEmpty();
+		  (yyval.dtype).refqualifier = (yyvsp[(1) - (1)].str);
+		  SwigType_push((yyval.dtype).qualifier, (yyvsp[(1) - (1)].str));
+	       ;}
+    break;
+
+  case 393:
+#line 6170 "parser.y"
+    {
+	          (yyval.str) = NewStringEmpty();
+	          SwigType_add_reference((yyval.str));
+	       ;}
+    break;
+
+  case 394:
+#line 6174 "parser.y"
+    {
+	          (yyval.str) = NewStringEmpty();
+	          SwigType_add_rvalue_reference((yyval.str));
+	       ;}
+    break;
+
+  case 395:
+#line 6180 "parser.y"
+    {
+	          (yyval.str) = NewStringEmpty();
+	          if ((yyvsp[(1) - (1)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (1)].id));
+               ;}
+    break;
+
+  case 396:
+#line 6184 "parser.y"
+    {
+		  (yyval.str) = (yyvsp[(2) - (2)].str);
+	          if ((yyvsp[(1) - (2)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (2)].id));
+               ;}
+    break;
+
+  case 397:
+#line 6190 "parser.y"
+    { (yyval.id) = "const"; ;}
+    break;
+
+  case 398:
+#line 6191 "parser.y"
+    { (yyval.id) = "volatile"; ;}
+    break;
+
+  case 399:
+#line 6192 "parser.y"
+    { (yyval.id) = 0; ;}
+    break;
+
+  case 400:
+#line 6198 "parser.y"
+    {
+                   (yyval.type) = (yyvsp[(1) - (1)].type);
+                   Replace((yyval.type),"typename ","", DOH_REPLACE_ANY);
+                ;}
+    break;
+
+  case 401:
+#line 6204 "parser.y"
+    {
+                   (yyval.type) = (yyvsp[(2) - (2)].type);
+	           SwigType_push((yyval.type),(yyvsp[(1) - (2)].str));
+               ;}
+    break;
+
+  case 402:
+#line 6208 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 403:
+#line 6209 "parser.y"
+    {
+		  (yyval.type) = (yyvsp[(1) - (2)].type);
+	          SwigType_push((yyval.type),(yyvsp[(2) - (2)].str));
+	       ;}
+    break;
+
+  case 404:
+#line 6213 "parser.y"
+    {
+		  (yyval.type) = (yyvsp[(2) - (3)].type);
+	          SwigType_push((yyval.type),(yyvsp[(3) - (3)].str));
+	          SwigType_push((yyval.type),(yyvsp[(1) - (3)].str));
+	       ;}
+    break;
+
+  case 405:
+#line 6220 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type);
+                  /* Printf(stdout,"primitive = '%s'\n", $$);*/
+               ;}
+    break;
+
+  case 406:
+#line 6223 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 407:
+#line 6224 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 408:
+#line 6228 "parser.y"
+    { (yyval.type) = NewStringf("enum %s", (yyvsp[(2) - (2)].str)); ;}
+    break;
+
+  case 409:
+#line 6229 "parser.y"
+    { (yyval.type) = (yyvsp[(1) - (1)].type); ;}
+    break;
+
+  case 410:
+#line 6231 "parser.y"
+    {
+		  (yyval.type) = (yyvsp[(1) - (1)].str);
+               ;}
+    break;
+
+  case 411:
+#line 6234 "parser.y"
+    { 
+		 (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].str));
+               ;}
+    break;
+
+  case 412:
+#line 6237 "parser.y"
+    {
+                 (yyval.type) = (yyvsp[(1) - (1)].type);
+               ;}
+    break;
+
+  case 413:
+#line 6242 "parser.y"
+    {
+                 Node *n = Swig_symbol_clookup((yyvsp[(3) - (4)].str),0);
+                 if (!n) {
+		   Swig_error(cparse_file, cparse_line, "Identifier %s not defined.\n", (yyvsp[(3) - (4)].str));
+                   (yyval.type) = (yyvsp[(3) - (4)].str);
+                 } else {
+                   (yyval.type) = Getattr(n, "type");
+                 }
+               ;}
+    break;
+
+  case 414:
+#line 6253 "parser.y"
+    {
+		 if (!(yyvsp[(1) - (1)].ptype).type) (yyvsp[(1) - (1)].ptype).type = NewString("int");
+		 if ((yyvsp[(1) - (1)].ptype).us) {
+		   (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (1)].ptype).us, (yyvsp[(1) - (1)].ptype).type);
+		   Delete((yyvsp[(1) - (1)].ptype).us);
+                   Delete((yyvsp[(1) - (1)].ptype).type);
+		 } else {
+                   (yyval.type) = (yyvsp[(1) - (1)].ptype).type;
+		 }
+		 if (Cmp((yyval.type),"signed int") == 0) {
+		   Delete((yyval.type));
+		   (yyval.type) = NewString("int");
+                 } else if (Cmp((yyval.type),"signed long") == 0) {
+		   Delete((yyval.type));
+                   (yyval.type) = NewString("long");
+                 } else if (Cmp((yyval.type),"signed short") == 0) {
+		   Delete((yyval.type));
+		   (yyval.type) = NewString("short");
+		 } else if (Cmp((yyval.type),"signed long long") == 0) {
+		   Delete((yyval.type));
+		   (yyval.type) = NewString("long long");
+		 }
+               ;}
+    break;
+
+  case 415:
+#line 6278 "parser.y"
+    { 
+                 (yyval.ptype) = (yyvsp[(1) - (1)].ptype);
+               ;}
+    break;
+
+  case 416:
+#line 6281 "parser.y"
+    {
+                    if ((yyvsp[(1) - (2)].ptype).us && (yyvsp[(2) - (2)].ptype).us) {
+		      Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(2) - (2)].ptype).us);
+		    }
+                    (yyval.ptype) = (yyvsp[(2) - (2)].ptype);
+                    if ((yyvsp[(1) - (2)].ptype).us) (yyval.ptype).us = (yyvsp[(1) - (2)].ptype).us;
+		    if ((yyvsp[(1) - (2)].ptype).type) {
+		      if (!(yyvsp[(2) - (2)].ptype).type) (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type;
+		      else {
+			int err = 0;
+			if ((Cmp((yyvsp[(1) - (2)].ptype).type,"long") == 0)) {
+			  if ((Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) || (Strncmp((yyvsp[(2) - (2)].ptype).type,"double",6) == 0)) {
+			    (yyval.ptype).type = NewStringf("long %s", (yyvsp[(2) - (2)].ptype).type);
+			  } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) {
+			    (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type;
+			  } else {
+			    err = 1;
+			  }
+			} else if ((Cmp((yyvsp[(1) - (2)].ptype).type,"short")) == 0) {
+			  if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) {
+			    (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type;
+			  } else {
+			    err = 1;
+			  }
+			} else if (Cmp((yyvsp[(1) - (2)].ptype).type,"int") == 0) {
+			  (yyval.ptype).type = (yyvsp[(2) - (2)].ptype).type;
+			} else if (Cmp((yyvsp[(1) - (2)].ptype).type,"double") == 0) {
+			  if (Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) {
+			    (yyval.ptype).type = NewString("long double");
+			  } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"_Complex") == 0) {
+			    (yyval.ptype).type = NewString("double _Complex");
+			  } else {
+			    err = 1;
+			  }
+			} else if (Cmp((yyvsp[(1) - (2)].ptype).type,"float") == 0) {
+			  if (Cmp((yyvsp[(2) - (2)].ptype).type,"_Complex") == 0) {
+			    (yyval.ptype).type = NewString("float _Complex");
+			  } else {
+			    err = 1;
+			  }
+			} else if (Cmp((yyvsp[(1) - (2)].ptype).type,"_Complex") == 0) {
+			  (yyval.ptype).type = NewStringf("%s _Complex", (yyvsp[(2) - (2)].ptype).type);
+			} else {
+			  err = 1;
+			}
+			if (err) {
+			  Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(1) - (2)].ptype).type);
+			}
+		      }
+		    }
+               ;}
+    break;
+
+  case 417:
+#line 6335 "parser.y"
+    { 
+		    (yyval.ptype).type = NewString("int");
+                    (yyval.ptype).us = 0;
+               ;}
+    break;
+
+  case 418:
+#line 6339 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("short");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 419:
+#line 6343 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("long");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 420:
+#line 6347 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("char");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 421:
+#line 6351 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("wchar_t");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 422:
+#line 6355 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("float");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 423:
+#line 6359 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("double");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 424:
+#line 6363 "parser.y"
+    { 
+                    (yyval.ptype).us = NewString("signed");
+                    (yyval.ptype).type = 0;
+                ;}
+    break;
+
+  case 425:
+#line 6367 "parser.y"
+    { 
+                    (yyval.ptype).us = NewString("unsigned");
+                    (yyval.ptype).type = 0;
+                ;}
+    break;
+
+  case 426:
+#line 6371 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("_Complex");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 427:
+#line 6375 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("__int8");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 428:
+#line 6379 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("__int16");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 429:
+#line 6383 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("__int32");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 430:
+#line 6387 "parser.y"
+    { 
+                    (yyval.ptype).type = NewString("__int64");
+                    (yyval.ptype).us = 0;
+                ;}
+    break;
+
+  case 431:
+#line 6393 "parser.y"
+    { /* scanner_check_typedef(); */ ;}
+    break;
+
+  case 432:
+#line 6393 "parser.y"
+    {
+                   (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
+		   if ((yyval.dtype).type == T_STRING) {
+		     (yyval.dtype).rawval = NewStringf("\"%(escape)s\"",(yyval.dtype).val);
+		   } else if ((yyval.dtype).type != T_CHAR && (yyval.dtype).type != T_WSTRING && (yyval.dtype).type != T_WCHAR) {
+		     (yyval.dtype).rawval = NewStringf("%s", (yyval.dtype).val);
+		   }
+		   (yyval.dtype).qualifier = 0;
+		   (yyval.dtype).refqualifier = 0;
+		   (yyval.dtype).bitfield = 0;
+		   (yyval.dtype).throws = 0;
+		   (yyval.dtype).throwf = 0;
+		   (yyval.dtype).nexcept = 0;
+		   (yyval.dtype).final = 0;
+		   scanner_ignore_typedef();
+                ;}
+    break;
+
+  case 433:
+#line 6409 "parser.y"
+    {
+		  (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+		;}
+    break;
+
+  case 434:
+#line 6414 "parser.y"
+    {
+		  (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+		;}
+    break;
+
+  case 435:
+#line 6417 "parser.y"
+    {
+		  (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+		;}
+    break;
+
+  case 436:
+#line 6423 "parser.y"
+    {
+		  (yyval.dtype).val = NewString("delete");
+		  (yyval.dtype).rawval = 0;
+		  (yyval.dtype).type = T_STRING;
+		  (yyval.dtype).qualifier = 0;
+		  (yyval.dtype).refqualifier = 0;
+		  (yyval.dtype).bitfield = 0;
+		  (yyval.dtype).throws = 0;
+		  (yyval.dtype).throwf = 0;
+		  (yyval.dtype).nexcept = 0;
+		  (yyval.dtype).final = 0;
+		;}
+    break;
+
+  case 437:
+#line 6438 "parser.y"
+    {
+		  (yyval.dtype).val = NewString("default");
+		  (yyval.dtype).rawval = 0;
+		  (yyval.dtype).type = T_STRING;
+		  (yyval.dtype).qualifier = 0;
+		  (yyval.dtype).refqualifier = 0;
+		  (yyval.dtype).bitfield = 0;
+		  (yyval.dtype).throws = 0;
+		  (yyval.dtype).throwf = 0;
+		  (yyval.dtype).nexcept = 0;
+		  (yyval.dtype).final = 0;
+		;}
+    break;
+
+  case 438:
+#line 6454 "parser.y"
+    { (yyval.id) = (yyvsp[(1) - (1)].id); ;}
+    break;
+
+  case 439:
+#line 6455 "parser.y"
+    { (yyval.id) = (char *) 0;;}
+    break;
+
+  case 444:
+#line 6474 "parser.y"
+    {
+		  Setattr((yyvsp[(1) - (1)].node),"_last",(yyvsp[(1) - (1)].node));
+		  (yyval.node) = (yyvsp[(1) - (1)].node);
+		;}
+    break;
+
+  case 445:
+#line 6478 "parser.y"
+    {
+		  Setattr((yyvsp[(1) - (2)].node),"_last",(yyvsp[(1) - (2)].node));
+		  set_comment((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].str));
+		  (yyval.node) = (yyvsp[(1) - (2)].node);
+		;}
+    break;
+
+  case 446:
+#line 6483 "parser.y"
+    {
+		  if ((yyvsp[(3) - (3)].node)) {
+		    set_nextSibling((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
+		    Setattr((yyvsp[(1) - (3)].node),"_last",Getattr((yyvsp[(3) - (3)].node),"_last"));
+		    Setattr((yyvsp[(3) - (3)].node),"_last",NULL);
+		  } else {
+		    Setattr((yyvsp[(1) - (3)].node),"_last",(yyvsp[(1) - (3)].node));
+		  }
+		  (yyval.node) = (yyvsp[(1) - (3)].node);
+		;}
+    break;
+
+  case 447:
+#line 6493 "parser.y"
+    {
+		  if ((yyvsp[(4) - (4)].node)) {
+		    set_nextSibling((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
+		    Setattr((yyvsp[(1) - (4)].node),"_last",Getattr((yyvsp[(4) - (4)].node),"_last"));
+		    Setattr((yyvsp[(4) - (4)].node),"_last",NULL);
+		  } else {
+		    Setattr((yyvsp[(1) - (4)].node),"_last",(yyvsp[(1) - (4)].node));
+		  }
+		  set_comment((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].str));
+		  (yyval.node) = (yyvsp[(1) - (4)].node);
+		;}
+    break;
+
+  case 448:
+#line 6504 "parser.y"
+    {
+		  (yyval.node) = 0;
+		;}
+    break;
+
+  case 449:
+#line 6509 "parser.y"
+    {
+		  (yyval.node) = (yyvsp[(2) - (3)].node);
+		;}
+    break;
+
+  case 450:
+#line 6514 "parser.y"
+    {
+		  (yyval.node) = (yyvsp[(1) - (1)].node);
+		;}
+    break;
+
+  case 451:
+#line 6517 "parser.y"
+    {
+		  (yyval.node) = (yyvsp[(2) - (2)].node);
+		  set_comment((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].str));
+		;}
+    break;
+
+  case 452:
+#line 6523 "parser.y"
+    {
+		   SwigType *type = NewSwigType(T_INT);
+		   (yyval.node) = new_node("enumitem");
+		   Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id));
+		   Setattr((yyval.node),"type",type);
+		   SetFlag((yyval.node),"feature:immutable");
+		   Delete(type);
+		 ;}
+    break;
+
+  case 453:
+#line 6531 "parser.y"
+    {
+		   SwigType *type = NewSwigType((yyvsp[(3) - (3)].dtype).type == T_BOOL ? T_BOOL : ((yyvsp[(3) - (3)].dtype).type == T_CHAR ? T_CHAR : T_INT));
+		   (yyval.node) = new_node("enumitem");
+		   Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
+		   Setattr((yyval.node),"type",type);
+		   SetFlag((yyval.node),"feature:immutable");
+		   Setattr((yyval.node),"enumvalue", (yyvsp[(3) - (3)].dtype).val);
+		   Setattr((yyval.node),"value",(yyvsp[(1) - (3)].id));
+		   Delete(type);
+                 ;}
+    break;
+
+  case 454:
+#line 6543 "parser.y"
+    {
+                   (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+		   if (((yyval.dtype).type != T_INT) && ((yyval.dtype).type != T_UINT) &&
+		       ((yyval.dtype).type != T_LONG) && ((yyval.dtype).type != T_ULONG) &&
+		       ((yyval.dtype).type != T_LONGLONG) && ((yyval.dtype).type != T_ULONGLONG) &&
+		       ((yyval.dtype).type != T_SHORT) && ((yyval.dtype).type != T_USHORT) &&
+		       ((yyval.dtype).type != T_SCHAR) && ((yyval.dtype).type != T_UCHAR) &&
+		       ((yyval.dtype).type != T_CHAR) && ((yyval.dtype).type != T_BOOL)) {
+		     Swig_error(cparse_file,cparse_line,"Type error. Expecting an integral type\n");
+		   }
+                ;}
+    break;
+
+  case 455:
+#line 6558 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 456:
+#line 6559 "parser.y"
+    {
+		 Node *n;
+		 (yyval.dtype).val = (yyvsp[(1) - (1)].type);
+		 (yyval.dtype).type = T_INT;
+		 /* Check if value is in scope */
+		 n = Swig_symbol_clookup((yyvsp[(1) - (1)].type),0);
+		 if (n) {
+                   /* A band-aid for enum values used in expressions. */
+                   if (Strcmp(nodeType(n),"enumitem") == 0) {
+                     String *q = Swig_symbol_qualified(n);
+                     if (q) {
+                       (yyval.dtype).val = NewStringf("%s::%s", q, Getattr(n,"name"));
+                       Delete(q);
+                     }
+                   }
+		 }
+               ;}
+    break;
+
+  case 457:
+#line 6579 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s->%s", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
+		 (yyval.dtype).type = 0;
+	       ;}
+    break;
+
+  case 458:
+#line 6583 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s->%s(%s)", (yyvsp[(1) - (6)].id), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype));
+		 (yyval.dtype).type = 0;
+	       ;}
+    break;
+
+  case 459:
+#line 6587 "parser.y"
+    {
+		 (yyval.dtype) = (yyvsp[(1) - (3)].dtype);
+		 Printf((yyval.dtype).val, "->%s", (yyvsp[(3) - (3)].id));
+	       ;}
+    break;
+
+  case 460:
+#line 6591 "parser.y"
+    {
+		 (yyval.dtype) = (yyvsp[(1) - (6)].dtype);
+		 Printf((yyval.dtype).val, "->%s(%s)", (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype));
+	       ;}
+    break;
+
+  case 461:
+#line 6595 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s.%s", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));
+		 (yyval.dtype).type = 0;
+	       ;}
+    break;
+
+  case 462:
+#line 6599 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s.%s(%s)", (yyvsp[(1) - (6)].id), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype));
+		 (yyval.dtype).type = 0;
+	       ;}
+    break;
+
+  case 463:
+#line 6603 "parser.y"
+    {
+		 (yyval.dtype) = (yyvsp[(1) - (3)].dtype);
+		 Printf((yyval.dtype).val, ".%s", (yyvsp[(3) - (3)].id));
+	       ;}
+    break;
+
+  case 464:
+#line 6607 "parser.y"
+    {
+		 (yyval.dtype) = (yyvsp[(1) - (6)].dtype);
+		 Printf((yyval.dtype).val, ".%s(%s)", (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype));
+	       ;}
+    break;
+
+  case 465:
+#line 6614 "parser.y"
+    {
+		    (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+               ;}
+    break;
+
+  case 466:
+#line 6617 "parser.y"
+    {
+		    (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+               ;}
+    break;
+
+  case 467:
+#line 6620 "parser.y"
+    {
+		    (yyval.dtype).val = (yyvsp[(1) - (1)].str);
+                    (yyval.dtype).type = T_STRING;
+               ;}
+    break;
+
+  case 468:
+#line 6624 "parser.y"
+    {
+		  SwigType_push((yyvsp[(3) - (5)].type),(yyvsp[(4) - (5)].decl).type);
+		  (yyval.dtype).val = NewStringf("sizeof(%s)",SwigType_str((yyvsp[(3) - (5)].type),0));
+		  (yyval.dtype).type = T_ULONG;
+               ;}
+    break;
+
+  case 469:
+#line 6629 "parser.y"
+    {
+		  SwigType_push((yyvsp[(4) - (6)].type),(yyvsp[(5) - (6)].decl).type);
+		  (yyval.dtype).val = NewStringf("sizeof...(%s)",SwigType_str((yyvsp[(4) - (6)].type),0));
+		  (yyval.dtype).type = T_ULONG;
+               ;}
+    break;
+
+  case 470:
+#line 6641 "parser.y"
+    {
+		  (yyval.dtype).val = NewStringf("sizeof(%s)", (yyvsp[(3) - (4)].dtype).val);
+		 (yyval.dtype).type = T_ULONG;
+	       ;}
+    break;
+
+  case 471:
+#line 6649 "parser.y"
+    {
+		  (yyval.dtype).val = NewStringf("sizeof(%s)", (yyvsp[(2) - (2)].dtype).val);
+		  (yyval.dtype).type = T_ULONG;
+	       ;}
+    break;
+
+  case 472:
+#line 6653 "parser.y"
+    {
+		    (yyval.dtype).val = (yyvsp[(1) - (1)].str);
+		    (yyval.dtype).rawval = NewStringf("L\"%s\"", (yyval.dtype).val);
+                    (yyval.dtype).type = T_WSTRING;
+	       ;}
+    break;
+
+  case 473:
+#line 6658 "parser.y"
+    {
+		  (yyval.dtype).val = NewString((yyvsp[(1) - (1)].str));
+		  if (Len((yyval.dtype).val)) {
+		    (yyval.dtype).rawval = NewStringf("'%(escape)s'", (yyval.dtype).val);
+		  } else {
+		    (yyval.dtype).rawval = NewString("'\\0'");
+		  }
+		  (yyval.dtype).type = T_CHAR;
+		  (yyval.dtype).bitfield = 0;
+		  (yyval.dtype).throws = 0;
+		  (yyval.dtype).throwf = 0;
+		  (yyval.dtype).nexcept = 0;
+		  (yyval.dtype).final = 0;
+	       ;}
+    break;
+
+  case 474:
+#line 6672 "parser.y"
+    {
+		  (yyval.dtype).val = NewString((yyvsp[(1) - (1)].str));
+		  if (Len((yyval.dtype).val)) {
+		    (yyval.dtype).rawval = NewStringf("L\'%s\'", (yyval.dtype).val);
+		  } else {
+		    (yyval.dtype).rawval = NewString("L'\\0'");
+		  }
+		  (yyval.dtype).type = T_WCHAR;
+		  (yyval.dtype).bitfield = 0;
+		  (yyval.dtype).throws = 0;
+		  (yyval.dtype).throwf = 0;
+		  (yyval.dtype).nexcept = 0;
+		  (yyval.dtype).final = 0;
+	       ;}
+    break;
+
+  case 475:
+#line 6689 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 476:
+#line 6690 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 477:
+#line 6693 "parser.y"
+    {
+		    (yyval.dtype).val = NewStringf("(%s)",(yyvsp[(2) - (3)].dtype).val);
+		    if ((yyvsp[(2) - (3)].dtype).rawval) {
+		      (yyval.dtype).rawval = NewStringf("(%s)",(yyvsp[(2) - (3)].dtype).rawval);
+		    }
+		    (yyval.dtype).type = (yyvsp[(2) - (3)].dtype).type;
+	       ;}
+    break;
+
+  case 478:
+#line 6703 "parser.y"
+    {
+                 (yyval.dtype) = (yyvsp[(4) - (4)].dtype);
+		 if ((yyvsp[(4) - (4)].dtype).type != T_STRING) {
+		   switch ((yyvsp[(2) - (4)].dtype).type) {
+		     case T_FLOAT:
+		     case T_DOUBLE:
+		     case T_LONGDOUBLE:
+		     case T_FLTCPLX:
+		     case T_DBLCPLX:
+		       (yyval.dtype).val = NewStringf("(%s)%s", (yyvsp[(2) - (4)].dtype).val, (yyvsp[(4) - (4)].dtype).val); /* SwigType_str and decimal points don't mix! */
+		       break;
+		     default:
+		       (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (4)].dtype).val,0), (yyvsp[(4) - (4)].dtype).val);
+		       break;
+		   }
+		 }
+		 (yyval.dtype).type = promote((yyvsp[(2) - (4)].dtype).type, (yyvsp[(4) - (4)].dtype).type);
+ 	       ;}
+    break;
+
+  case 479:
+#line 6721 "parser.y"
+    {
+                 (yyval.dtype) = (yyvsp[(5) - (5)].dtype);
+		 if ((yyvsp[(5) - (5)].dtype).type != T_STRING) {
+		   SwigType_push((yyvsp[(2) - (5)].dtype).val,(yyvsp[(3) - (5)].type));
+		   (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val);
+		 }
+ 	       ;}
+    break;
+
+  case 480:
+#line 6728 "parser.y"
+    {
+                 (yyval.dtype) = (yyvsp[(5) - (5)].dtype);
+		 if ((yyvsp[(5) - (5)].dtype).type != T_STRING) {
+		   SwigType_add_reference((yyvsp[(2) - (5)].dtype).val);
+		   (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val);
+		 }
+ 	       ;}
+    break;
+
+  case 481:
+#line 6735 "parser.y"
+    {
+                 (yyval.dtype) = (yyvsp[(5) - (5)].dtype);
+		 if ((yyvsp[(5) - (5)].dtype).type != T_STRING) {
+		   SwigType_add_rvalue_reference((yyvsp[(2) - (5)].dtype).val);
+		   (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val);
+		 }
+ 	       ;}
+    break;
+
+  case 482:
+#line 6742 "parser.y"
+    {
+                 (yyval.dtype) = (yyvsp[(6) - (6)].dtype);
+		 if ((yyvsp[(6) - (6)].dtype).type != T_STRING) {
+		   SwigType_push((yyvsp[(2) - (6)].dtype).val,(yyvsp[(3) - (6)].type));
+		   SwigType_add_reference((yyvsp[(2) - (6)].dtype).val);
+		   (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (6)].dtype).val,0), (yyvsp[(6) - (6)].dtype).val);
+		 }
+ 	       ;}
+    break;
+
+  case 483:
+#line 6750 "parser.y"
+    {
+                 (yyval.dtype) = (yyvsp[(6) - (6)].dtype);
+		 if ((yyvsp[(6) - (6)].dtype).type != T_STRING) {
+		   SwigType_push((yyvsp[(2) - (6)].dtype).val,(yyvsp[(3) - (6)].type));
+		   SwigType_add_rvalue_reference((yyvsp[(2) - (6)].dtype).val);
+		   (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (6)].dtype).val,0), (yyvsp[(6) - (6)].dtype).val);
+		 }
+ 	       ;}
+    break;
+
+  case 484:
+#line 6758 "parser.y"
+    {
+		 (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
+                 (yyval.dtype).val = NewStringf("&%s",(yyvsp[(2) - (2)].dtype).val);
+	       ;}
+    break;
+
+  case 485:
+#line 6762 "parser.y"
+    {
+		 (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
+                 (yyval.dtype).val = NewStringf("*%s",(yyvsp[(2) - (2)].dtype).val);
+	       ;}
+    break;
+
+  case 486:
+#line 6768 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 487:
+#line 6769 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 488:
+#line 6770 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 489:
+#line 6771 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 490:
+#line 6772 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 491:
+#line 6773 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 492:
+#line 6774 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 493:
+#line 6775 "parser.y"
+    { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;}
+    break;
+
+  case 494:
+#line 6778 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s+%s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 495:
+#line 6782 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s-%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 496:
+#line 6786 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s*%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 497:
+#line 6790 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s/%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 498:
+#line 6794 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s%%%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 499:
+#line 6798 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s&%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 500:
+#line 6802 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s|%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 501:
+#line 6806 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s^%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 502:
+#line 6810 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s << %s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 503:
+#line 6814 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s >> %s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type);
+	       ;}
+    break;
+
+  case 504:
+#line 6818 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s&&%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 505:
+#line 6822 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s||%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 506:
+#line 6826 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s==%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 507:
+#line 6830 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s!=%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 508:
+#line 6838 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s > %s", COMPOUND_EXPR_VAL((yyvsp[(2) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(4) - (5)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 509:
+#line 6848 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s < %s", COMPOUND_EXPR_VAL((yyvsp[(2) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(4) - (5)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 510:
+#line 6852 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s >= %s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 511:
+#line 6856 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s <= %s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT;
+	       ;}
+    break;
+
+  case 512:
+#line 6860 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s <=> %s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype)));
+		 /* Really `<=>` returns one of `std::strong_ordering`,
+		  * `std::partial_ordering` or `std::weak_ordering`, but we
+		  * fake it by treating the return value as `int`.  The main
+		  * thing to do with the return value in this context is to
+		  * compare it with 0, for which `int` does the job. */
+		 (yyval.dtype).type = T_INT;
+	       ;}
+    break;
+
+  case 513:
+#line 6869 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("%s?%s:%s", COMPOUND_EXPR_VAL((yyvsp[(1) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(5) - (5)].dtype)));
+		 /* This may not be exactly right, but is probably good enough
+		  * for the purposes of parsing constant expressions. */
+		 (yyval.dtype).type = promote((yyvsp[(3) - (5)].dtype).type, (yyvsp[(5) - (5)].dtype).type);
+	       ;}
+    break;
+
+  case 514:
+#line 6875 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("-%s",(yyvsp[(2) - (2)].dtype).val);
+		 (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type;
+	       ;}
+    break;
+
+  case 515:
+#line 6879 "parser.y"
+    {
+                 (yyval.dtype).val = NewStringf("+%s",(yyvsp[(2) - (2)].dtype).val);
+		 (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type;
+	       ;}
+    break;
+
+  case 516:
+#line 6883 "parser.y"
+    {
+		 (yyval.dtype).val = NewStringf("~%s",(yyvsp[(2) - (2)].dtype).val);
+		 (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type;
+	       ;}
+    break;
+
+  case 517:
+#line 6887 "parser.y"
+    {
+                 (yyval.dtype).val = NewStringf("!%s",COMPOUND_EXPR_VAL((yyvsp[(2) - (2)].dtype)));
+		 (yyval.dtype).type = T_INT;
+	       ;}
+    break;
+
+  case 518:
+#line 6891 "parser.y"
+    {
+		 String *qty;
+                 skip_balanced('(',')');
+		 qty = Swig_symbol_type_qualify((yyvsp[(1) - (2)].type),0);
+		 if (SwigType_istemplate(qty)) {
+		   String *nstr = SwigType_namestr(qty);
+		   Delete(qty);
+		   qty = nstr;
+		 }
+		 (yyval.dtype).val = NewStringf("%s%s",qty,scanner_ccode);
+		 Clear(scanner_ccode);
+		 (yyval.dtype).type = T_INT;
+		 Delete(qty);
+               ;}
+    break;
+
+  case 519:
+#line 6907 "parser.y"
+    {
+	        (yyval.str) = NewString("...");
+	      ;}
+    break;
+
+  case 520:
+#line 6910 "parser.y"
+    {
+	        (yyval.str) = 0;
+	      ;}
+    break;
+
+  case 521:
+#line 6915 "parser.y"
+    {
+		 (yyval.bases) = (yyvsp[(1) - (1)].bases);
+               ;}
+    break;
+
+  case 522:
+#line 6920 "parser.y"
+    { inherit_list = 1; ;}
+    break;
+
+  case 523:
+#line 6920 "parser.y"
+    { (yyval.bases) = (yyvsp[(3) - (3)].bases); inherit_list = 0; ;}
+    break;
+
+  case 524:
+#line 6921 "parser.y"
+    { (yyval.bases) = 0; ;}
+    break;
+
+  case 525:
+#line 6924 "parser.y"
+    {
+		   Hash *list = NewHash();
+		   Node *base = (yyvsp[(1) - (1)].node);
+		   Node *name = Getattr(base,"name");
+		   List *lpublic = NewList();
+		   List *lprotected = NewList();
+		   List *lprivate = NewList();
+		   Setattr(list,"public",lpublic);
+		   Setattr(list,"protected",lprotected);
+		   Setattr(list,"private",lprivate);
+		   Delete(lpublic);
+		   Delete(lprotected);
+		   Delete(lprivate);
+		   Append(Getattr(list,Getattr(base,"access")),name);
+	           (yyval.bases) = list;
+               ;}
+    break;
+
+  case 526:
+#line 6941 "parser.y"
+    {
+		   Hash *list = (yyvsp[(1) - (3)].bases);
+		   Node *base = (yyvsp[(3) - (3)].node);
+		   Node *name = Getattr(base,"name");
+		   Append(Getattr(list,Getattr(base,"access")),name);
+                   (yyval.bases) = list;
+               ;}
+    break;
+
+  case 527:
+#line 6950 "parser.y"
+    {
+		 (yyval.intvalue) = cparse_line;
+	       ;}
+    break;
+
+  case 528:
+#line 6952 "parser.y"
+    {
+		 (yyval.node) = NewHash();
+		 Setfile((yyval.node),cparse_file);
+		 Setline((yyval.node),(yyvsp[(2) - (4)].intvalue));
+		 Setattr((yyval.node),"name",(yyvsp[(3) - (4)].str));
+		 Setfile((yyvsp[(3) - (4)].str),cparse_file);
+		 Setline((yyvsp[(3) - (4)].str),(yyvsp[(2) - (4)].intvalue));
+                 if (last_cpptype && (Strcmp(last_cpptype,"struct") != 0)) {
+		   Setattr((yyval.node),"access","private");
+		   Swig_warning(WARN_PARSE_NO_ACCESS, Getfile((yyval.node)), Getline((yyval.node)), "No access specifier given for base class '%s' (ignored).\n", SwigType_namestr((yyvsp[(3) - (4)].str)));
+                 } else {
+		   Setattr((yyval.node),"access","public");
+		 }
+		 if ((yyvsp[(4) - (4)].str))
+		   SetFlag((yyval.node), "variadic");
+               ;}
+    break;
+
+  case 529:
+#line 6968 "parser.y"
+    {
+		 (yyval.intvalue) = cparse_line;
+	       ;}
+    break;
+
+  case 530:
+#line 6970 "parser.y"
+    {
+		 (yyval.node) = NewHash();
+		 Setfile((yyval.node),cparse_file);
+		 Setline((yyval.node),(yyvsp[(3) - (6)].intvalue));
+		 Setattr((yyval.node),"name",(yyvsp[(5) - (6)].str));
+		 Setfile((yyvsp[(5) - (6)].str),cparse_file);
+		 Setline((yyvsp[(5) - (6)].str),(yyvsp[(3) - (6)].intvalue));
+		 Setattr((yyval.node),"access",(yyvsp[(2) - (6)].id));
+	         if (Strcmp((yyvsp[(2) - (6)].id),"public") != 0) {
+		   Swig_warning(WARN_PARSE_PRIVATE_INHERIT, Getfile((yyval.node)), Getline((yyval.node)), "%s inheritance from base '%s' (ignored).\n", (yyvsp[(2) - (6)].id), SwigType_namestr((yyvsp[(5) - (6)].str)));
+		 }
+		 if ((yyvsp[(6) - (6)].str))
+		   SetFlag((yyval.node), "variadic");
+               ;}
+    break;
+
+  case 531:
+#line 6986 "parser.y"
+    { (yyval.id) = (char*)"public"; ;}
+    break;
+
+  case 532:
+#line 6987 "parser.y"
+    { (yyval.id) = (char*)"private"; ;}
+    break;
+
+  case 533:
+#line 6988 "parser.y"
+    { (yyval.id) = (char*)"protected"; ;}
+    break;
+
+  case 534:
+#line 6991 "parser.y"
+    { 
+                   (yyval.id) = (char*)"class"; 
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 535:
+#line 6995 "parser.y"
+    { 
+                   (yyval.id) = (char *)"typename"; 
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 536:
+#line 6999 "parser.y"
+    {
+                   (yyval.id) = (char *)"class..."; 
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 537:
+#line 7003 "parser.y"
+    {
+                   (yyval.id) = (char *)"typename..."; 
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 538:
+#line 7009 "parser.y"
+    {
+                 (yyval.id) = (yyvsp[(1) - (1)].id);
+               ;}
+    break;
+
+  case 539:
+#line 7012 "parser.y"
+    { 
+                   (yyval.id) = (char*)"struct"; 
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 540:
+#line 7016 "parser.y"
+    {
+                   (yyval.id) = (char*)"union"; 
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 541:
+#line 7022 "parser.y"
+    {
+                   (yyval.id) = (char*)"class";
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 542:
+#line 7026 "parser.y"
+    {
+                   (yyval.id) = (char*)"struct";
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 543:
+#line 7030 "parser.y"
+    {
+                   (yyval.id) = (char*)"union";
+		   if (!inherit_list) last_cpptype = (yyval.id);
+               ;}
+    break;
+
+  case 544:
+#line 7036 "parser.y"
+    {
+		   (yyval.id) = (yyvsp[(1) - (1)].id);
+               ;}
+    break;
+
+  case 545:
+#line 7039 "parser.y"
+    {
+		   (yyval.id) = 0;
+               ;}
+    break;
+
+  case 548:
+#line 7048 "parser.y"
+    {
+                   (yyval.str) = 0;
+	       ;}
+    break;
+
+  case 549:
+#line 7051 "parser.y"
+    {
+                   (yyval.str) = NewString("1");
+	       ;}
+    break;
+
+  case 550:
+#line 7054 "parser.y"
+    {
+                   (yyval.str) = NewString("1");
+	       ;}
+    break;
+
+  case 551:
+#line 7057 "parser.y"
+    {
+                   (yyval.str) = NewString("1");
+	       ;}
+    break;
+
+  case 552:
+#line 7062 "parser.y"
+    {
+                   (yyval.str) = (yyvsp[(1) - (1)].str);
+               ;}
+    break;
+
+  case 553:
+#line 7065 "parser.y"
+    {
+                   (yyval.str) = 0;
+               ;}
+    break;
+
+  case 554:
+#line 7070 "parser.y"
+    {
+                   (yyval.str) = NewString("1");
+               ;}
+    break;
+
+  case 555:
+#line 7073 "parser.y"
+    {
+                   (yyval.str) = 0;
+               ;}
+    break;
+
+  case 556:
+#line 7078 "parser.y"
+    {
+                    (yyval.dtype).throws = (yyvsp[(3) - (4)].pl);
+                    (yyval.dtype).throwf = NewString("1");
+                    (yyval.dtype).nexcept = 0;
+                    (yyval.dtype).final = 0;
+	       ;}
+    break;
+
+  case 557:
+#line 7084 "parser.y"
+    {
+                    (yyval.dtype).throws = 0;
+                    (yyval.dtype).throwf = 0;
+                    (yyval.dtype).nexcept = NewString("true");
+                    (yyval.dtype).final = 0;
+	       ;}
+    break;
+
+  case 558:
+#line 7090 "parser.y"
+    {
+                    (yyval.dtype).throws = 0;
+                    (yyval.dtype).throwf = 0;
+                    (yyval.dtype).nexcept = 0;
+                    (yyval.dtype).final = (yyvsp[(1) - (1)].str);
+	       ;}
+    break;
+
+  case 559:
+#line 7096 "parser.y"
+    {
+                    (yyval.dtype).throws = (yyvsp[(3) - (5)].pl);
+                    (yyval.dtype).throwf = NewString("1");
+                    (yyval.dtype).nexcept = 0;
+                    (yyval.dtype).final = (yyvsp[(5) - (5)].str);
+	       ;}
+    break;
+
+  case 560:
+#line 7102 "parser.y"
+    {
+                    (yyval.dtype).throws = 0;
+                    (yyval.dtype).throwf = 0;
+                    (yyval.dtype).nexcept = NewString("true");
+                    (yyval.dtype).final = (yyvsp[(2) - (2)].str);
+	       ;}
+    break;
+
+  case 561:
+#line 7108 "parser.y"
+    {
+                    (yyval.dtype).throws = 0;
+                    (yyval.dtype).throwf = 0;
+                    (yyval.dtype).nexcept = (yyvsp[(3) - (4)].dtype).val;
+                    (yyval.dtype).final = 0;
+	       ;}
+    break;
+
+  case 562:
+#line 7116 "parser.y"
+    {
+                    (yyval.dtype).throws = 0;
+                    (yyval.dtype).throwf = 0;
+                    (yyval.dtype).nexcept = 0;
+                    (yyval.dtype).final = 0;
+                    (yyval.dtype).qualifier = (yyvsp[(1) - (1)].dtype).qualifier;
+                    (yyval.dtype).refqualifier = (yyvsp[(1) - (1)].dtype).refqualifier;
+               ;}
+    break;
+
+  case 563:
+#line 7124 "parser.y"
+    {
+		    (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+                    (yyval.dtype).qualifier = 0;
+                    (yyval.dtype).refqualifier = 0;
+               ;}
+    break;
+
+  case 564:
+#line 7129 "parser.y"
+    {
+		    (yyval.dtype) = (yyvsp[(2) - (2)].dtype);
+                    (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier;
+                    (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier;
+               ;}
+    break;
+
+  case 565:
+#line 7136 "parser.y"
+    {
+                    (yyval.dtype) = (yyvsp[(1) - (1)].dtype);
+               ;}
+    break;
+
+  case 566:
+#line 7139 "parser.y"
+    { 
+                    (yyval.dtype).throws = 0;
+                    (yyval.dtype).throwf = 0;
+                    (yyval.dtype).nexcept = 0;
+                    (yyval.dtype).final = 0;
+                    (yyval.dtype).qualifier = 0;
+                    (yyval.dtype).refqualifier = 0;
+               ;}
+    break;
+
+  case 567:
+#line 7149 "parser.y"
+    { 
+                    Clear(scanner_ccode); 
+                    (yyval.decl).have_parms = 0; 
+                    (yyval.decl).defarg = 0; 
+		    (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws;
+		    (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf;
+		    (yyval.decl).nexcept = (yyvsp[(1) - (3)].dtype).nexcept;
+		    (yyval.decl).final = (yyvsp[(1) - (3)].dtype).final;
+                    if ((yyvsp[(1) - (3)].dtype).qualifier)
+                      Swig_error(cparse_file, cparse_line, "Constructor cannot have a qualifier.\n");
+               ;}
+    break;
+
+  case 568:
+#line 7160 "parser.y"
+    { 
+                    skip_balanced('{','}'); 
+                    (yyval.decl).have_parms = 0; 
+                    (yyval.decl).defarg = 0; 
+                    (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws;
+                    (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf;
+                    (yyval.decl).nexcept = (yyvsp[(1) - (3)].dtype).nexcept;
+                    (yyval.decl).final = (yyvsp[(1) - (3)].dtype).final;
+                    if ((yyvsp[(1) - (3)].dtype).qualifier)
+                      Swig_error(cparse_file, cparse_line, "Constructor cannot have a qualifier.\n");
+               ;}
+    break;
+
+  case 569:
+#line 7171 "parser.y"
+    { 
+                    Clear(scanner_ccode); 
+                    (yyval.decl).parms = (yyvsp[(2) - (4)].pl); 
+                    (yyval.decl).have_parms = 1; 
+                    (yyval.decl).defarg = 0; 
+		    (yyval.decl).throws = 0;
+		    (yyval.decl).throwf = 0;
+		    (yyval.decl).nexcept = 0;
+		    (yyval.decl).final = 0;
+               ;}
+    break;
+
+  case 570:
+#line 7181 "parser.y"
+    {
+                    skip_balanced('{','}'); 
+                    (yyval.decl).parms = (yyvsp[(2) - (4)].pl); 
+                    (yyval.decl).have_parms = 1; 
+                    (yyval.decl).defarg = 0; 
+                    (yyval.decl).throws = 0;
+                    (yyval.decl).throwf = 0;
+                    (yyval.decl).nexcept = 0;
+                    (yyval.decl).final = 0;
+               ;}
+    break;
+
+  case 571:
+#line 7191 "parser.y"
+    { 
+                    (yyval.decl).have_parms = 0; 
+                    (yyval.decl).defarg = (yyvsp[(2) - (3)].dtype).val; 
+                    (yyval.decl).throws = 0;
+                    (yyval.decl).throwf = 0;
+                    (yyval.decl).nexcept = 0;
+                    (yyval.decl).final = 0;
+               ;}
+    break;
+
+  case 572:
+#line 7199 "parser.y"
+    {
+                    (yyval.decl).have_parms = 0;
+                    (yyval.decl).defarg = (yyvsp[(3) - (4)].dtype).val;
+                    (yyval.decl).throws = (yyvsp[(1) - (4)].dtype).throws;
+                    (yyval.decl).throwf = (yyvsp[(1) - (4)].dtype).throwf;
+                    (yyval.decl).nexcept = (yyvsp[(1) - (4)].dtype).nexcept;
+                    (yyval.decl).final = (yyvsp[(1) - (4)].dtype).final;
+                    if ((yyvsp[(1) - (4)].dtype).qualifier)
+                      Swig_error(cparse_file, cparse_line, "Constructor cannot have a qualifier.\n");
+               ;}
+    break;
+
+  case 579:
+#line 7221 "parser.y"
+    {
+		  skip_balanced('(',')');
+		  Clear(scanner_ccode);
+		;}
+    break;
+
+  case 580:
+#line 7233 "parser.y"
+    {
+		  skip_balanced('{','}');
+		  Clear(scanner_ccode);
+		;}
+    break;
+
+  case 581:
+#line 7239 "parser.y"
+    {
+                     String *s = NewStringEmpty();
+                     SwigType_add_template(s,(yyvsp[(2) - (3)].p));
+                     (yyval.id) = Char(s);
+		     scanner_last_id(1);
+                ;}
+    break;
+
+  case 582:
+#line 7248 "parser.y"
+    { (yyval.id) = (yyvsp[(1) - (1)].id); ;}
+    break;
+
+  case 583:
+#line 7249 "parser.y"
+    { (yyval.id) = Swig_copy_string("override"); ;}
+    break;
+
+  case 584:
+#line 7250 "parser.y"
+    { (yyval.id) = Swig_copy_string("final"); ;}
+    break;
+
+  case 585:
+#line 7253 "parser.y"
+    { (yyval.id) = (yyvsp[(1) - (1)].id); ;}
+    break;
+
+  case 586:
+#line 7254 "parser.y"
+    { (yyval.id) = Char((yyvsp[(1) - (1)].dtype).val); ;}
+    break;
+
+  case 587:
+#line 7255 "parser.y"
+    { (yyval.id) = Char((yyvsp[(1) - (1)].str)); ;}
+    break;
+
+  case 588:
+#line 7258 "parser.y"
+    { (yyval.id) = (yyvsp[(1) - (1)].id); ;}
+    break;
+
+  case 589:
+#line 7259 "parser.y"
+    { (yyval.id) = 0; ;}
+    break;
+
+  case 590:
+#line 7262 "parser.y"
+    { 
+                  (yyval.str) = 0;
+		  if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str));
+      	          Delete((yyvsp[(2) - (2)].str));
+               ;}
+    break;
+
+  case 591:
+#line 7267 "parser.y"
+    {
+		 (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str));
+                 Delete((yyvsp[(4) - (4)].str));
+               ;}
+    break;
+
+  case 592:
+#line 7271 "parser.y"
+    {
+		 (yyval.str) = NewString((yyvsp[(1) - (1)].str));
+   	       ;}
+    break;
+
+  case 593:
+#line 7274 "parser.y"
+    {
+		 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str));
+               ;}
+    break;
+
+  case 594:
+#line 7277 "parser.y"
+    {
+                 (yyval.str) = NewStringf("%s", (yyvsp[(1) - (1)].str));
+	       ;}
+    break;
+
+  case 595:
+#line 7280 "parser.y"
+    {
+                 (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].id));
+	       ;}
+    break;
+
+  case 596:
+#line 7283 "parser.y"
+    {
+                 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str));
+               ;}
+    break;
+
+  case 597:
+#line 7288 "parser.y"
+    {
+                   (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str));
+		   Delete((yyvsp[(3) - (3)].str));
+               ;}
+    break;
+
+  case 598:
+#line 7292 "parser.y"
+    {
+                   (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str));
+               ;}
+    break;
+
+  case 599:
+#line 7295 "parser.y"
+    {
+                   (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str));
+               ;}
+    break;
+
+  case 600:
+#line 7302 "parser.y"
+    {
+		 (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].str));
+               ;}
+    break;
+
+  case 601:
+#line 7308 "parser.y"
+    {
+		(yyval.str) = NewStringf("%s", (yyvsp[(1) - (1)].id));
+	      ;}
+    break;
+
+  case 602:
+#line 7311 "parser.y"
+    {
+		(yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
+	      ;}
+    break;
+
+  case 603:
+#line 7316 "parser.y"
+    {
+		(yyval.str) = (yyvsp[(1) - (1)].str);
+	      ;}
+    break;
+
+  case 604:
+#line 7319 "parser.y"
+    {
+		(yyval.str) = NewStringf("%s%s", (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id));
+	      ;}
+    break;
+
+  case 605:
+#line 7325 "parser.y"
+    {
+                  (yyval.str) = 0;
+		  if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].id),(yyvsp[(2) - (2)].str));
+      	          Delete((yyvsp[(2) - (2)].str));
+               ;}
+    break;
+
+  case 606:
+#line 7330 "parser.y"
+    {
+		 (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].id),(yyvsp[(4) - (4)].str));
+                 Delete((yyvsp[(4) - (4)].str));
+               ;}
+    break;
+
+  case 607:
+#line 7334 "parser.y"
+    {
+		 (yyval.str) = NewString((yyvsp[(1) - (1)].id));
+   	       ;}
+    break;
+
+  case 608:
+#line 7337 "parser.y"
+    {
+		 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].id));
+               ;}
+    break;
+
+  case 609:
+#line 7340 "parser.y"
+    {
+                 (yyval.str) = NewString((yyvsp[(1) - (1)].str));
+	       ;}
+    break;
+
+  case 610:
+#line 7343 "parser.y"
+    {
+                 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str));
+               ;}
+    break;
+
+  case 611:
+#line 7348 "parser.y"
+    {
+                   (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].str));
+		   Delete((yyvsp[(3) - (3)].str));
+               ;}
+    break;
+
+  case 612:
+#line 7352 "parser.y"
+    {
+                   (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].id));
+               ;}
+    break;
+
+  case 613:
+#line 7355 "parser.y"
+    {
+                   (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str));
+               ;}
+    break;
+
+  case 614:
+#line 7358 "parser.y"
+    {
+		 (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].id));
+               ;}
+    break;
+
+  case 615:
+#line 7364 "parser.y"
+    { 
+                   (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].id));
+               ;}
+    break;
+
+  case 616:
+#line 7367 "parser.y"
+    { (yyval.str) = NewString((yyvsp[(1) - (1)].id));;}
+    break;
+
+  case 617:
+#line 7370 "parser.y"
+    {
+                   (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].id));
+               ;}
+    break;
+
+  case 618:
+#line 7378 "parser.y"
+    { (yyval.str) = NewString((yyvsp[(1) - (1)].id));;}
+    break;
+
+  case 619:
+#line 7381 "parser.y"
+    {
+		 (yyval.str) = (yyvsp[(1) - (1)].str);
+               ;}
+    break;
+
+  case 620:
+#line 7384 "parser.y"
+    {
+                  skip_balanced('{','}');
+		  (yyval.str) = NewString(scanner_ccode);
+               ;}
+    break;
+
+  case 621:
+#line 7388 "parser.y"
+    {
+		 (yyval.str) = (yyvsp[(1) - (1)].str);
+              ;}
+    break;
+
+  case 622:
+#line 7393 "parser.y"
+    {
+                  Hash *n;
+                  (yyval.node) = NewHash();
+                  n = (yyvsp[(2) - (3)].node);
+                  while(n) {
+                     String *name, *value;
+                     name = Getattr(n,"name");
+                     value = Getattr(n,"value");
+		     if (!value) value = (String *) "1";
+                     Setattr((yyval.node),name, value);
+		     n = nextSibling(n);
+		  }
+               ;}
+    break;
+
+  case 623:
+#line 7406 "parser.y"
+    { (yyval.node) = 0; ;}
+    break;
+
+  case 624:
+#line 7410 "parser.y"
+    {
+		 (yyval.node) = NewHash();
+		 Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
+		 Setattr((yyval.node),"value",(yyvsp[(3) - (3)].str));
+               ;}
+    break;
+
+  case 625:
+#line 7415 "parser.y"
+    {
+		 (yyval.node) = NewHash();
+		 Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id));
+		 Setattr((yyval.node),"value",(yyvsp[(3) - (5)].str));
+		 set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+               ;}
+    break;
+
+  case 626:
+#line 7421 "parser.y"
+    {
+                 (yyval.node) = NewHash();
+                 Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id));
+	       ;}
+    break;
+
+  case 627:
+#line 7425 "parser.y"
+    {
+                 (yyval.node) = NewHash();
+                 Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
+                 set_nextSibling((yyval.node),(yyvsp[(3) - (3)].node));
+               ;}
+    break;
+
+  case 628:
+#line 7430 "parser.y"
+    {
+                 (yyval.node) = (yyvsp[(3) - (3)].node);
+		 Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id));
+               ;}
+    break;
+
+  case 629:
+#line 7434 "parser.y"
+    {
+                 (yyval.node) = (yyvsp[(3) - (5)].node);
+		 Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id));
+		 set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node));
+               ;}
+    break;
+
+  case 630:
+#line 7441 "parser.y"
+    {
+		 (yyval.str) = (yyvsp[(1) - (1)].str);
+               ;}
+    break;
+
+  case 631:
+#line 7444 "parser.y"
+    {
+                 (yyval.str) = Char((yyvsp[(1) - (1)].dtype).val);
+               ;}
+    break;
+
+
+/* Line 1267 of yacc.c.  */
+#line 12858 "parser.c"
+      default: break;
+    }
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (YY_("syntax error"));
+#else
+      {
+	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+	  {
+	    YYSIZE_T yyalloc = 2 * yysize;
+	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
+	    if (yymsg != yymsgbuf)
+	      YYSTACK_FREE (yymsg);
+	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+	    if (yymsg)
+	      yymsg_alloc = yyalloc;
+	    else
+	      {
+		yymsg = yymsgbuf;
+		yymsg_alloc = sizeof yymsgbuf;
+	      }
+	  }
+
+	if (0 < yysize && yysize <= yymsg_alloc)
+	  {
+	    (void) yysyntax_error (yymsg, yystate, yychar);
+	    yyerror (yymsg);
+	  }
+	else
+	  {
+	    yyerror (YY_("syntax error"));
+	    if (yysize != 0)
+	      goto yyexhaustedlab;
+	  }
+      }
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse look-ahead token after an
+	 error, discard it.  */
+
+      if (yychar <= YYEOF)
+	{
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
+	}
+      else
+	{
+	  yydestruct ("Error: discarding",
+		      yytoken, &yylval);
+	  yychar = YYEMPTY;
+	}
+    }
+
+  /* Else will try to reuse look-ahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (yyn != YYPACT_NINF)
+	{
+	  yyn += YYTERROR;
+	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+	    {
+	      yyn = yytable[yyn];
+	      if (0 < yyn)
+		break;
+	    }
+	}
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+	YYABORT;
+
+
+      yydestruct ("Error: popping",
+		  yystos[yystate], yyvsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  *++yyvsp = yylval;
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#ifndef yyoverflow
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval);
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);
+}
+
+
+#line 7451 "parser.y"
+
+
+SwigType *Swig_cparse_type(String *s) {
+   String *ns;
+   ns = NewStringf("%s;",s);
+   Seek(ns,0,SEEK_SET);
+   scanner_file(ns);
+   top = 0;
+   scanner_next_token(PARSETYPE);
+   yyparse();
+   /*   Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */
+   return top;
+}
+
+
+Parm *Swig_cparse_parm(String *s) {
+   String *ns;
+   ns = NewStringf("%s;",s);
+   Seek(ns,0,SEEK_SET);
+   scanner_file(ns);
+   top = 0;
+   scanner_next_token(PARSEPARM);
+   yyparse();
+   /*   Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */
+   Delete(ns);
+   return top;
+}
+
+
+ParmList *Swig_cparse_parms(String *s, Node *file_line_node) {
+   String *ns;
+   char *cs = Char(s);
+   if (cs && cs[0] != '(') {
+     ns = NewStringf("(%s);",s);
+   } else {
+     ns = NewStringf("%s;",s);
+   }
+   Setfile(ns, Getfile(file_line_node));
+   Setline(ns, Getline(file_line_node));
+   Seek(ns,0,SEEK_SET);
+   scanner_file(ns);
+   top = 0;
+   scanner_next_token(PARSEPARMS);
+   yyparse();
+   /*   Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */
+   return top;
+}
+
+
