VTK  9.3.20240328
vtkVRMLImporter_Yacc.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-FileCopyrightText: Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
3 // SPDX-FileCopyrightText: Copyright (C) 1996 Silicon Graphics, Inc.
4 // SPDX-License-Identifier: BSD-3-Clause AND GPL-3.0 WITH Bison-exception-2.2
10 #ifndef vtkVRMLImporter_Yacc_h
11 #define vtkVRMLImporter_Yacc_h
12 
13 
14 #include "vtkFloatArray.h"
15 #include "vtkIdTypeArray.h"
16 #include "vtkPoints.h"
17 #include "vtkVRML.h"
18 #include "vtkVRMLImporter.h"
19 
20 #include <cassert>
21 #include <cstdio>
22 #include <cstring>
23 
24 //
25 // The VrmlNodeType class is responsible for storing information about node
26 // or prototype types.
27 //
28 
29 // used to hold the VRML DEF names and assoc vtkObjects
30 VTK_ABI_NAMESPACE_BEGIN
32 public:
33  vtkVRMLUseStruct( char *n, vtkObject *o) { defName = n; defObject = o; }
34  char *defName;
36 
37  void* operator new(size_t n)
38  {
39  return vtkVRMLAllocator::AllocateMemory(n);
40  }
41 
42  void operator delete(void *vtkNotUsed(ptr)) {}
43 };
44 
45 
46 
47 class VrmlNodeType {
48 public:
49  // Constructor. Takes name of new type (e.g. "Transform" or "Box")
50  // Copies the string given as name.
51  VrmlNodeType(const char *nm);
52 
53  // Destructor exists mainly to deallocate storage for name
54  ~VrmlNodeType();
55 
56  // Routines for adding/getting eventIns/Outs/fields
57  void addEventIn(const char *name, int type);
58  void addEventOut(const char *name, int type);
59  void addField(const char *name, int type);
60  void addExposedField(const char *name, int type);
61 
62  int hasEventIn(const char *name) const;
63  int hasEventOut(const char *name) const;
64  int hasField(const char *name) const;
65  int hasExposedField(const char *name) const;
66 
67  const char *getName() const { return name; }
68 
69  void* operator new(size_t n)
70  {
71  return vtkVRMLAllocator::AllocateMemory(n);
72  }
73 
74  void operator delete(void *vtkNotUsed(ptr)) {}
75 
76  struct NameTypeRec {
77  char *name;
78  int type;
79 
80  void* operator new(size_t n)
81  {
82  return vtkVRMLAllocator::AllocateMemory(n);
83  }
84 
85  void operator delete(void *vtkNotUsed(ptr)) {}
86 
87  };
88 
89  // This is used to keep track of which field in which type of node is being
90  // parsed. Field are nested (nodes are contained inside MFNode/SFNode fields)
91  // so a stack of these is needed:
92  struct FieldRec
93  {
95  const char *fieldName;
96  };
97 
98 private:
99  void add(vtkVRMLVectorType<NameTypeRec*> &,const char *,int);
100  int has(const vtkVRMLVectorType<NameTypeRec*> &,const char *) const;
101 
102  char *name;
103 
104  vtkVRMLVectorType<NameTypeRec*> eventIns;
105  vtkVRMLVectorType<NameTypeRec*> eventOuts;
106  vtkVRMLVectorType<NameTypeRec*> fields;
107 };
108 
110 {
111 public:
112  vtkVRMLYaccData();
114  typedef unsigned char YY_CHAR;
115  typedef int yy_state_type;
116 private:
117  vtkVRMLYaccData(const vtkVRMLYaccData&) = delete;
118  vtkVRMLYaccData& operator=(const vtkVRMLYaccData&) = delete;
119 public:
120  // Parser variables and functions:
121  // Currently-being-define proto. Prototypes may be nested, so a stack
122  // is needed:
123  vtkVRMLVectorType<VrmlNodeType*> *CurrentProtoStack;// = nullptr;
124 
125  // Some helper routines defined below:
126  void beginProto(const char *);
127  void endProto();
128 
129  int addField(const char *type, const char *name);
130  int addEventIn(const char *type, const char *name);
131  int addEventOut(const char *type, const char *name);
132  int addExposedField(const char *type, const char *name);
133  int add(void (VrmlNodeType::*)(const char *, int), const char *,
134  const char *);
135  int fieldType(const char *type);
136  void inScript();
137  void expect(int type);
138 
139  void yyerror(const char *);
140  int yylex(vtkVRMLImporter* self);
141 
142  class FakeAlloca;
143 
144  typedef union {
145  char *string;
146 
147  /* Other types that will be needed by a true VRML implementation
148  * (but are not defined by this parser due to the complexity):
149  * Node *node;
150  * list<Node *> *nodeList;
151  */
152 
153  float sffloat;
157  int sfint;
158  float vec4f[4];
159  } YYSTYPE;
160 
161 
162  typedef
163  struct yyltype
164  {
170  char *text;
171  }
173 
174 
175  int yychar; /* the lookahead symbol */
176  YYSTYPE yylval; /* the semantic value of the */
177  /* lookahead symbol */
178  yyltype yylloc; /* location data for the lookahead */
179  /* symbol */
180  int yynerrs; /* number of parse errors so far */
181  // Lexer variables and functions:
182  int yyleng;
183  FILE *yyin, *yyout;
184  int yywrap();
185 
187  {
189 
190  char *yy_ch_buf; /* input buffer */
191  char *yy_buf_pos; /* current position in input buffer */
192 
193  /* Size of input buffer in bytes, not including room for EOB
194  * characters.
195  */
197 
198  /* Number of characters read into yy_ch_buf, not including EOB
199  * characters.
200  */
202 
203  /* Whether this is an "interactive" input source; if so, and
204  * if we're using stdio for input, then we want to use getc()
205  * instead of fread(), to make sure we stop fetching input after
206  * each newline.
207  */
209 
210  /* Whether to try to fill the input buffer when we reach the
211  * end of it.
212  */
214 
218  /* When an EOF's been seen but there's still some text to process
219  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
220  * shouldn't try reading from the input source any more. We might
221  * still have a bunch of tokens to match, though, because of
222  * possible backing-up.
223  *
224  * When we actually see the EOF, we change the status to "new"
225  * (via yyrestart()), so that the user can continue scanning by
226  * just pointing yyin at a new input file.
227  */
229  };
231 
232  };
234 
236 
237  /* yy_hold_char holds the character lost when yytext is formed. */
239 
240  int yy_n_chars; /* number of characters read into yy_ch_buf */
241 
242 
243  /* Points to current character in buffer. */
244  char *yy_c_buf_p;// = (char *) 0;
245  int yy_init;// = 1; /* whether we need to initialize */
246  int yy_start;// = 0; /* start state number */
247 
248  /* Flag which is used to allow yywrap()'s to do buffer switches
249  * instead of setting up a fresh yyin. A bit of a hack ...
250  */
252 
253  void yyrestart ( FILE *input_file );
254  void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
255  void yy_load_buffer_state ();
256  YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
258  void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
259 
260  void *yy_flex_alloc ( unsigned int );
261  void *yy_flex_realloc ( void *, unsigned int );
262  void yy_flex_free ( void * );
263 
264  char *yytext;
265 
267  yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
268  int yy_get_next_buffer ();
269  void yy_fatal_error ( const char msg[] );
270 
273 
274  int yy_flex_debug;// = 1;
275 
276  // used to reset the lexer input after initialization of VRML nodes
277  void (*theyyInput)(char *, int &, int, vtkVRMLYaccData*);
278 
279 
280  /* Current line number */
281  int currentLineNumber;// = 1;
283 
284  /* The YACC parser sets this to a token to direct the lexer */
285  /* in cases where just syntax isn't enough: */
286  int expectToken;// = 0;
287 
288  /* True when parsing a multiple-valued field: */
289  int parsing_mf;// = 0;
290 
291  /* These are used when parsing SFImage fields: */
292  int sfImageIntsParsed;// = 0;
294 
295  int yydebug; /* nonzero means print parse trace */
296  int yyparse(vtkVRMLImporter* self);
297 
298  static void memyyInput(char *buf, int &result, int max_size, vtkVRMLYaccData* self);
299  static void defyyInput(char *buf, int &result, int max_size, vtkVRMLYaccData* self);
300 
301  int memyyInput_i;// = 0;
302  int memyyInput_j;// = 0;
303 
304  // Used during the parsing
305  int creatingDEF;// = 0;
306  char *curDEFName;
307 
308  // Node types are stored in this data structure:
309  vtkVRMLVectorType<VrmlNodeType*>* typeList;
310  vtkVRMLVectorType<vtkVRMLUseStruct *>* useList;
311  vtkVRMLVectorType<VrmlNodeType::FieldRec*>* currentField;
312 
313  // Moved from VrmlNodeType when getting rid of static data
314  //
315  // Namespace management functions. PROTO definitions add node types
316  // to the namespace. PROTO implementations are a separate node
317  // namespace, and require that any nested PROTOs NOT be available
318  // outside the PROTO implementation.
319  // addToNameSpace will print an error to stderr if the given type
320  // is already defined.
322  void pushNameSpace();
323  void popNameSpace();
324 
325  // Find a node type, given its name. Returns nullptr if type is not defined.
326  const VrmlNodeType *find(const char *nm);
327 
328 };
329 
330 //------------------------------------------------------------------------------------
331 //
332 // Implementation of the above begins here
333 //
334 
335 inline VrmlNodeType::VrmlNodeType(const char *nm)
336 {
337  assert(nm != nullptr);
338  name = static_cast<char*>(
339  vtkVRMLAllocator::AllocateMemory((strlen(nm)+1)*sizeof(char)));
340  strcpy(name, nm);
341 }
342 
344 {
345  // Free strings duplicated when fields/eventIns/eventOuts added:
346 
347  int i;
348  for (i = 0;i < eventIns.Count(); i++)
349  {
350  NameTypeRec *r = eventIns[i];
351 // free(r->name);
352  delete r;
353  }
354  for (i = 0;i < eventOuts.Count(); i++)
355  {
356  NameTypeRec *r = eventOuts[i];
357 // free(r->name);
358  delete r;
359  }
360  for (i = 0;i < fields.Count(); i++)
361  {
362  NameTypeRec *r = fields[i];
363 // free(r->name);
364  delete r;
365  }
366 }
367 inline void
368 VrmlNodeType::addEventIn(const char *nodeName, int type)
369 {
370  add(eventIns, nodeName, type);
371 }
372 inline void
373 VrmlNodeType::addEventOut(const char *nodeName, int type)
374 {
375  add(eventOuts, nodeName, type);
376 }
377 inline void
378 VrmlNodeType::addField(const char *nodeName, int type)
379 {
380  add(fields, nodeName, type);
381 }
382 inline void
383 VrmlNodeType::addExposedField(const char *nodeName, int type)
384 {
385  size_t length = 20 + strlen(nodeName);
386  std::vector<char> tmp(length);
387  add(fields, nodeName, type);
388  snprintf(tmp.data(), length, "set_%s", nodeName);
389  add(eventIns, tmp.data(), type);
390  snprintf(tmp.data(), length, "%s_changed", nodeName);
391  add(eventOuts, tmp.data(), type);
392 }
393 
394 inline void
395 VrmlNodeType::add(vtkVRMLVectorType<NameTypeRec*> &recs, const char *nodeName, int type)
396 {
397  NameTypeRec *r = new NameTypeRec;
398  r->name = vtkVRMLAllocator::StrDup(nodeName); //strdup(nodeName);
399  r->type = type;
400  recs += r;
401 }
402 
403 inline int
404 VrmlNodeType::hasEventIn(const char *nodeName) const
405 {
406  return has(eventIns, nodeName);
407 }
408 inline int
409 VrmlNodeType::hasEventOut(const char *nodeName) const
410 {
411  return has(eventOuts, nodeName);
412 }
413 inline int
414 VrmlNodeType::hasField(const char *nodeName) const
415 {
416  return has(fields, nodeName);
417 }
418 inline int
419 VrmlNodeType::hasExposedField(const char *nodeName) const
420 {
421  // Must have field "name", eventIn "set_name", and eventOut
422  // "name_changed", all with same type:
423  int type;
424  if ( (type = has(fields, nodeName)) == 0) return 0;
425 
426  if (type != has(eventIns, nodeName)) return 0;
427 
428  if (type != has(eventOuts, nodeName)) return 0;
429 
430  return type;
431 }
432 inline int
433 VrmlNodeType::has(const vtkVRMLVectorType<NameTypeRec*> &recs, const char *nodeName) const
434 {
435  for (int i = 0;i < recs.Count(); i++)
436  {
437  NameTypeRec *n = recs.Get(i);
438  if (strcmp(n->name, nodeName) == 0)
439  return n->type;
440  }
441  return 0;
442 }
443 
444 
445 
446 
447 //----------------------------------------------------------------------------
449 {
450  yy_current_buffer = nullptr;
451  yy_c_buf_p = nullptr;
452  yy_init = 1;
453  yy_start = 0;
454  yy_flex_debug = 1;
455  yyin = nullptr;
456  yyout = nullptr;
457  currentLineNumber = 1;
458  expectToken = 0;
459  parsing_mf = 0;
461  sfImageIntsParsed = 0;
462  memyyInput_i = 0;
463  memyyInput_j = 0;
464  creatingDEF = 0;
465  theyyInput = nullptr;
466 
467  typeList = nullptr;
468  useList = nullptr;
469  currentField = nullptr;
470 }
471 
472 //----------------------------------------------------------------------------
474 {
475  if (yy_current_buffer)
476  {
478  yy_current_buffer = nullptr;
479  }
480 }
481 
482 
484 {
485  if (find(_type->getName()) != nullptr)
486  {
487  cerr << "PROTO " << _type->getName() << " already defined\n";
488  return;
489  }
490  *typeList += _type;
491 }
492 
493 //
494 // One list is used to store all the node types. Nested namespaces are
495 // separated by nullptr elements.
496 // This isn't terribly efficient, but it is nice and simple.
497 //
499 {
500  *typeList += (VrmlNodeType *) nullptr;
501 }
502 
504 {
505  // Remove everything up to and including the next nullptr marker:
506  for (int i = 0;i < typeList->Count(); i++)
507  {
508  VrmlNodeType *nodeType = typeList->Pop();
509 
510  if (nodeType == nullptr)
511  {
512  break;
513  }
514  else
515  {
516  // NOTE: Instead of just deleting the VrmlNodeTypes, you will
517  // probably want to reference count or garbage collect them, since
518  // any nodes created as part of the PROTO implementation will
519  // probably point back to their VrmlNodeType structure.
520  delete nodeType;
521  }
522  }
523 }
524 
525 inline const VrmlNodeType* vtkVRMLYaccData::find(const char *_name)
526 {
527  // Look through the type stack:
528  for (int i = 0;i < typeList->Count(); i++)
529  {
530  const VrmlNodeType *nt = (*typeList)[i];
531  if (nt != nullptr && strcmp(nt->getName(),_name) == 0)
532  {
533  return nt;
534  }
535  }
536  return nullptr;
537 }
538 
539 
540 // Begin of Auto-generated Parser Code
541 
542 
543 /* A Bison parser, made from parser.y with Bison version GNU Bison version 1.24
544  */
545 
546 #define YYBISON 1 /* Identify Bison output. */
547 
548 #define IDENTIFIER 258
549 #define DEF 259
550 #define USE 260
551 #define PROTO 261
552 #define EXTERNPROTO 262
553 #define TO 263
554 #define IS 264
555 #define ROUTE 265
556 #define SFN_NULL 266
557 #define EVENTIN 267
558 #define EVENTOUT 268
559 #define FIELD 269
560 #define EXPOSEDFIELD 270
561 #define SFBOOL 271
562 #define SFCOLOR 272
563 #define SFFLOAT 273
564 #define SFIMAGE 274
565 #define SFINT32 275
566 #define SFNODE 276
567 #define SFROTATION 277
568 #define SFSTRING 278
569 #define SFTIME 279
570 #define SFVEC2F 280
571 #define SFVEC3F 281
572 #define MFCOLOR 282
573 #define MFFLOAT 283
574 #define MFINT32 284
575 #define MFROTATION 285
576 #define MFSTRING 286
577 #define MFVEC2F 287
578 #define MFVEC3F 288
579 #define MFNODE 289
580 
581 
582 
583 //
584 // Parser for VRML 2.0 files.
585 // This is a minimal parser that does NOT generate an in-memory scene graph.
586 //
587 
588 // The original parser was developed on a Windows 95 PC with
589 // Borland's C++ 5.0 development tools. This was then ported
590 // to a Windows 95 PC with Microsoft's MSDEV C++ 4.0 development
591 // tools. The port introduced the ifdef's for
592 // USING_BORLAND_CPP_5 : since this provides a "std namespace",
593 // TWO_ARGUMENTS_FOR_STL_STACK : STL is a moving target. The stack template
594 // class takes either one or two arguments.
595 
596 
597 #define YYDEBUG 1
598 
599 VTK_ABI_NAMESPACE_END
600 #include <stdlib.h>
601 
602 
603 
604 
605 // This is used when the parser knows what kind of token it expects
606 // to get next-- used when parsing field values (whose types are declared
607 // and read by the parser) and at certain other places:
608 //extern int expectToken;
609 
610 // Current line number (set by lexer)
611 //extern int currentLineNumber;
612 
613 // Some helper routines defined below:
614 //static void beginProto(const char *);
615 //static void endProto();
616 
617 //static int addField(const char *type, const char *name);
618 //static int addEventIn(const char *type, const char *name);
619 //static int addEventOut(const char *type, const char *name);
620 //static int addExposedField(const char *type, const char *name);
621 //static int add(void (VrmlNodeType::*)(const char *, int), const char *,
622 // const char *);
623 //static int fieldType(const char *type);
624 //static void inScript();
625 //static void expect(int type);
626 
627 //void yyerror(const char *);
628 //int yylex(vtkVRMLImporter* self);
629 
630 
631 
632 #ifndef YYLTYPE
633 
634 #define YYLTYPE yyltype
635 #endif
636 
637 #define YYFINAL 128
638 #define YYFLAG -32768
639 #define YYNTBASE 40
640 
641 #define YYTRANSLATE(x) ((unsigned)(x) <= 289 ? yytranslate[x] : 68)
642 
643 static const char yytranslate[] = { 0,
644  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
645  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
646  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
647  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
648  2, 2, 2, 2, 2, 39, 2, 2, 2, 2,
649  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
650  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
651  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
652  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
653  35, 2, 36, 2, 2, 2, 2, 2, 2, 2,
654  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
655  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
656  2, 2, 37, 2, 38, 2, 2, 2, 2, 2,
657  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
658  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
659  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
660  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
661  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
662  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
663  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
664  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
665  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
666  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
667  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
668  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
669  2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
670  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
671  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
672  26, 27, 28, 29, 30, 31, 32, 33, 34
673 };
674 
675 #if YYDEBUG != 0
676 static const short yyprhs[] = { 0,
677  0, 2, 3, 6, 8, 10, 12, 14, 15, 16,
678  22, 25, 27, 29, 30, 40, 41, 42, 51, 52,
679  55, 59, 63, 64, 70, 71, 77, 78, 81, 85,
680  89, 93, 97, 106, 107, 113, 114, 117, 118, 122,
681  124, 126, 130, 134, 135, 141, 147, 153, 155, 157,
682  159, 161, 163, 165, 167, 169, 171, 173, 175, 177,
683  179, 181, 183, 185, 187, 190, 193, 196, 199, 203,
684  205, 206
685 };
686 
687 static const short yyrhs[] = { 41,
688  0, 0, 41, 42, 0, 43, 0, 46, 0, 58,
689  0, 59, 0, 0, 0, 4, 44, 3, 45, 59,
690  0, 5, 3, 0, 47, 0, 49, 0, 0, 6,
691  3, 48, 35, 52, 36, 37, 41, 38, 0, 0,
692  0, 7, 3, 50, 35, 56, 36, 51, 65, 0,
693  0, 52, 53, 0, 12, 3, 3, 0, 13, 3,
694  3, 0, 0, 14, 3, 3, 54, 65, 0, 0,
695  15, 3, 3, 55, 65, 0, 0, 56, 57, 0,
696  12, 3, 3, 0, 13, 3, 3, 0, 14, 3,
697  3, 0, 15, 3, 3, 0, 10, 3, 39, 3,
698  8, 3, 39, 3, 0, 0, 3, 60, 37, 61,
699  38, 0, 0, 61, 62, 0, 0, 3, 63, 65,
700  0, 58, 0, 46, 0, 12, 3, 3, 0, 13,
701  3, 3, 0, 0, 14, 3, 3, 64, 65, 0,
702  12, 3, 3, 9, 3, 0, 13, 3, 3, 9,
703  3, 0, 16, 0, 17, 0, 27, 0, 18, 0,
704  28, 0, 19, 0, 20, 0, 29, 0, 22, 0,
705  30, 0, 23, 0, 31, 0, 24, 0, 25, 0,
706  32, 0, 26, 0, 33, 0, 21, 43, 0, 21,
707  11, 0, 34, 66, 0, 9, 3, 0, 35, 67,
708  36, 0, 43, 0, 0, 67, 43, 0
709 };
710 
711 #endif
712 
713 #if YYDEBUG != 0
714 static const short yyrline[] = { 0,
715  106, 109, 111, 114, 116, 117, 120, 122, 123, 124,
716  125, 128, 130, 133, 135, 139, 141, 143, 145, 147,
717  150, 153, 155, 157, 158, 160, 163, 165, 168, 171,
718  173, 175, 179, 184, 186, 189, 191, 194, 196, 197,
719  198, 201, 202, 203, 206, 207, 209, 213, 215, 216,
720  217, 218, 219, 220, 221, 222, 223, 224, 225, 226,
721  227, 228, 229, 230, 232, 233, 234, 235, 238, 240,
722  243, 245
723 };
724 
725 static const char * const yytname[] = { "$","error","$undefined.","IDENTIFIER",
726  "DEF","USE","PROTO","EXTERNPROTO","TO","IS","ROUTE","SFN_NULL","EVENTIN","EVENTOUT",
727  "FIELD","EXPOSEDFIELD","SFBOOL","SFCOLOR","SFFLOAT","SFIMAGE","SFINT32","SFNODE",
728  "SFROTATION","SFSTRING","SFTIME","SFVEC2F","SFVEC3F","MFCOLOR","MFFLOAT","MFINT32",
729  "MFROTATION","MFSTRING","MFVEC2F","MFVEC3F","MFNODE","'['","']'","'{'","'}'",
730  "'.'","vrmlscene","declarations","declaration","nodeDeclaration","@1","@2","protoDeclaration",
731  "proto","@3","externproto","@4","@5","interfaceDeclarations","interfaceDeclaration",
732  "@6","@7","externInterfaceDeclarations","externInterfaceDeclaration","routeDeclaration",
733  "node","@8","nodeGuts","nodeGut","@9","@10","fieldValue","mfnodeValue","nodes",
734  ""
735 };
736 #endif
737 
738 static const short yyr1[] = { 0,
739  40, 41, 41, 42, 42, 42, 43, 44, 45, 43,
740  43, 46, 46, 48, 47, 50, 51, 49, 52, 52,
741  53, 53, 54, 53, 55, 53, 56, 56, 57, 57,
742  57, 57, 58, 60, 59, 61, 61, 63, 62, 62,
743  62, 62, 62, 64, 62, 62, 62, 65, 65, 65,
744  65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
745  65, 65, 65, 65, 65, 65, 65, 65, 66, 66,
746  67, 67
747 };
748 
749 static const short yyr2[] = { 0,
750  1, 0, 2, 1, 1, 1, 1, 0, 0, 5,
751  2, 1, 1, 0, 9, 0, 0, 8, 0, 2,
752  3, 3, 0, 5, 0, 5, 0, 2, 3, 3,
753  3, 3, 8, 0, 5, 0, 2, 0, 3, 1,
754  1, 3, 3, 0, 5, 5, 5, 1, 1, 1,
755  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
756  1, 1, 1, 1, 2, 2, 2, 2, 3, 1,
757  0, 2
758 };
759 
760 static const short yydefact[] = { 2,
761  1, 34, 8, 0, 0, 0, 0, 3, 4, 5,
762  12, 13, 6, 7, 0, 0, 11, 14, 16, 0,
763  36, 9, 0, 0, 0, 0, 0, 19, 27, 0,
764  38, 0, 0, 0, 35, 41, 40, 37, 10, 0,
765  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
766  0, 20, 0, 0, 0, 0, 17, 28, 0, 0,
767  48, 49, 51, 53, 54, 0, 56, 58, 60, 61,
768  63, 50, 52, 55, 57, 59, 62, 64, 0, 39,
769  42, 43, 44, 0, 0, 0, 0, 2, 0, 0,
770  0, 0, 0, 0, 68, 66, 65, 71, 70, 67,
771  0, 0, 0, 21, 22, 23, 25, 0, 29, 30,
772  31, 32, 18, 33, 0, 46, 47, 45, 0, 0,
773  15, 69, 72, 24, 26, 0, 0, 0
774 };
775 
776 static const short yydefgoto[] = { 126,
777  1, 8, 9, 16, 27, 10, 11, 23, 12, 24,
778  93, 40, 52, 119, 120, 41, 58, 13, 14, 15,
779  26, 38, 43, 103, 80, 100, 115
780 };
781 
782 static const short yypact[] = {-32768,
783  79,-32768,-32768, -1, 0, 3, 4,-32768,-32768,-32768,
784  -32768,-32768,-32768,-32768, -28, 11,-32768,-32768,-32768, -18,
785  -32768,-32768, -6, 5, 32, -2, 38,-32768,-32768, 35,
786  -32768, 39, 41, 45,-32768,-32768,-32768,-32768,-32768, 19,
787  66, 48, 43, 50, 51, 54, 84, 85, 87, 88,
788  55,-32768, 90, 91, 92, 93,-32768,-32768, 58, 95,
789  -32768,-32768,-32768,-32768,-32768, 34,-32768,-32768,-32768,-32768,
790  -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 23,-32768,
791  94, 96,-32768, 97, 98, 101, 103,-32768, 104, 105,
792  106, 107, 43, 108,-32768,-32768,-32768,-32768,-32768,-32768,
793  109, 110, 43,-32768,-32768,-32768,-32768, 12,-32768,-32768,
794  -32768,-32768,-32768,-32768, 20,-32768,-32768,-32768, 43, 43,
795  -32768,-32768,-32768,-32768,-32768, 99, 114,-32768
796 };
797 
798 static const short yypgoto[] = {-32768,
799  27,-32768, -66,-32768,-32768, 100,-32768,-32768,-32768,-32768,
800  -32768,-32768,-32768,-32768,-32768,-32768,-32768, 102, 89,-32768,
801  -32768,-32768,-32768,-32768, -73,-32768,-32768
802 };
803 
804 
805 #define YYLAST 128
806 
807 
808 static const short yytable[] = { 97,
809  31, 17, 18, 5, 6, 19, 20, 7, 21, 32,
810  33, 34, 99, 22, 2, 3, 4, 5, 6, 113,
811  25, 7, 2, 3, 4, 2, 3, 4, 28, 118,
812  47, 48, 49, 50, 30, 35, 2, 3, 4, 29,
813  2, 44, 42, 45, 96, 124, 125, 46, 123, 121,
814  59, 60, 81, 82, 51, 122, 83, 98, 61, 62,
815  63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
816  73, 74, 75, 76, 77, 78, 79, 53, 54, 55,
817  56, 2, 3, 4, 5, 6, 84, 85, 7, 86,
818  87, 88, 89, 90, 91, 92, 94, 95, 127, 104,
819  105, 57, 101, 106, 102, 107, 109, 110, 111, 112,
820  114, 116, 117, 128, 108, 39, 0, 0, 0, 0,
821  0, 0, 0, 0, 0, 36, 0, 37
822 };
823 
824 static const short yycheck[] = { 66,
825  3, 3, 3, 6, 7, 3, 3, 10, 37, 12,
826  13, 14, 79, 3, 3, 4, 5, 6, 7, 93,
827  39, 10, 3, 4, 5, 3, 4, 5, 35, 103,
828  12, 13, 14, 15, 3, 38, 3, 4, 5, 35,
829  3, 3, 8, 3, 11, 119, 120, 3, 115, 38,
830  3, 9, 3, 3, 36, 36, 3, 35, 16, 17,
831  18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
832  28, 29, 30, 31, 32, 33, 34, 12, 13, 14,
833  15, 3, 4, 5, 6, 7, 3, 3, 10, 3,
834  3, 37, 3, 3, 3, 3, 39, 3, 0, 3,
835  3, 36, 9, 3, 9, 3, 3, 3, 3, 3,
836  3, 3, 3, 0, 88, 27, -1, -1, -1, -1,
837  -1, -1, -1, -1, -1, 26, -1, 26
838 };
839 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
840 
841 //extern int yylex(vtkVRMLImporter* self);
842 //extern void yyerror();
843 
844 #include <list>
845 //
846 // This file was originally generated from a yacc grammar source
847 // file, but subsequently it has been locally modified to suit
848 // VTK's needs. The use of alloca -- part of the original parser
849 // boilerplate became problematic because the confusing
850 // preprocessor #defines with respect to alloca were causing
851 // compile problems with newer versions of CLang.
852 //
853 // This class replaces alloca with a malloc-based allocator that
854 // cleans up after itself when the FakeAlloca object goes out of
855 // scope. Whatever performance penalty this incurs is minor and
856 // would only be noticeably if a very large, deeply nested VRML
857 // file was imported; in the real world, I think alloca was very
858 // rarely called here.
859 
860 VTK_ABI_NAMESPACE_BEGIN
862 {
863 public:
864  typedef std::list<void *> list_type;
866  {
867  for(list_type::iterator it = this->m_allocs.begin();
868  it != this->m_allocs.end(); ++it)
869  {
870  free(*it);
871  }
872  }
873  void *Allocate(size_t size)
874  {
875  void *rval = malloc(size);
876  m_allocs.push_back(rval);
877  return rval;
878  }
879 private:
880  list_type m_allocs;
881 };
882 /* This is the parser code that is written into each bison parser
883  when the %semantic_parser declaration is not specified in the grammar.
884  It was written by Richard Stallman by simplifying the hairy parser
885  used when %semantic_parser is specified. */
886 
887 /* Note: there must be only one dollar sign in this file.
888  It is replaced by the list of actions, each action
889  as one case of the switch. */
890 
891 #define yyerrok (yyerrstatus = 0)
892 #define yyclearin (yychar = YYEMPTY)
893 #define YYEMPTY -2
894 #define YYEOF 0
895 #define YYACCEPT return(0)
896 #define YYABORT return(1)
897 #define YYERROR goto yyerrlab1
898 /* Like YYERROR except do call yyerror.
899  This remains here temporarily to ease the
900  transition to the new meaning of YYERROR, for GCC.
901  Once GCC version 2 has supplanted version 1, this can go. */
902 #define YYFAIL goto yyerrlab
903 #define YYRECOVERING() (!!yyerrstatus)
904 #define YYBACKUP(token, value) \
905 do \
906  if (yychar == YYEMPTY && yylen == 1) \
907  { yychar = (token), yylval = (value); \
908  yychar1 = YYTRANSLATE (yychar); \
909  YYPOPSTACK; \
910  goto yybackup; \
911  } \
912  else \
913  { yyerror ("syntax error: cannot back up"); YYERROR; } \
914 while (0)
915 
916 #define YYTERROR 1
917 #define YYERRCODE 256
918 
919 
920 /* YYINITDEPTH indicates the initial size of the parser's stacks */
921 
922 #ifndef YYINITDEPTH
923 #define YYINITDEPTH 200
924 #endif
925 
926 /* YYMAXDEPTH is the maximum size the stacks can grow to
927  (effective only if the built-in stack extension method is used). */
928 
929 #if defined(YYMAXDEPTH) && (YYMAXDEPTH == 0)
930 #undef YYMAXDEPTH
931 #endif
932 
933 #ifndef YYMAXDEPTH
934 #define YYMAXDEPTH 10000
935 #endif
936 
937 static void
938 yy_memcpy (char *from, char *to, int count)
939 {
940  char *f = from;
941  char *t = to;
942  int i = count;
943 
944  while (i-- > 0)
945  *t++ = *f++;
946 }
947 
948 
950 {
951  FakeAlloca yyallocator;
952  int yystate;
953  int yyn;
954  short *yyssp;
955  YYSTYPE *yyvsp;
956  int yyerrstatus; /* number of tokens to shift before error messages enabled */
957  int yychar1 = 0; /* lookahead token as an internal (translated) token number */
958 
959  short yyssa[YYINITDEPTH]; /* the state stack */
960  YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
961 
962  short *yyss = yyssa; /* refer to the stacks through separate pointers */
963  YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
964 
965 #ifdef YYLSP_NEEDED
966  YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
967  YYLTYPE *yyls = yylsa;
968  YYLTYPE *yylsp;
969 
970 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
971 #else
972 #define YYPOPSTACK (yyvsp--, yyssp--)
973 #endif
974 
975  int yystacksize = YYINITDEPTH;
976 
977 #ifdef YYPURE
978  int yychar;
979  YYSTYPE yylval;
980  int yynerrs;
981 #ifdef YYLSP_NEEDED
982  YYLTYPE yylloc;
983 #endif
984 #endif
985 
986  YYSTYPE yyval; /* the variable used to return */
987  /* semantic values from the action */
988  /* routines */
989 
990  int yylen;
991 
992 #if YYDEBUG != 0
993  if (yydebug)
994  fprintf(stderr, "Starting parse\n");
995 #endif
996 
997  yystate = 0;
998  yyerrstatus = 0;
999  yynerrs = 0;
1000  yychar = YYEMPTY; /* Cause a token to be read. */
1001 
1002  /* Initialize stack pointers.
1003  Waste one element of value and location stack
1004  so that they stay on the same level as the state stack.
1005  The wasted elements are never initialized. */
1006 
1007  yyssp = yyss - 1;
1008  yyvsp = yyvs;
1009 #ifdef YYLSP_NEEDED
1010  yylsp = yyls;
1011 #endif
1012 
1013  /* Push a new state, which is found in yystate . */
1014  /* In all cases, when you get here, the value and location stacks
1015  have just been pushed. so pushing a state here evens the stacks. */
1016  yynewstate:
1017 
1018  *++yyssp = yystate;
1019 
1020  if (yyssp >= yyss + yystacksize - 1)
1021  {
1022  /* Give user a chance to reallocate the stack */
1023  /* Use copies of these so that the &'s don't force the real ones into memory. */
1024  YYSTYPE *yyvs1 = yyvs;
1025  short *yyss1 = yyss;
1026 #ifdef YYLSP_NEEDED
1027  YYLTYPE *yyls1 = yyls;
1028 #endif
1029 
1030  /* Get the current used size of the three stacks, in elements. */
1031  int size = yyssp - yyss + 1;
1032 
1033 #ifdef yyoverflow
1034  /* Each stack pointer address is followed by the size of
1035  the data in use in that stack, in bytes. */
1036 #ifdef YYLSP_NEEDED
1037  /* This used to be a conditional around just the two extra args,
1038  but that might be undefined if yyoverflow is a macro. */
1039  yyoverflow("parser stack overflow",
1040  &yyss1, size * sizeof (*yyssp),
1041  &yyvs1, size * sizeof (*yyvsp),
1042  &yyls1, size * sizeof (*yylsp),
1043  &yystacksize);
1044 #else
1045  yyoverflow("parser stack overflow",
1046  &yyss1, size * sizeof (*yyssp),
1047  &yyvs1, size * sizeof (*yyvsp),
1048  &yystacksize);
1049 #endif
1050 
1051  yyss = yyss1; yyvs = yyvs1;
1052 #ifdef YYLSP_NEEDED
1053  yyls = yyls1;
1054 #endif
1055 #else /* no yyoverflow */
1056  /* Extend the stack our own way. */
1057  if (yystacksize >= YYMAXDEPTH)
1058  {
1059  yyerror("parser stack overflow");
1060  return 2;
1061  }
1062  yystacksize *= 2;
1063  if (yystacksize > YYMAXDEPTH)
1064  yystacksize = YYMAXDEPTH;
1065  yyss = (short *) yyallocator.Allocate (yystacksize * sizeof (*yyssp));
1066  yy_memcpy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
1067  yyvs = (YYSTYPE *) yyallocator.Allocate (yystacksize * sizeof (*yyvsp));
1068  yy_memcpy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
1069 #ifdef YYLSP_NEEDED
1070  yyls = (YYLTYPE *) yyallocator.Allocate (yystacksize * sizeof (*yylsp));
1071  yy_memcpy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
1072 #endif
1073 #endif /* no yyoverflow */
1074 
1075  yyssp = yyss + size - 1;
1076  yyvsp = yyvs + size - 1;
1077 #ifdef YYLSP_NEEDED
1078  yylsp = yyls + size - 1;
1079 #endif
1080 
1081 #if YYDEBUG != 0
1082  if (yydebug)
1083  fprintf(stderr, "Stack size increased to %d\n", yystacksize);
1084 #endif
1085 
1086  if (yyssp >= yyss + yystacksize - 1)
1087  YYABORT;
1088  }
1089 
1090 #if YYDEBUG != 0
1091  if (yydebug)
1092  fprintf(stderr, "Entering state %d\n", yystate);
1093 #endif
1094 
1095  goto yybackup;
1096  yybackup:
1097 
1098  /* Do appropriate processing given the current state. */
1099  /* Read a lookahead token if we need one and don't already have one. */
1100  /* yyresume: */
1101 
1102  /* First try to decide what to do without reference to lookahead token. */
1103 
1104  yyn = yypact[yystate];
1105  if (yyn == YYFLAG)
1106  goto yydefault;
1107 
1108  /* Not known => get a lookahead token if don't already have one. */
1109 
1110  /* yychar is either YYEMPTY or YYEOF
1111  or a valid token in external form. */
1112 
1113  if (yychar == YYEMPTY)
1114  {
1115 #if YYDEBUG != 0
1116  if (yydebug)
1117  fprintf(stderr, "Reading a token: ");
1118 #endif
1119  yychar = yylex(self);
1120  }
1121 
1122  /* Convert token to internal form (in yychar1) for indexing tables with */
1123 
1124  if (yychar <= 0) /* This means end of input. */
1125  {
1126  yychar1 = 0;
1127  yychar = YYEOF; /* Don't call YYLEX any more */
1128 
1129 #if YYDEBUG != 0
1130  if (yydebug)
1131  fprintf(stderr, "Now at end of input.\n");
1132 #endif
1133  }
1134  else
1135  {
1136  yychar1 = YYTRANSLATE(yychar);
1137 
1138 #if YYDEBUG != 0
1139  if (yydebug)
1140  {
1141  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
1142  /* Give the individual parser a way to print the precise meaning
1143  of a token, for further debugging info. */
1144 #ifdef YYPRINT
1145  YYPRINT (stderr, yychar, yylval);
1146 #endif
1147  fprintf (stderr, ")\n");
1148  }
1149 #endif
1150  }
1151 
1152  yyn += yychar1;
1153  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
1154  goto yydefault;
1155 
1156  yyn = yytable[yyn];
1157 
1158  /* yyn is what to do for this token type in this state.
1159  Negative => reduce, -yyn is rule number.
1160  Positive => shift, yyn is new state.
1161  New state is final state => don't bother to shift,
1162  just return success.
1163  0, or most negative number => error. */
1164 
1165  if (yyn < 0)
1166  {
1167  if (yyn == YYFLAG)
1168  goto yyerrlab;
1169  yyn = -yyn;
1170  goto yyreduce;
1171  }
1172  else if (yyn == 0)
1173  goto yyerrlab;
1174 
1175  if (yyn == YYFINAL)
1176  YYACCEPT;
1177 
1178  /* Shift the lookahead token. */
1179 
1180 #if YYDEBUG != 0
1181  if (yydebug)
1182  fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1183 #endif
1184 
1185  /* Discard the token being shifted unless it is eof. */
1186  if (yychar != YYEOF)
1187  yychar = YYEMPTY;
1188 
1189  *++yyvsp = yylval;
1190 #ifdef YYLSP_NEEDED
1191  *++yylsp = yylloc;
1192 #endif
1193 
1194  /* count tokens shifted since error; after three, turn off error status. */
1195  if (yyerrstatus) yyerrstatus--;
1196 
1197  yystate = yyn;
1198  goto yynewstate;
1199 
1200  /* Do the default action for the current state. */
1201  yydefault:
1202 
1203  yyn = yydefact[yystate];
1204  if (yyn == 0)
1205  goto yyerrlab;
1206 
1207  /* Do a reduction. yyn is the number of a rule to reduce with. */
1208  yyreduce:
1209  yylen = yyr2[yyn];
1210  if (yylen > 0)
1211  yyval = yyvsp[1-yylen]; /* implement default value of the action */
1212  else
1213  yyval.sfint = 0;
1214 
1215 #if YYDEBUG != 0
1216  if (yydebug)
1217  {
1218  int i;
1219 
1220  fprintf (stderr, "Reducing via rule %d (line %d), ",
1221  yyn, yyrline[yyn]);
1222 
1223  /* Print the symbols being reduced, and their result. */
1224  for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1225  fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1226  fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1227  }
1228 #endif
1229 
1230 
1231  // Note: several free() methods are commented out due to the use of
1232  // vtkVRMLAllocator.
1233  switch (yyn) {
1234 
1235  case 8:
1236  { creatingDEF = 1;
1237  break;}
1238  case 9:
1239  { curDEFName = yyvsp[0].string;
1240  break;}
1241  case 10:
1242  { creatingDEF = 0;
1243  break;}
1244  case 11:
1245  { self->useNode(yyvsp[0].string);//free(yyvsp[0].string); ;
1246  break;}
1247  case 14:
1248  { beginProto(yyvsp[0].string);
1249  break;}
1250  case 15:
1251  { endProto(); //free(yyvsp[-7].string);
1252  break;}
1253  case 16:
1254  { beginProto(yyvsp[0].string);
1255  break;}
1256  case 17:
1257  { expect(MFSTRING);
1258  break;}
1259  case 18:
1260  { endProto(); //free(yyvsp[-6].string); ;
1261  break;}
1262  case 21:
1263  { addEventIn(yyvsp[-1].string, yyvsp[0].string);
1264  //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1265  break;}
1266  case 22:
1267  { addEventOut(yyvsp[-1].string, yyvsp[0].string);
1268  //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1269  break;}
1270  case 23:
1271  { int type = addField(yyvsp[-1].string, yyvsp[0].string);
1272  expect(type);
1273  break;}
1274  case 24:
1275  { //free(yyvsp[-3].string); free(yyvsp[-2].string); ;
1276  break;}
1277  case 25:
1278  { int type = addExposedField(yyvsp[-1].string, yyvsp[0].string);
1279  expect(type);
1280  break;}
1281  case 26:
1282  { //free(yyvsp[-3].string); free(yyvsp[-2].string); ;
1283  break;}
1284  case 29:
1285  { addEventIn(yyvsp[-1].string, yyvsp[0].string);
1286  //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1287  break;}
1288  case 30:
1289  { addEventOut(yyvsp[-1].string, yyvsp[0].string);
1290  //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1291  break;}
1292  case 31:
1293  { addField(yyvsp[-1].string, yyvsp[0].string);
1294  //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1295  break;}
1296  case 32:
1297  { addExposedField(yyvsp[-1].string, yyvsp[0].string);
1298  //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1299  break;}
1300  case 33:
1301  { //free(yyvsp[-6].string); free(yyvsp[-4].string); free(yyvsp[-2].string); free(yyvsp[0].string); ;
1302  break;}
1303  case 34:
1304  { self->enterNode(yyvsp[0].string);
1305  break;}
1306  case 35:
1307  { self->exitNode(); //free(yyvsp[-4].string);
1308  break;}
1309  case 38:
1310  { self->enterField(yyvsp[0].string);
1311  break;}
1312  case 39:
1313  { self->exitField(); //free(yyvsp[-2].string); ;
1314  break;}
1315  case 42:
1316  { inScript(); //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1317  break;}
1318  case 43:
1319  { inScript(); //free(yyvsp[-1].string); free(yyvsp[0].string); ;
1320  break;}
1321  case 44:
1322  { inScript();
1323  int type = fieldType(yyvsp[-1].string);
1324  expect(type);
1325  break;}
1326  case 45:
1327  { //free(yyvsp[-3].string); free(yyvsp[-2].string); ;
1328  break;}
1329  case 46:
1330  { inScript(); //free(yyvsp[-3].string); free(yyvsp[-2].string); free(yyvsp[0].string); ;
1331  break;}
1332  case 47:
1333  { inScript(); //free(yyvsp[-3].string); free(yyvsp[-2].string); free(yyvsp[0].string); ;
1334  break;}
1335  case 49:
1336  {
1337  break;}
1338  case 50:
1339  { break;}
1340  case 55:
1341  { break;}
1342  case 63:
1343  {
1344  break;}
1345  case 64:
1346  { break;}
1347  case 68:
1348  { //free(yyvsp[0].string); ;
1349  break;}
1350  }
1351  /* the action file gets copied in place of this dollarsign */
1352 
1353 
1354  yyvsp -= yylen;
1355  yyssp -= yylen;
1356 #ifdef YYLSP_NEEDED
1357  yylsp -= yylen;
1358 #endif
1359 
1360 #if YYDEBUG != 0
1361  if (yydebug)
1362  {
1363  short *ssp1 = yyss - 1;
1364  fprintf (stderr, "state stack now");
1365  while (ssp1 != yyssp)
1366  fprintf (stderr, " %d", *++ssp1);
1367  fprintf (stderr, "\n");
1368  }
1369 #endif
1370 
1371  *++yyvsp = yyval;
1372 
1373 #ifdef YYLSP_NEEDED
1374  yylsp++;
1375  if (yylen == 0)
1376  {
1377  yylsp->first_line = yylloc.first_line;
1378  yylsp->first_column = yylloc.first_column;
1379  yylsp->last_line = (yylsp-1)->last_line;
1380  yylsp->last_column = (yylsp-1)->last_column;
1381  yylsp->text = 0;
1382  }
1383  else
1384  {
1385  yylsp->last_line = (yylsp+yylen-1)->last_line;
1386  yylsp->last_column = (yylsp+yylen-1)->last_column;
1387  }
1388 #endif
1389 
1390  /* Now "shift" the result of the reduction.
1391  Determine what state that goes to,
1392  based on the state we popped back to
1393  and the rule number reduced by. */
1394 
1395  yyn = yyr1[yyn];
1396 
1397  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1398  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1399  yystate = yytable[yystate];
1400  else
1401  yystate = yydefgoto[yyn - YYNTBASE];
1402 
1403  goto yynewstate;
1404 
1405  yyerrlab: /* here on detecting error */
1406 
1407  if (! yyerrstatus)
1408  /* If not already recovering from an error, report this error. */
1409  {
1410  ++yynerrs;
1411 
1412 #ifdef YYERROR_VERBOSE
1413  yyn = yypact[yystate];
1414 
1415  if (yyn > YYFLAG && yyn < YYLAST)
1416  {
1417  int size = 0;
1418  char *msg;
1419  int x, count;
1420 
1421  count = 0;
1422  /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
1423  for (x = (yyn < 0 ? -yyn : 0);
1424  x < (sizeof(yytname) / sizeof(char *)); x++)
1425  if (yycheck[x + yyn] == x)
1426  size += strlen(yytname[x]) + 15, count++;
1427  msg = (char *) malloc(size + 15);
1428  if (msg != 0)
1429  {
1430  strcpy(msg, "parse error");
1431 
1432  if (count < 5)
1433  {
1434  count = 0;
1435  for (x = (yyn < 0 ? -yyn : 0);
1436  x < (sizeof(yytname) / sizeof(char *)); x++)
1437  if (yycheck[x + yyn] == x)
1438  {
1439  strcat(msg, count == 0 ? ", expecting `" : " or `");
1440  strcat(msg, yytname[x]);
1441  strcat(msg, "'");
1442  count++;
1443  }
1444  }
1445  yyerror(msg);
1446  free(msg);
1447  }
1448  else
1449  yyerror ("parse error; also virtual memory exceeded");
1450  }
1451  else
1452 #endif /* YYERROR_VERBOSE */
1453  yyerror("parse error");
1454  }
1455 
1456  goto yyerrlab1;
1457  yyerrlab1: /* here on error raised explicitly by an action */
1458 
1459  if (yyerrstatus == 3)
1460  {
1461  /* if just tried and failed to reuse lookahead token after an error, discard it. */
1462 
1463  /* return failure if at end of input */
1464  if (yychar == YYEOF)
1465  YYABORT;
1466 
1467 #if YYDEBUG != 0
1468  if (yydebug)
1469  fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1470 #endif
1471 
1472  yychar = YYEMPTY;
1473  }
1474 
1475  /* Else will try to reuse lookahead token
1476  after shifting the error token. */
1477 
1478  yyerrstatus = 3; /* Each real token shifted decrements this */
1479 
1480  goto yyerrhandle;
1481 
1482  yyerrdefault: /* current state does not do anything special for the error token. */
1483 
1484 #if 0
1485  /* This is wrong; only states that explicitly want error tokens
1486  should shift them. */
1487  yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1488  if (yyn) goto yydefault;
1489 #endif
1490 
1491  yyerrpop: /* pop the current state because it cannot handle the error token */
1492 
1493  if (yyssp == yyss) YYABORT;
1494  yyvsp--;
1495  yystate = *--yyssp;
1496 #ifdef YYLSP_NEEDED
1497  yylsp--;
1498 #endif
1499 
1500 #if YYDEBUG != 0
1501  if (yydebug)
1502  {
1503  short *ssp1 = yyss - 1;
1504  fprintf (stderr, "Error: state stack now");
1505  while (ssp1 != yyssp)
1506  fprintf (stderr, " %d", *++ssp1);
1507  fprintf (stderr, "\n");
1508  }
1509 #endif
1510 
1511  yyerrhandle:
1512 
1513  yyn = yypact[yystate];
1514  if (yyn == YYFLAG)
1515  goto yyerrdefault;
1516 
1517  yyn += YYTERROR;
1518  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1519  goto yyerrdefault;
1520 
1521  yyn = yytable[yyn];
1522  if (yyn < 0)
1523  {
1524  if (yyn == YYFLAG)
1525  goto yyerrpop;
1526  yyn = -yyn;
1527  goto yyreduce;
1528  }
1529  else if (yyn == 0)
1530  goto yyerrpop;
1531 
1532  if (yyn == YYFINAL)
1533  YYACCEPT;
1534 
1535 #if YYDEBUG != 0
1536  if (yydebug)
1537  fprintf(stderr, "Shifting error token, ");
1538 #endif
1539 
1540  *++yyvsp = yylval;
1541 #ifdef YYLSP_NEEDED
1542  *++yylsp = yylloc;
1543 #endif
1544 
1545  yystate = yyn;
1546  goto yynewstate;
1547 }
1548 
1549 
1550 inline void vtkVRMLYaccData::yyerror(const char *msg)
1551 {
1552  cerr << "Error near line " << currentLineNumber << ": " << msg << "\n";
1553  expect(0);
1554 }
1555 
1556 inline void vtkVRMLYaccData::beginProto(const char *protoName)
1557 {
1558  // Any protos in the implementation are in a local namespace:
1559  pushNameSpace();
1560 
1561  VrmlNodeType *t = new VrmlNodeType(protoName);
1562  *CurrentProtoStack += t;
1563 }
1564 
1566 {
1567  // Make any protos defined in implementation unavailable:
1568  popNameSpace();
1569 
1570  // Add this proto definition:
1571  if (CurrentProtoStack->Count() == 0)
1572  {
1573  cerr << "Error: Empty PROTO stack!\n";
1574  }
1575  else
1576  {
1577  VrmlNodeType *t = CurrentProtoStack->Top();
1578  CurrentProtoStack->Pop();
1579  addToNameSpace(t);
1580  }
1581 }
1582 
1583 inline int vtkVRMLYaccData::addField(const char *type, const char *name)
1584 {
1585  return add(&VrmlNodeType::addField, type, name);
1586 }
1587 
1588 inline int vtkVRMLYaccData::addEventIn(const char *type, const char *name)
1589 {
1591 }
1592 inline int vtkVRMLYaccData::addEventOut(const char *type, const char *name)
1593 {
1595 }
1596 inline int vtkVRMLYaccData::addExposedField(const char *type, const char *name)
1597 {
1599 }
1600 
1601 inline int vtkVRMLYaccData::add(void (VrmlNodeType::*func)(const char *, int),
1602  const char *typeString, const char *name)
1603 {
1604  int type = fieldType(typeString);
1605 
1606  if (type == 0)
1607  {
1608  cerr << "Error: invalid field type: " << type << "\n";
1609  }
1610 
1611  // Need to add support for Script nodes:
1612  // if (inScript) ... ???
1613 
1614  if (CurrentProtoStack->Count() == 0)
1615  {
1616  cerr << "Error: declaration outside of prototype\n";
1617  return 0;
1618  }
1619  VrmlNodeType *t = CurrentProtoStack->Top();
1620  (t->*func)(name, type);
1621 
1622  return type;
1623 }
1624 
1625 inline int vtkVRMLYaccData::fieldType(const char *type)
1626 {
1627  if (strcmp(type, "SFBool") == 0) return SFBOOL;
1628  if (strcmp(type, "SFColor") == 0) return SFCOLOR;
1629  if (strcmp(type, "SFFloat") == 0) return SFFLOAT;
1630  if (strcmp(type, "SFImage") == 0) return SFIMAGE;
1631  if (strcmp(type, "SFInt32") == 0) return SFINT32;
1632  if (strcmp(type, "SFNode") == 0) return SFNODE;
1633  if (strcmp(type, "SFRotation") == 0) return SFROTATION;
1634  if (strcmp(type, "SFString") == 0) return SFSTRING;
1635  if (strcmp(type, "SFTime") == 0) return SFTIME;
1636  if (strcmp(type, "SFVec2f") == 0) return SFVEC2F;
1637  if (strcmp(type, "SFVec3f") == 0) return SFVEC3F;
1638  if (strcmp(type, "MFColor") == 0) return MFCOLOR;
1639  if (strcmp(type, "MFFloat") == 0) return MFFLOAT;
1640  if (strcmp(type, "MFInt32") == 0) return MFINT32;
1641  if (strcmp(type, "MFNode") == 0) return MFNODE;
1642  if (strcmp(type, "MFRotation") == 0) return MFROTATION;
1643  if (strcmp(type, "MFString") == 0) return MFSTRING;
1644  if (strcmp(type, "MFVec2f") == 0) return MFVEC2F;
1645  if (strcmp(type, "MFVec3f") == 0) return MFVEC3F;
1646 
1647  cerr << "Illegal field type: " << type << "\n";
1648 
1649  return 0;
1650 }
1651 
1653 {
1654  VrmlNodeType::FieldRec *fr = currentField->Top();
1655  if (fr->nodeType == nullptr ||
1656  strcmp(fr->nodeType->getName(), "Script") != 0)
1657  {
1658  yyerror("interface declaration outside of Script or prototype");
1659  }
1660 }
1661 
1662 
1664 {
1665  expectToken = type;
1666 }
1667 
1668 VTK_ABI_NAMESPACE_END
1669 
1670 // End of Auto-generated Parser Code
1671 // Begin of Auto-generated Lexer Code
1672 
1673 /* A lexical scanner generated by flex */
1674 
1675 
1676 #define FLEX_SCANNER
1677 
1678 #ifdef _WIN32
1679 #include <io.h>
1680 #else
1681 #include <unistd.h>
1682 #endif
1683 
1684 /* Use prototypes in function declarations. */
1685 #define YY_USE_PROTOS
1686 #define YY_PROTO(proto) proto
1687 
1688 /* Returned upon end-of-file. */
1689 #define YY_NULL 0
1690 
1691 /* Promotes a possibly negative, possibly signed char to an unsigned
1692  * integer for use as an array index. If the signed char is negative,
1693  * we want to instead treat it as an 8-bit unsigned char, hence the
1694  * double cast.
1695  */
1696 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
1697 
1698 /* Enter a start condition. This macro really ought to take a parameter,
1699  * but we do it the disgusting crufty way forced on us by the ()-less
1700  * definition of BEGIN.
1701  */
1702 #define BEGIN yy_start = 1 + 2 *
1703 
1704 /* Translate the current start state into a value that can be later handed
1705  * to BEGIN to return to the state.
1706  */
1707 #define YY_START ((yy_start - 1) / 2)
1708 
1709 /* Action number for EOF rule of a given start state. */
1710 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
1711 
1712 /* Special action meaning "start processing a new file". Now included
1713  * only for backward compatibility with previous versions of flex.
1714  */
1715 #define YY_NEW_FILE yyrestart( yyin )
1716 
1717 #define YY_END_OF_BUFFER_CHAR 0
1718 
1719 /* Size of default input buffer. */
1720 #define YY_BUF_SIZE 16384
1721 
1722 //typedef struct yy_buffer_state *YY_BUFFER_STATE;
1723 
1724 //extern int yyleng;
1725 //extern FILE *yyin, *yyout;
1726 
1727 #ifdef __cplusplus
1728 extern "C" {
1729 #endif
1730  //extern int yywrap YY_PROTO(( void ));
1731 #ifdef __cplusplus
1732 }
1733 #endif
1734 
1735 #define EOB_ACT_CONTINUE_SCAN 0
1736 #define EOB_ACT_END_OF_FILE 1
1737 #define EOB_ACT_LAST_MATCH 2
1738 
1739 /* The funky do-while in the following #define is used to turn the definition
1740  * int a single C statement (which needs a semi-colon terminator). This
1741  * avoids problems with code like:
1742  *
1743  * if ( condition_holds )
1744  * yyless( 5 );
1745  * else
1746  * do_something_else();
1747  *
1748  * Prior to using the do-while the compiler would get upset at the
1749  * "else" because it interpreted the "if" statement as being all
1750  * done when it reached the ';' after the yyless() call.
1751  */
1752 
1753 /* Return all but the first 'n' matched characters back to the input stream. */
1754 
1755 #define yyless(n) \
1756  do \
1757  { \
1758  /* Undo effects of setting up yytext. */ \
1759  *yy_cp = yy_hold_char; \
1760  yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
1761  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
1762  } \
1763  while ( 0 )
1764 
1765 
1766 //struct yy_buffer_state
1767 //{
1768 // FILE *yy_input_file;
1769 
1770 // char *yy_ch_buf; /* input buffer */
1771 // char *yy_buf_pos; /* current position in input buffer */
1772 
1773  /* Size of input buffer in bytes, not including room for EOB
1774  * characters.
1775  */
1776 // int yy_buf_size;
1777 
1778  /* Number of characters read into yy_ch_buf, not including EOB
1779  * characters.
1780  */
1781 // int yy_n_chars;
1782 
1783  /* Whether this is an "interactive" input source; if so, and
1784  * if we're using stdio for input, then we want to use getc()
1785  * instead of fread(), to make sure we stop fetching input after
1786  * each newline.
1787  */
1788 // int yy_is_interactive;
1789 
1790  /* Whether to try to fill the input buffer when we reach the
1791  * end of it.
1792  */
1793 // int yy_fill_buffer;
1794 
1795 // int yy_buffer_status;
1796 //#define YY_BUFFER_NEW 0
1797 //#define YY_BUFFER_NORMAL 1
1798  /* When an EOF's been seen but there's still some text to process
1799  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
1800  * shouldn't try reading from the input source any more. We might
1801  * still have a bunch of tokens to match, though, because of
1802  * possible backing-up.
1803  *
1804  * When we actually see the EOF, we change the status to "new"
1805  * (via yyrestart()), so that the user can continue scanning by
1806  * just pointing yyin at a new input file.
1807  */
1808 //#define YY_BUFFER_EOF_PENDING 2
1809 //};
1810 
1811 //static YY_BUFFER_STATE yy_current_buffer = 0;
1812 
1813 /* We provide macros for accessing buffer states in case in the
1814  * future we want to put the buffer states in a more general
1815  * "scanner state".
1816  */
1817 #define YY_CURRENT_BUFFER yy_current_buffer
1818 
1819 
1820 /* yy_hold_char holds the character lost when yytext is formed. */
1821 //static char yy_hold_char;
1822 
1823 //static int yy_n_chars; /* number of characters read into yy_ch_buf */
1824 
1825 
1826 //int yyleng;
1827 
1828 /* Points to current character in buffer. */
1829 //static char *yy_c_buf_p = (char *) 0;
1830 //static int yy_init = 1; /* whether we need to initialize */
1831 //static int yy_start = 0; /* start state number */
1832 
1833 /* Flag which is used to allow yywrap()'s to do buffer switches
1834  * instead of setting up a fresh yyin. A bit of a hack ...
1835  */
1836 //static int yy_did_buffer_switch_on_eof;
1837 
1838 //void yyrestart YY_PROTO(( FILE *input_file ));
1839 //void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
1840 //void yy_load_buffer_state YY_PROTO(( void ));
1841 //YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
1842 //void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
1843 //void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
1844 
1845 //static void *yy_flex_alloc YY_PROTO(( unsigned int ));
1846 //static void *yy_flex_realloc YY_PROTO(( void *, unsigned int ));
1847 //static void yy_flex_free YY_PROTO(( void * ));
1848 
1849 #define yy_new_buffer yy_create_buffer
1850 
1851 #define INITIAL 0
1852 #define NODE 1
1853 #define SFB 2
1854 #define SFC 3
1855 #define SFF 4
1856 #define SFIMG 5
1857 #define SFI 6
1858 #define SFR 7
1859 #define SFS 8
1860 #define SFT 9
1861 #define SFV2 10
1862 #define SFV3 11
1863 #define MFC 12
1864 #define MFF 13
1865 #define MFI 14
1866 #define MFR 15
1867 #define MFS 16
1868 #define MFV2 17
1869 #define MFV3 18
1870 #define IN_SFS 19
1871 #define IN_MFS 20
1872 #define IN_SFIMG 21
1873 
1874 #define FLEX_DEBUG
1875 //FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
1876 //extern char *yytext;
1877 #define yytext_ptr yytext
1878 
1879 #ifndef yytext_ptr
1880 //static void yy_flex_strncpy YY_PROTO(( char *, const char *, int ));
1881 #endif
1882 
1883 //static yy_state_type yy_get_previous_state YY_PROTO(( void ));
1884 //static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
1885 //static int yy_get_next_buffer YY_PROTO(( void ));
1886 //static void yy_fatal_error YY_PROTO(( const char msg[] ));
1887 
1888 /* Done after the current pattern has been matched and before the
1889  * corresponding action - sets up yytext.
1890  */
1891 #define YY_DO_BEFORE_ACTION \
1892  do { \
1893  yytext_ptr = yy_bp; \
1894  yyleng = yy_cp - yy_bp; \
1895  yy_hold_char = *yy_cp; \
1896  *yy_cp = '\0'; \
1897  yy_c_buf_p = yy_cp; \
1898  } while (false)
1899 
1900 #define YY_END_OF_BUFFER 50
1901 static const short int yy_accept[949] =
1902 { 0,
1903  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1904  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1905  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1906  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1907  0, 0, 0, 0, 50, 48, 46, 47, 46, 14,
1908  46, 14, 14, 14, 14, 14, 14, 14, 14, 14,
1909  14, 48, 48, 48, 48, 48, 48, 48, 48, 25,
1910  48, 48, 48, 48, 23, 23, 48, 48, 48, 38,
1911  36, 38, 38, 48, 48, 35, 48, 48, 48, 48,
1912  48, 48, 48, 48, 48, 48, 19, 20, 48, 48,
1913 
1914  26, 17, 48, 24, 24, 18, 48, 48, 48, 39,
1915  37, 39, 39, 48, 48, 48, 48, 48, 48, 41,
1916  41, 42, 41, 41, 43, 48, 45, 45, 46, 47,
1917  46, 47, 47, 46, 46, 46, 46, 14, 14, 14,
1918  7, 14, 14, 14, 6, 14, 14, 14, 14, 0,
1919  15, 0, 0, 0, 0, 0, 0, 0, 0, 25,
1920  25, 0, 0, 0, 0, 0, 23, 23, 0, 0,
1921  0, 0, 0, 0, 38, 38, 38, 15, 0, 35,
1922  35, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1923  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1924 
1925  16, 0, 26, 26, 0, 24, 24, 0, 0, 0,
1926  0, 0, 0, 39, 39, 39, 16, 0, 0, 0,
1927  0, 0, 0, 0, 0, 0, 0, 0, 0, 41,
1928  41, 41, 41, 41, 41, 40, 45, 45, 47, 47,
1929  47, 46, 4, 14, 14, 14, 14, 5, 14, 14,
1930  14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1931  0, 0, 0, 0, 0, 25, 0, 44, 44, 0,
1932  0, 0, 0, 44, 44, 0, 23, 0, 0, 0,
1933  0, 0, 0, 0, 0, 0, 0, 0, 0, 35,
1934  0, 0, 27, 0, 0, 0, 0, 0, 27, 0,
1935 
1936  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1937  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1938  0, 0, 0, 0, 26, 24, 0, 0, 0, 0,
1939  0, 0, 0, 0, 0, 0, 0, 0, 0, 28,
1940  0, 0, 0, 0, 0, 28, 0, 0, 0, 0,
1941  0, 0, 0, 0, 0, 0, 0, 0, 0, 45,
1942  46, 14, 9, 14, 14, 14, 14, 14, 0, 21,
1943  0, 0, 0, 0, 0, 0, 0, 0, 44, 44,
1944  0, 0, 0, 0, 0, 0, 0, 0, 27, 0,
1945  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1946 
1947  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1948  0, 0, 0, 0, 0, 28, 0, 0, 0, 0,
1949  0, 0, 0, 0, 0, 0, 46, 14, 2, 8,
1950  14, 14, 12, 22, 0, 0, 33, 0, 0, 0,
1951  0, 0, 33, 0, 0, 0, 0, 33, 0, 0,
1952  0, 33, 0, 0, 0, 0, 0, 33, 0, 0,
1953  0, 44, 44, 44, 44, 0, 0, 0, 0, 0,
1954  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1955  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1956  0, 0, 0, 27, 0, 0, 27, 0, 0, 29,
1957 
1958  0, 0, 0, 0, 0, 29, 0, 0, 0, 0,
1959  29, 0, 0, 0, 29, 0, 0, 0, 0, 0,
1960  29, 0, 0, 0, 0, 0, 34, 0, 0, 0,
1961  0, 0, 34, 0, 0, 0, 0, 34, 0, 0,
1962  0, 34, 0, 0, 0, 0, 0, 34, 0, 0,
1963  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1964  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1965  0, 0, 0, 0, 0, 0, 0, 0, 0, 28,
1966  0, 0, 28, 0, 0, 30, 0, 0, 0, 0,
1967  0, 30, 0, 0, 0, 0, 30, 0, 0, 0,
1968 
1969  30, 0, 0, 0, 0, 0, 30, 0, 0, 0,
1970  46, 14, 14, 14, 14, 33, 0, 0, 33, 0,
1971  33, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1972  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1973  0, 0, 29, 0, 0, 29, 0, 29, 0, 0,
1974  34, 0, 0, 34, 0, 34, 0, 0, 0, 0,
1975  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1976  0, 0, 0, 0, 0, 0, 0, 30, 0, 0,
1977  30, 0, 30, 0, 0, 46, 14, 10, 14, 14,
1978  0, 33, 0, 0, 33, 0, 0, 33, 0, 33,
1979 
1980  0, 0, 33, 0, 0, 31, 0, 0, 0, 0,
1981  0, 31, 0, 0, 0, 0, 31, 0, 0, 31,
1982  0, 0, 0, 0, 0, 31, 0, 0, 0, 0,
1983  0, 31, 0, 0, 0, 31, 0, 0, 0, 0,
1984  0, 31, 0, 0, 0, 0, 0, 0, 0, 31,
1985  0, 0, 0, 0, 29, 0, 0, 29, 0, 0,
1986  29, 0, 29, 0, 0, 29, 0, 34, 0, 0,
1987  34, 0, 0, 34, 0, 34, 0, 0, 34, 0,
1988  0, 32, 0, 0, 0, 0, 0, 32, 0, 0,
1989  0, 0, 32, 0, 0, 32, 0, 0, 0, 0,
1990 
1991  0, 32, 0, 0, 0, 0, 0, 32, 0, 0,
1992  0, 32, 0, 0, 0, 0, 0, 32, 0, 0,
1993  0, 0, 0, 0, 0, 32, 0, 0, 0, 0,
1994  30, 0, 0, 30, 0, 0, 30, 0, 30, 0,
1995  0, 30, 46, 14, 11, 14, 31, 0, 0, 31,
1996  0, 31, 0, 0, 31, 0, 31, 0, 0, 31,
1997  0, 32, 0, 0, 32, 0, 32, 0, 0, 32,
1998  0, 32, 0, 0, 32, 0, 46, 14, 14, 0,
1999  31, 0, 0, 31, 0, 0, 31, 0, 31, 0,
2000  0, 31, 0, 0, 31, 0, 31, 0, 0, 31,
2001 
2002  0, 0, 31, 0, 32, 0, 0, 32, 0, 0,
2003  32, 0, 32, 0, 0, 32, 0, 0, 32, 0,
2004  32, 0, 0, 32, 0, 0, 32, 46, 14, 14,
2005  46, 3, 14, 46, 13, 46, 46, 46, 46, 46,
2006  1, 46, 1, 1, 1, 1, 1, 0
2007 } ;
2008 
2009 static const int yy_ec[256] =
2010 { 0,
2011  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
2012  1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
2013  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2014  1, 4, 5, 6, 7, 5, 5, 5, 1, 5,
2015  5, 5, 8, 2, 9, 10, 5, 11, 12, 13,
2016  12, 12, 12, 12, 12, 14, 12, 5, 5, 5,
2017  5, 5, 5, 5, 15, 16, 16, 17, 18, 19,
2018  5, 5, 20, 5, 5, 21, 22, 23, 24, 25,
2019  5, 26, 27, 28, 29, 30, 5, 31, 5, 5,
2020  32, 33, 34, 5, 5, 5, 16, 16, 16, 35,
2021 
2022  36, 37, 5, 5, 38, 5, 5, 39, 5, 40,
2023  41, 42, 5, 5, 43, 44, 45, 46, 5, 47,
2024  5, 5, 1, 5, 1, 5, 5, 5, 5, 5,
2025  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2026  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2027  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2028  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2029  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2030  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2031  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2032 
2033  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2034  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2035  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2036  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2037  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
2038  5, 5, 5, 5, 5
2039 } ;
2040 
2041 static const int yy_meta[48] =
2042 { 0,
2043  1, 2, 3, 2, 4, 5, 6, 4, 4, 1,
2044  7, 7, 7, 7, 7, 7, 7, 7, 7, 4,
2045  4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2046  4, 8, 1, 8, 7, 7, 7, 4, 4, 4,
2047  4, 4, 4, 4, 4, 4, 4
2048 } ;
2049 
2050 static const short int yy_base[1090] =
2051 { 0,
2052  0, 6, 13, 0, 59, 65, 92, 0, 104, 110,
2053  116, 122, 128, 134, 140, 146, 159, 165, 164, 177,
2054  183, 189, 195, 201, 207, 233, 259, 285, 311, 337,
2055  363, 389, 422, 455, 481, 507, 533, 559, 222, 228,
2056  256, 274, 324, 350, 787, 7663, 73, 79, 280, 0,
2057  247, 768, 753, 751, 745, 726, 725, 719, 715, 18,
2058  685, 702, 687, 682, 78, 96, 592, 170, 289, 368,
2059  300, 627, 51, 315, 380, 328, 342, 354, 673, 0,
2060  7663, 410, 677, 420, 376, 427, 436, 394, 708, 454,
2061  458, 743, 466, 470, 778, 676, 7663, 7663, 486, 491,
2062 
2063  496, 7663, 511, 517, 522, 7663, 544, 538, 813, 0,
2064  7663, 579, 665, 549, 563, 848, 604, 576, 883, 0,
2065  605, 7663, 617, 672, 7663, 631, 635, 639, 652, 302,
2066  658, 665, 666, 686, 692, 698, 725, 0, 652, 636,
2067  0, 636, 613, 607, 0, 617, 597, 590, 591, 605,
2068  7663, 596, 722, 0, 727, 918, 931, 751, 755, 792,
2069  759, 821, 0, 944, 957, 805, 786, 0, 825, 0,
2070  830, 970, 983, 856, 0, 869, 875, 0, 834, 900,
2071  987, 891, 895, 0, 996, 1022, 1035, 1003, 1007, 0,
2072  1040, 1053, 1066, 1073, 1077, 0, 1082, 1095, 1108, 1115,
2073 
2074  7663, 1119, 1124, 1132, 1140, 1144, 0, 1150, 0, 1159,
2075  1172, 1185, 1192, 0, 1205, 1211, 0, 1208, 0, 1213,
2076  1244, 1257, 1220, 1261, 1274, 1283, 1309, 1322, 1290, 0,
2077  1335, 1341, 1347, 1353, 1359, 7663, 1294, 0, 1234, 1365,
2078  1366, 1372, 0, 604, 580, 572, 569, 0, 552, 537,
2079  501, 511, 519, 1370, 1374, 1393, 1428, 1441, 0, 0,
2080  0, 1410, 1378, 1454, 1407, 1411, 1458, 1462, 1466, 1508,
2081  1521, 1534, 1547, 1560, 191, 1479, 0, 1477, 1483, 1606,
2082  1641, 1654, 0, 0, 0, 1575, 1487, 1667, 1491, 1572,
2083  1584, 1576, 1623, 1680, 0, 0, 0, 0, 230, 1588,
2084 
2085  1693, 1615, 1592, 1706, 1741, 0, 0, 0, 0, 1723,
2086  1720, 1758, 1725, 1762, 1775, 1810, 0, 0, 0, 0,
2087  1792, 1789, 1827, 1793, 1831, 0, 1836, 1840, 1853, 1888,
2088  0, 0, 0, 0, 1870, 1867, 1905, 1872, 1909, 1914,
2089  1949, 0, 0, 0, 0, 238, 1922, 1962, 1927, 1931,
2090  1975, 2010, 0, 0, 0, 0, 1992, 1935, 2027, 0,
2091  2040, 500, 0, 488, 493, 444, 443, 450, 456, 7663,
2092  1990, 2060, 2073, 2037, 2086, 2099, 2112, 2044, 0, 2116,
2093  1995, 2162, 2175, 2128, 2188, 2201, 2214, 2227, 2132, 2146,
2094  2240, 2253, 2288, 2301, 2261, 2314, 2327, 2340, 2353, 2366,
2095 
2096  2401, 2414, 2268, 2427, 2440, 2453, 2466, 2479, 2514, 2527,
2097  2374, 2540, 2553, 2566, 2579, 2383, 2487, 2592, 2605, 2640,
2098  2653, 2494, 2666, 2679, 2692, 2705, 2281, 437, 0, 0,
2099  50, 386, 0, 7663, 2379, 2498, 2622, 2718, 2731, 0,
2100  0, 0, 239, 2613, 2744, 2757, 2770, 2783, 2818, 2792,
2101  2617, 2831, 2866, 0, 0, 0, 0, 272, 2796, 2800,
2102  2845, 0, 2881, 205, 285, 2840, 2804, 2927, 2962, 2975,
2103  0, 0, 0, 2944, 2941, 2988, 3001, 3014, 3027, 3062,
2104  2946, 3035, 3075, 3110, 0, 0, 0, 0, 3092, 3039,
2105  3043, 3127, 3047, 3089, 3162, 3175, 400, 3094, 3135, 3144,
2106 
2107  3188, 3201, 0, 0, 0, 417, 3139, 3214, 3227, 3240,
2108  3253, 3288, 3262, 3266, 3301, 3336, 0, 0, 0, 0,
2109  437, 3270, 3274, 3315, 3310, 3341, 3346, 3381, 3394, 0,
2110  0, 0, 548, 3354, 3407, 3420, 3433, 3446, 3481, 3359,
2111  3363, 3494, 3529, 0, 0, 0, 0, 562, 3367, 3454,
2112  3463, 3503, 3458, 3542, 3577, 3590, 0, 0, 0, 3559,
2113  3507, 3603, 3616, 3629, 3642, 3677, 3512, 3556, 3690, 3725,
2114  0, 0, 0, 0, 3659, 3560, 3656, 3738, 3660, 3698,
2115  3773, 3786, 645, 3703, 3707, 3755, 3799, 3812, 0, 0,
2116  0, 661, 3711, 3825, 3838, 3851, 3864, 3899, 3747, 3872,
2117 
2118  3912, 3947, 0, 0, 0, 0, 680, 3876, 3880, 3926,
2119  3925, 390, 370, 351, 323, 3952, 3960, 3987, 4000, 4035,
2120  4048, 3967, 4083, 4096, 4131, 4144, 4008, 4157, 4170, 4183,
2121  4196, 4209, 4244, 4257, 4270, 4283, 4296, 4331, 4015, 4344,
2122  4357, 4370, 4065, 4056, 4383, 4396, 4431, 4444, 4104, 4479,
2123  4113, 4217, 4492, 4505, 4540, 4553, 4224, 4588, 4601, 4636,
2124  4649, 4304, 4662, 4675, 4688, 4701, 4714, 4749, 4762, 4775,
2125  4788, 4801, 4836, 4311, 4849, 4862, 4875, 4413, 4404, 4888,
2126  4901, 4936, 4949, 4452, 4984, 2858, 304, 0, 274, 296,
2127  3884, 3971, 4997, 5010, 688, 5023, 5036, 4522, 4019, 5049,
2128 
2129  5062, 5075, 689, 4061, 4108, 4461, 5088, 5101, 0, 0,
2130  0, 695, 4228, 5114, 5127, 5140, 5153, 4316, 4408, 5188,
2131  5223, 5236, 0, 0, 0, 712, 4456, 4519, 4570, 5249,
2132  5262, 5275, 5310, 4524, 4561, 5323, 5358, 0, 0, 0,
2133  0, 740, 4565, 4609, 4618, 4613, 5371, 5384, 5397, 5410,
2134  4722, 4726, 4731, 4809, 4813, 5445, 5458, 757, 5471, 5484,
2135  4918, 4817, 5497, 5510, 5523, 765, 4821, 4915, 5536, 5549,
2136  838, 5562, 5575, 4966, 4919, 5588, 5601, 5614, 862, 4964,
2137  4968, 5167, 5627, 5640, 0, 0, 0, 931, 5161, 5653,
2138  5666, 5679, 5692, 5197, 5201, 5727, 5762, 5775, 0, 0,
2139 
2140  0, 986, 5205, 5209, 5292, 5788, 5801, 5814, 5849, 5284,
2141  5331, 5862, 5897, 0, 0, 0, 0, 1022, 5335, 5339,
2142  5427, 5343, 5910, 5923, 5936, 5949, 5418, 5422, 5706, 5700,
2143  5735, 5984, 5997, 1023, 6010, 6023, 5831, 5739, 6036, 6049,
2144  6062, 1025, 5752, 268, 0, 250, 5879, 5828, 6075, 6088,
2145  6123, 6136, 5870, 6171, 6184, 6219, 6232, 5957, 6267, 6280,
2146  6315, 5966, 6096, 6103, 5833, 6144, 5875, 6151, 6192, 5962,
2147  6199, 6108, 6240, 6247, 6156, 6288, 6301, 236, 204, 6203,
2148  6251, 6328, 0, 1065, 3, 277, 6341, 6340, 6376, 6389,
2149  0, 1123, 376, 411, 6402, 6344, 6437, 6450, 0, 1129,
2150 
2151  435, 443, 6463, 6349, 6353, 6357, 6361, 6401, 6410, 6414,
2152  6464, 6418, 6499, 6422, 6472, 6478, 6504, 6508, 6513, 6521,
2153  6525, 6529, 6533, 6539, 6547, 6551, 6556, 3328, 213, 194,
2154  6569, 0, 188, 6575, 0, 6491, 3939, 5180, 5719, 6307,
2155  6579, 6586, 6592, 6593, 6599, 6600, 6606, 7663, 6619, 6627,
2156  6635, 6643, 6651, 6656, 6663, 6671, 6679, 6686, 6694, 6702,
2157  6710, 6718, 6726, 6733, 163, 6740, 6748, 6756, 6764, 157,
2158  6772, 6780, 6788, 6796, 6804, 104, 6812, 6820, 6825, 6832,
2159  6840, 6847, 93, 6854, 90, 6862, 6870, 66, 6878, 6886,
2160  6894, 6902, 6910, 6918, 6926, 6934, 6942, 6950, 6958, 6966,
2161 
2162  6974, 6982, 6990, 6998, 7006, 7011, 7018, 7026, 7034, 64,
2163  7042, 7050, 7058, 7066, 7074, 7082, 7090, 7098, 7106, 7114,
2164  7122, 7130, 7138, 7146, 7154, 7162, 7170, 7178, 7183, 7190,
2165  7198, 7206, 7214, 7222, 7230, 7238, 7246, 7254, 7262, 7270,
2166  7278, 7286, 7294, 7302, 7310, 7318, 7326, 7334, 7342, 7350,
2167  7358, 7366, 7374, 7382, 7387, 7394, 7402, 7410, 7418, 7426,
2168  7434, 7442, 7450, 7458, 7466, 7474, 7482, 7490, 7498, 7506,
2169  7514, 7522, 7530, 7538, 7546, 7554, 7562, 7570, 7578, 7586,
2170  7591, 7598, 7606, 7614, 7622, 7630, 7638, 7646, 7654
2171 } ;
2172 
2173 static const short int yy_def[1090] =
2174 { 0,
2175  949, 949, 948, 3, 949, 949, 949, 7, 7, 7,
2176  7, 7, 7, 7, 7, 7, 950, 950, 7, 7,
2177  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2178  7, 7, 951, 951, 7, 7, 7, 7, 952, 952,
2179  952, 952, 7, 7, 948, 948, 948, 948, 953, 954,
2180  953, 954, 954, 954, 954, 954, 954, 954, 954, 954,
2181  954, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2182  948, 948, 72, 948, 948, 948, 948, 948, 948, 955,
2183  948, 956, 955, 948, 948, 948, 948, 948, 948, 948,
2184  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2185 
2186  948, 948, 948, 948, 948, 948, 948, 948, 948, 957,
2187  948, 958, 957, 948, 948, 948, 948, 948, 948, 959,
2188  959, 948, 960, 959, 948, 948, 948, 948, 948, 948,
2189  953, 948, 961, 953, 953, 953, 953, 954, 954, 954,
2190  954, 954, 954, 954, 954, 954, 954, 954, 954, 948,
2191  948, 948, 948, 67, 67, 948, 962, 948, 948, 948,
2192  948, 948, 73, 948, 963, 964, 948, 965, 948, 79,
2193  79, 948, 966, 948, 955, 956, 956, 955, 948, 948,
2194  948, 948, 948, 89, 89, 948, 967, 948, 948, 92,
2195  92, 948, 968, 948, 948, 95, 95, 948, 969, 948,
2196 
2197  948, 948, 948, 948, 948, 948, 970, 948, 109, 109,
2198  948, 971, 948, 957, 958, 958, 957, 948, 116, 116,
2199  948, 972, 948, 948, 948, 225, 948, 973, 948, 974,
2200  974, 975, 975, 975, 975, 948, 948, 976, 977, 977,
2201  977, 978, 979, 979, 979, 979, 979, 979, 979, 979,
2202  979, 948, 948, 948, 948, 948, 980, 980, 258, 258,
2203  258, 258, 948, 948, 948, 948, 948, 948, 948, 981,
2204  981, 981, 981, 981, 274, 982, 983, 948, 948, 948,
2205  984, 984, 282, 282, 282, 282, 948, 948, 948, 948,
2206  948, 948, 948, 967, 294, 294, 294, 294, 294, 948,
2207 
2208  948, 948, 948, 948, 968, 305, 305, 305, 305, 305,
2209  948, 948, 948, 948, 948, 969, 316, 316, 316, 316,
2210  316, 948, 948, 948, 948, 985, 948, 948, 948, 971,
2211  330, 330, 330, 330, 330, 948, 948, 948, 948, 948,
2212  972, 341, 341, 341, 341, 341, 948, 948, 948, 948,
2213  948, 973, 352, 352, 352, 352, 352, 948, 948, 976,
2214  978, 979, 979, 979, 979, 979, 979, 979, 948, 948,
2215  256, 948, 986, 948, 258, 948, 987, 258, 988, 274,
2216  280, 948, 989, 948, 282, 948, 990, 385, 948, 948,
2217  991, 948, 948, 992, 948, 993, 948, 994, 993, 948,
2218 
2219  948, 995, 948, 996, 948, 997, 996, 948, 948, 998,
2220  948, 999, 948, 1000, 999, 948, 948, 1001, 948, 948,
2221  1002, 948, 1003, 948, 1004, 1003, 1005, 1006, 1006, 1006,
2222  1006, 1006, 1006, 948, 948, 948, 948, 1007, 1007, 439,
2223  439, 439, 439, 948, 948, 1008, 1008, 447, 1009, 948,
2224  948, 948, 1009, 453, 453, 453, 453, 453, 447, 447,
2225  448, 1010, 948, 463, 463, 948, 948, 948, 1011, 1011,
2226  470, 470, 470, 470, 948, 948, 1012, 1012, 478, 1013,
2227  948, 948, 948, 1013, 484, 484, 484, 484, 484, 478,
2228  478, 478, 948, 948, 1014, 1014, 496, 948, 948, 948,
2229 
2230  1015, 1015, 502, 502, 502, 502, 948, 948, 1016, 1016,
2231  510, 1017, 948, 948, 948, 1017, 516, 516, 516, 516,
2232  516, 510, 510, 511, 948, 948, 948, 1018, 1018, 529,
2233  529, 529, 529, 948, 948, 1019, 1019, 537, 1020, 948,
2234  948, 948, 1020, 543, 543, 543, 543, 543, 537, 537,
2235  538, 948, 948, 948, 1021, 1021, 556, 556, 556, 556,
2236  948, 948, 1022, 1022, 564, 1023, 948, 948, 948, 1023,
2237  570, 570, 570, 570, 570, 564, 564, 564, 948, 948,
2238  1024, 1024, 582, 948, 948, 948, 1025, 1025, 588, 588,
2239  588, 588, 948, 948, 1026, 1026, 596, 1027, 948, 948,
2240 
2241  948, 1027, 602, 602, 602, 602, 602, 596, 596, 597,
2242  1028, 1029, 1029, 1029, 1029, 948, 948, 1030, 1031, 1031,
2243  948, 948, 1032, 948, 948, 1033, 948, 1034, 948, 1035,
2244  1034, 1036, 1036, 948, 1037, 1036, 948, 1035, 948, 1038,
2245  1037, 1038, 948, 948, 1039, 1040, 1040, 948, 948, 1041,
2246  948, 948, 1042, 1043, 1043, 948, 948, 1044, 948, 948,
2247  1045, 948, 1046, 948, 1047, 1046, 1048, 1048, 948, 1049,
2248  1048, 948, 1047, 948, 1050, 1049, 1050, 948, 948, 1051,
2249  1052, 1052, 948, 948, 1053, 1054, 1055, 1055, 1055, 1055,
2250  948, 948, 1056, 1056, 694, 1057, 1057, 697, 948, 948,
2251 
2252  1058, 1058, 702, 948, 948, 948, 1059, 1059, 708, 708,
2253  708, 708, 948, 948, 1060, 1060, 716, 948, 948, 948,
2254  1061, 1061, 722, 722, 722, 722, 716, 716, 717, 1062,
2255  1062, 731, 1063, 948, 948, 948, 1063, 737, 737, 737,
2256  737, 737, 731, 731, 732, 948, 948, 1064, 1064, 749,
2257  749, 749, 750, 948, 948, 1065, 1065, 757, 1066, 1066,
2258  760, 948, 948, 1067, 1067, 765, 948, 948, 1068, 1068,
2259  770, 1069, 1069, 773, 948, 948, 1070, 1070, 778, 948,
2260  948, 948, 1071, 1071, 784, 784, 784, 784, 948, 948,
2261  1072, 1072, 792, 948, 948, 948, 1073, 1073, 798, 798,
2262 
2263  798, 798, 792, 792, 793, 1074, 1074, 807, 1075, 948,
2264  948, 948, 1075, 813, 813, 813, 813, 813, 807, 807,
2265  808, 948, 948, 1076, 1076, 825, 825, 825, 826, 948,
2266  948, 1077, 1077, 833, 1078, 1078, 836, 948, 948, 1079,
2267  1079, 841, 1080, 1081, 1081, 1081, 948, 948, 1082, 1083,
2268  1083, 948, 948, 1084, 1085, 1085, 948, 948, 1086, 1087,
2269  1087, 948, 948, 784, 793, 792, 796, 948, 798, 808,
2270  807, 812, 948, 813, 826, 825, 1080, 1081, 1081, 948,
2271  948, 1082, 882, 882, 851, 851, 851, 948, 948, 1084,
2272  890, 890, 856, 856, 856, 948, 948, 1086, 898, 898,
2273 
2274  861, 861, 861, 948, 948, 784, 784, 784, 792, 792,
2275  793, 948, 948, 798, 798, 798, 807, 807, 808, 948,
2276  823, 813, 813, 813, 825, 825, 826, 1080, 1081, 1081,
2277  1080, 1081, 1081, 1080, 1081, 1080, 1080, 1088, 1088, 1088,
2278  948, 1088, 948, 1089, 1089, 1089, 1089, 0, 948, 948,
2279  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2280  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2281  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2282  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2283  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2284 
2285  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2286  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2287  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2288  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2289  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2290  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2291  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2292  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
2293  948, 948, 948, 948, 948, 948, 948, 948, 948
2294 } ;
2295 
2296 static const short int yy_nxt[7711] =
2297 { 0,
2298  948, 47, 48, 47, 948, 948, 49, 47, 48, 47,
2299  469, 472, 49, 46, 47, 48, 47, 50, 46, 51,
2300  46, 46, 46, 46, 46, 46, 46, 50, 50, 52,
2301  53, 50, 54, 50, 50, 55, 50, 56, 57, 50,
2302  58, 59, 50, 50, 46, 46, 46, 50, 60, 61,
2303  50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
2304  47, 48, 47, 147, 148, 51, 47, 48, 47, 613,
2305  462, 51, 462, 614, 129, 130, 129, 62, 63, 131,
2306  132, 948, 132, 62, 63, 133, 64, 153, 154, 154,
2307  154, 154, 64, 47, 48, 47, 326, 948, 51, 277,
2308 
2309  65, 66, 67, 67, 67, 67, 155, 155, 155, 155,
2310  360, 63, 68, 69, 70, 70, 70, 70, 68, 69,
2311  70, 70, 70, 70, 71, 46, 72, 73, 73, 73,
2312  71, 46, 72, 73, 73, 73, 74, 46, 75, 76,
2313  76, 76, 74, 46, 75, 76, 76, 76, 77, 78,
2314  79, 79, 79, 79, 77, 78, 79, 79, 79, 79,
2315  47, 48, 47, 326, 81, 82, 47, 48, 47, 277,
2316  81, 82, 84, 85, 86, 86, 86, 86, 83, 159,
2317  160, 160, 160, 160, 83, 84, 85, 86, 86, 86,
2318  86, 87, 88, 89, 89, 89, 89, 87, 88, 89,
2319 
2320  89, 89, 89, 90, 91, 92, 92, 92, 92, 90,
2321  91, 92, 92, 92, 92, 93, 94, 95, 95, 95,
2322  95, 270, 935, 121, 48, 121, 96, 122, 123, 121,
2323  48, 121, 933, 122, 123, 270, 932, 270, 97, 930,
2324  98, 93, 94, 95, 95, 95, 95, 391, 135, 130,
2325  135, 270, 96, 136, 124, 418, 618, 121, 48, 121,
2326  124, 125, 123, 929, 97, 391, 98, 99, 100, 101,
2327  101, 101, 101, 418, 618, 121, 48, 121, 96, 125,
2328  123, 135, 130, 135, 469, 472, 136, 879, 124, 623,
2329  102, 878, 98, 99, 100, 101, 101, 101, 101, 161,
2330 
2331  161, 161, 161, 132, 96, 132, 124, 623, 133, 137,
2332  163, 163, 163, 163, 846, 270, 102, 845, 98, 103,
2333  46, 104, 105, 105, 105, 167, 167, 167, 167, 844,
2334  96, 270, 126, 46, 127, 128, 128, 128, 167, 167,
2335  167, 167, 106, 46, 98, 103, 46, 104, 105, 105,
2336  105, 169, 170, 170, 170, 170, 96, 690, 126, 46,
2337  127, 128, 128, 128, 171, 171, 171, 171, 106, 46,
2338  98, 107, 108, 109, 109, 109, 109, 159, 160, 160,
2339  160, 160, 96, 281, 284, 162, 181, 181, 181, 181,
2340  167, 167, 167, 167, 102, 689, 98, 107, 108, 109,
2341 
2342  109, 109, 109, 162, 185, 185, 185, 185, 96, 688,
2343  168, 135, 130, 135, 687, 134, 177, 391, 281, 284,
2344  102, 615, 98, 47, 48, 47, 168, 111, 112, 179,
2345  180, 180, 180, 180, 645, 391, 179, 180, 180, 180,
2346  180, 113, 484, 487, 182, 183, 184, 184, 184, 184,
2347  484, 487, 645, 102, 650, 98, 47, 48, 47, 612,
2348  111, 112, 182, 189, 190, 190, 190, 190, 191, 191,
2349  191, 191, 650, 434, 113, 195, 196, 196, 196, 196,
2350  197, 197, 197, 197, 433, 432, 102, 431, 98, 114,
2351  115, 116, 116, 116, 116, 202, 203, 203, 203, 203,
2352 
2353  96, 204, 204, 204, 204, 202, 203, 203, 203, 203,
2354  430, 429, 102, 205, 98, 114, 115, 116, 116, 116,
2355  116, 206, 206, 206, 206, 428, 96, 206, 206, 206,
2356  206, 205, 206, 206, 206, 206, 370, 369, 102, 368,
2357  98, 117, 118, 119, 119, 119, 119, 207, 210, 210,
2358  210, 210, 96, 208, 209, 209, 209, 209, 218, 219,
2359  219, 219, 219, 207, 97, 653, 98, 117, 118, 119,
2360  119, 119, 119, 220, 220, 220, 220, 367, 96, 658,
2361  135, 130, 135, 653, 134, 216, 226, 226, 226, 226,
2362  97, 366, 98, 156, 156, 156, 365, 658, 157, 364,
2363 
2364  363, 153, 154, 154, 154, 154, 231, 130, 231, 158,
2365  134, 232, 134, 224, 225, 225, 225, 225, 234, 130,
2366  234, 362, 134, 235, 253, 252, 251, 158, 164, 164,
2367  164, 250, 249, 165, 248, 247, 246, 163, 163, 163,
2368  163, 237, 237, 237, 237, 237, 237, 237, 237, 237,
2369  237, 237, 237, 129, 130, 129, 245, 166, 131, 135,
2370  130, 135, 418, 244, 136, 238, 132, 240, 132, 240,
2371  243, 133, 241, 166, 172, 172, 172, 236, 680, 173,
2372  418, 238, 169, 170, 170, 170, 170, 135, 130, 135,
2373  174, 217, 136, 135, 130, 135, 680, 685, 136, 135,
2374 
2375  130, 135, 201, 178, 136, 618, 623, 152, 174, 186,
2376  186, 186, 849, 151, 187, 685, 150, 183, 184, 184,
2377  184, 184, 149, 618, 623, 188, 135, 130, 135, 854,
2378  849, 136, 155, 155, 155, 155, 948, 155, 155, 155,
2379  155, 146, 145, 188, 192, 192, 192, 854, 144, 193,
2380  242, 143, 189, 190, 190, 190, 190, 859, 263, 263,
2381  194, 264, 264, 264, 264, 161, 161, 161, 161, 161,
2382  161, 161, 161, 142, 645, 859, 162, 141, 194, 198,
2383  198, 198, 650, 140, 199, 139, 948, 195, 196, 196,
2384  196, 196, 645, 948, 162, 200, 167, 167, 167, 167,
2385 
2386  650, 159, 160, 160, 160, 160, 164, 164, 164, 162,
2387  948, 165, 948, 200, 211, 211, 211, 948, 948, 212,
2388  948, 948, 208, 209, 209, 209, 209, 162, 265, 265,
2389  213, 266, 266, 266, 266, 171, 171, 171, 171, 948,
2390  171, 171, 171, 171, 181, 181, 181, 181, 213, 221,
2391  221, 221, 948, 948, 222, 653, 948, 218, 219, 219,
2392  219, 219, 948, 287, 287, 223, 288, 288, 288, 288,
2393  135, 130, 135, 653, 134, 177, 135, 130, 135, 658,
2394  134, 177, 948, 223, 227, 227, 227, 948, 948, 228,
2395  948, 948, 224, 225, 225, 225, 225, 658, 289, 289,
2396 
2397  229, 290, 290, 290, 290, 185, 185, 185, 185, 179,
2398  180, 180, 180, 180, 948, 948, 948, 182, 229, 156,
2399  156, 156, 948, 948, 157, 948, 254, 255, 256, 256,
2400  256, 256, 258, 156, 258, 182, 948, 259, 948, 260,
2401  261, 262, 262, 262, 262, 164, 164, 164, 864, 948,
2402  165, 948, 267, 948, 268, 269, 269, 269, 271, 164,
2403  271, 948, 948, 272, 948, 273, 864, 274, 275, 275,
2404  275, 172, 172, 172, 948, 948, 173, 948, 278, 279,
2405  280, 280, 280, 280, 282, 172, 282, 948, 948, 283,
2406  948, 284, 285, 286, 286, 286, 286, 181, 181, 181,
2407 
2408  181, 948, 948, 869, 182, 948, 185, 185, 185, 185,
2409  300, 300, 948, 301, 301, 301, 301, 191, 191, 191,
2410  191, 869, 182, 186, 186, 186, 948, 948, 187, 948,
2411  291, 292, 293, 293, 293, 293, 295, 186, 295, 874,
2412  680, 296, 685, 297, 298, 299, 299, 299, 299, 948,
2413  191, 191, 191, 191, 192, 192, 192, 874, 680, 193,
2414  685, 302, 303, 304, 304, 304, 304, 306, 192, 306,
2415  948, 948, 307, 948, 308, 309, 310, 310, 310, 310,
2416  311, 311, 849, 312, 312, 312, 312, 197, 197, 197,
2417  197, 948, 197, 197, 197, 197, 198, 198, 198, 948,
2418 
2419  849, 199, 948, 313, 314, 315, 315, 315, 315, 317,
2420  198, 317, 948, 948, 318, 948, 319, 320, 321, 321,
2421  321, 321, 322, 322, 948, 323, 323, 323, 323, 204,
2422  204, 204, 204, 202, 203, 203, 203, 203, 948, 948,
2423  854, 205, 204, 204, 204, 204, 859, 324, 324, 205,
2424  325, 325, 325, 325, 206, 206, 206, 206, 854, 205,
2425  210, 210, 210, 210, 859, 948, 948, 205, 948, 210,
2426  210, 210, 210, 211, 211, 211, 948, 948, 212, 948,
2427  327, 328, 329, 329, 329, 329, 331, 211, 331, 948,
2428  948, 332, 948, 333, 334, 335, 335, 335, 335, 336,
2429 
2430  336, 948, 337, 337, 337, 337, 135, 130, 135, 948,
2431  134, 216, 135, 130, 135, 948, 134, 216, 220, 220,
2432  220, 220, 948, 220, 220, 220, 220, 347, 347, 948,
2433  348, 348, 348, 348, 948, 240, 134, 240, 134, 948,
2434  241, 948, 134, 948, 134, 221, 221, 221, 948, 948,
2435  222, 948, 338, 339, 340, 340, 340, 340, 342, 221,
2436  342, 948, 948, 343, 948, 344, 345, 346, 346, 346,
2437  346, 226, 226, 226, 226, 227, 227, 227, 948, 948,
2438  228, 948, 948, 224, 225, 225, 225, 225, 948, 948,
2439  948, 229, 948, 226, 226, 226, 226, 358, 358, 948,
2440 
2441  359, 359, 359, 359, 237, 237, 237, 237, 948, 229,
2442  227, 227, 227, 948, 948, 228, 948, 349, 350, 351,
2443  351, 351, 351, 353, 227, 353, 948, 948, 354, 948,
2444  355, 356, 357, 357, 357, 357, 231, 130, 231, 948,
2445  948, 232, 234, 130, 234, 948, 134, 235, 234, 130,
2446  234, 948, 134, 235, 234, 130, 234, 948, 134, 235,
2447  234, 130, 234, 948, 134, 235, 240, 240, 240, 240,
2448  948, 241, 241, 135, 130, 135, 948, 948, 136, 255,
2449  256, 256, 256, 256, 371, 371, 371, 371, 264, 264,
2450  264, 264, 948, 361, 372, 372, 372, 948, 948, 373,
2451 
2452  948, 948, 255, 256, 256, 256, 256, 948, 948, 948,
2453  374, 375, 376, 375, 948, 948, 377, 266, 266, 266,
2454  266, 266, 266, 266, 266, 948, 948, 378, 374, 258,
2455  156, 258, 948, 948, 259, 948, 260, 261, 262, 262,
2456  262, 262, 258, 156, 258, 378, 948, 259, 948, 260,
2457  261, 262, 262, 262, 262, 156, 156, 156, 948, 948,
2458  157, 948, 948, 948, 264, 264, 264, 264, 269, 269,
2459  269, 269, 269, 269, 269, 269, 269, 269, 269, 269,
2460  164, 164, 164, 948, 948, 165, 279, 280, 280, 280,
2461  280, 948, 379, 381, 381, 381, 381, 288, 288, 288,
2462 
2463  288, 290, 290, 290, 290, 948, 948, 948, 379, 271,
2464  164, 271, 948, 948, 272, 948, 273, 948, 274, 275,
2465  275, 275, 271, 164, 271, 948, 948, 272, 948, 273,
2466  948, 274, 275, 275, 275, 271, 164, 271, 948, 948,
2467  272, 948, 273, 948, 274, 275, 275, 275, 271, 164,
2468  271, 948, 948, 272, 948, 273, 948, 274, 275, 275,
2469  275, 271, 164, 271, 948, 948, 272, 948, 273, 948,
2470  274, 275, 275, 275, 948, 948, 385, 386, 385, 948,
2471  948, 387, 290, 290, 290, 290, 389, 389, 389, 389,
2472  380, 948, 388, 292, 293, 293, 293, 293, 301, 301,
2473 
2474  301, 301, 392, 392, 392, 392, 380, 382, 382, 382,
2475  388, 948, 383, 948, 948, 279, 280, 280, 280, 280,
2476  948, 948, 948, 384, 303, 304, 304, 304, 304, 948,
2477  948, 948, 292, 293, 293, 293, 293, 948, 948, 948,
2478  390, 384, 282, 172, 282, 948, 948, 283, 948, 284,
2479  285, 286, 286, 286, 286, 282, 172, 282, 390, 948,
2480  283, 948, 284, 285, 286, 286, 286, 286, 172, 172,
2481  172, 948, 948, 173, 948, 948, 948, 288, 288, 288,
2482  288, 295, 186, 295, 948, 948, 296, 948, 297, 298,
2483  299, 299, 299, 299, 186, 186, 186, 948, 948, 187,
2484 
2485  948, 948, 948, 301, 301, 301, 301, 393, 393, 393,
2486  948, 948, 394, 948, 948, 303, 304, 304, 304, 304,
2487  948, 948, 948, 395, 396, 397, 396, 948, 948, 398,
2488  312, 312, 312, 312, 314, 315, 315, 315, 315, 948,
2489  399, 395, 306, 192, 306, 948, 948, 307, 948, 308,
2490  309, 310, 310, 310, 310, 948, 948, 948, 399, 192,
2491  192, 192, 948, 948, 193, 948, 948, 948, 312, 312,
2492  312, 312, 400, 400, 400, 400, 401, 401, 401, 948,
2493  948, 402, 948, 948, 314, 315, 315, 315, 315, 948,
2494  948, 948, 403, 404, 405, 404, 948, 948, 406, 323,
2495 
2496  323, 323, 323, 325, 325, 325, 325, 948, 948, 407,
2497  403, 317, 198, 317, 948, 948, 318, 948, 319, 320,
2498  321, 321, 321, 321, 948, 948, 948, 407, 198, 198,
2499  198, 948, 948, 199, 948, 948, 948, 323, 323, 323,
2500  323, 325, 325, 325, 325, 328, 329, 329, 329, 329,
2501  408, 408, 408, 408, 409, 409, 409, 948, 948, 410,
2502  948, 948, 328, 329, 329, 329, 329, 948, 948, 948,
2503  411, 412, 413, 412, 948, 948, 414, 337, 337, 337,
2504  337, 339, 340, 340, 340, 340, 948, 415, 411, 331,
2505  211, 331, 948, 948, 332, 948, 333, 334, 335, 335,
2506 
2507  335, 335, 948, 948, 948, 415, 211, 211, 211, 948,
2508  948, 212, 948, 948, 948, 337, 337, 337, 337, 416,
2509  416, 416, 416, 339, 340, 340, 340, 340, 948, 948,
2510  948, 417, 348, 348, 348, 348, 350, 351, 351, 351,
2511  351, 419, 419, 419, 419, 359, 359, 359, 359, 417,
2512  342, 221, 342, 948, 948, 343, 948, 344, 345, 346,
2513  346, 346, 346, 221, 221, 221, 948, 948, 222, 948,
2514  948, 948, 348, 348, 348, 348, 420, 420, 420, 948,
2515  948, 421, 948, 948, 350, 351, 351, 351, 351, 948,
2516  948, 948, 422, 423, 424, 423, 948, 948, 425, 948,
2517 
2518  371, 371, 371, 371, 948, 381, 381, 381, 381, 426,
2519  422, 353, 227, 353, 948, 948, 354, 948, 355, 356,
2520  357, 357, 357, 357, 948, 948, 948, 426, 227, 227,
2521  227, 948, 948, 228, 948, 948, 948, 359, 359, 359,
2522  359, 135, 130, 135, 444, 444, 136, 445, 445, 445,
2523  445, 459, 460, 948, 461, 461, 461, 461, 948, 948,
2524  427, 372, 372, 372, 948, 948, 373, 948, 435, 436,
2525  437, 437, 437, 437, 439, 372, 439, 948, 948, 440,
2526  948, 441, 442, 443, 443, 443, 443, 375, 376, 375,
2527  948, 948, 377, 948, 446, 447, 448, 448, 448, 448,
2528 
2529  376, 376, 376, 948, 948, 449, 948, 450, 451, 452,
2530  452, 452, 452, 454, 376, 454, 948, 948, 455, 948,
2531  456, 457, 458, 458, 458, 458, 463, 464, 464, 464,
2532  465, 465, 465, 465, 465, 475, 475, 948, 476, 476,
2533  476, 476, 389, 389, 389, 389, 270, 948, 948, 390,
2534  465, 465, 465, 493, 493, 948, 494, 494, 494, 494,
2535  948, 948, 270, 382, 382, 382, 948, 390, 383, 948,
2536  466, 467, 468, 468, 468, 468, 470, 382, 470, 948,
2537  948, 471, 948, 472, 473, 474, 474, 474, 474, 385,
2538  386, 385, 948, 948, 387, 948, 477, 478, 479, 479,
2539 
2540  479, 479, 386, 386, 386, 948, 948, 480, 948, 481,
2541  482, 483, 483, 483, 483, 485, 386, 485, 948, 948,
2542  486, 948, 487, 488, 489, 489, 489, 489, 282, 172,
2543  282, 948, 948, 283, 490, 491, 285, 492, 492, 492,
2544  492, 295, 186, 295, 948, 948, 296, 495, 496, 298,
2545  497, 497, 497, 497, 393, 393, 393, 948, 948, 394,
2546  948, 948, 948, 392, 392, 392, 392, 948, 507, 507,
2547  395, 508, 508, 508, 508, 534, 534, 948, 535, 535,
2548  535, 535, 135, 130, 611, 948, 948, 136, 395, 393,
2549  393, 393, 948, 948, 394, 948, 498, 499, 500, 500,
2550 
2551  500, 500, 502, 393, 502, 948, 948, 503, 948, 504,
2552  505, 506, 506, 506, 506, 396, 397, 396, 948, 948,
2553  398, 948, 509, 510, 511, 511, 511, 511, 397, 397,
2554  397, 948, 948, 512, 948, 513, 514, 515, 515, 515,
2555  515, 517, 397, 517, 948, 948, 518, 948, 519, 520,
2556  521, 521, 521, 521, 306, 192, 306, 948, 948, 307,
2557  522, 523, 309, 524, 524, 524, 524, 401, 401, 401,
2558  948, 948, 402, 948, 948, 948, 400, 400, 400, 400,
2559  948, 561, 561, 403, 562, 562, 562, 562, 436, 437,
2560  437, 437, 437, 416, 416, 416, 416, 948, 948, 948,
2561 
2562  417, 403, 401, 401, 401, 948, 948, 402, 948, 525,
2563  526, 527, 527, 527, 527, 529, 401, 529, 417, 948,
2564  530, 948, 531, 532, 533, 533, 533, 533, 404, 405,
2565  404, 948, 948, 406, 948, 536, 537, 538, 538, 538,
2566  538, 405, 405, 405, 948, 948, 539, 948, 540, 541,
2567  542, 542, 542, 542, 544, 405, 544, 948, 948, 545,
2568  948, 546, 547, 548, 548, 548, 548, 317, 198, 317,
2569  948, 948, 318, 549, 550, 320, 551, 551, 551, 551,
2570  409, 409, 409, 948, 948, 410, 948, 948, 948, 408,
2571  408, 408, 408, 948, 579, 579, 411, 580, 580, 580,
2572 
2573  580, 593, 593, 948, 594, 594, 594, 594, 616, 616,
2574  616, 616, 948, 948, 411, 409, 409, 409, 948, 948,
2575  410, 948, 552, 553, 554, 554, 554, 554, 556, 409,
2576  556, 948, 948, 557, 948, 558, 559, 560, 560, 560,
2577  560, 412, 413, 412, 948, 948, 414, 948, 563, 564,
2578  565, 565, 565, 565, 413, 413, 413, 948, 948, 566,
2579  948, 567, 568, 569, 569, 569, 569, 571, 413, 571,
2580  948, 948, 572, 948, 573, 574, 575, 575, 575, 575,
2581  331, 211, 331, 948, 948, 332, 576, 577, 334, 578,
2582  578, 578, 578, 342, 221, 342, 948, 948, 343, 581,
2583 
2584  582, 345, 583, 583, 583, 583, 420, 420, 420, 948,
2585  948, 421, 948, 948, 948, 419, 419, 419, 419, 948,
2586  948, 948, 422, 445, 445, 445, 445, 621, 621, 621,
2587  621, 436, 437, 437, 437, 437, 948, 948, 948, 617,
2588  422, 420, 420, 420, 948, 948, 421, 948, 584, 585,
2589  586, 586, 586, 586, 588, 420, 588, 617, 948, 589,
2590  948, 590, 591, 592, 592, 592, 592, 423, 424, 423,
2591  948, 948, 425, 948, 595, 596, 597, 597, 597, 597,
2592  424, 424, 424, 948, 948, 598, 948, 599, 600, 601,
2593  601, 601, 601, 603, 424, 603, 948, 948, 604, 948,
2594 
2595  605, 606, 607, 607, 607, 607, 353, 227, 353, 948,
2596  948, 354, 608, 609, 356, 610, 610, 610, 610, 439,
2597  372, 439, 948, 948, 440, 948, 441, 442, 443, 443,
2598  443, 443, 439, 372, 439, 948, 948, 440, 948, 441,
2599  442, 443, 443, 443, 443, 372, 372, 372, 948, 948,
2600  373, 948, 948, 948, 445, 445, 445, 445, 258, 156,
2601  258, 948, 948, 259, 948, 260, 447, 448, 448, 448,
2602  448, 258, 156, 258, 948, 948, 259, 948, 260, 261,
2603  619, 619, 619, 619, 375, 376, 375, 948, 948, 377,
2604  948, 948, 447, 448, 448, 448, 448, 948, 948, 948,
2605 
2606  620, 451, 452, 452, 452, 452, 461, 461, 461, 461,
2607  461, 461, 461, 461, 624, 624, 624, 624, 620, 454,
2608  376, 454, 948, 948, 455, 948, 456, 457, 458, 458,
2609  458, 458, 372, 372, 372, 948, 948, 373, 948, 948,
2610  451, 452, 452, 452, 452, 948, 948, 948, 622, 467,
2611  468, 468, 468, 468, 261, 461, 461, 461, 461, 135,
2612  130, 135, 378, 948, 136, 948, 622, 454, 376, 454,
2613  843, 948, 455, 948, 456, 457, 458, 458, 458, 458,
2614  378, 270, 271, 164, 271, 270, 270, 272, 270, 273,
2615  270, 463, 464, 464, 464, 465, 465, 465, 465, 465,
2616 
2617  270, 270, 270, 270, 270, 270, 270, 270, 270, 270,
2618  270, 380, 270, 270, 270, 465, 465, 465, 270, 270,
2619  270, 270, 270, 270, 270, 270, 270, 380, 625, 625,
2620  625, 948, 948, 626, 948, 948, 467, 468, 468, 468,
2621  468, 948, 948, 948, 627, 628, 629, 628, 948, 948,
2622  630, 476, 476, 476, 476, 482, 483, 483, 483, 483,
2623  948, 631, 627, 470, 382, 470, 948, 948, 471, 948,
2624  472, 473, 474, 474, 474, 474, 470, 382, 470, 631,
2625  948, 471, 948, 472, 473, 474, 474, 474, 474, 382,
2626  382, 382, 948, 948, 383, 948, 948, 948, 476, 476,
2627 
2628  476, 476, 282, 172, 282, 948, 948, 283, 948, 284,
2629  478, 479, 479, 479, 479, 282, 172, 282, 948, 948,
2630  283, 948, 284, 285, 632, 632, 632, 632, 633, 634,
2631  633, 948, 948, 635, 948, 948, 478, 479, 479, 479,
2632  479, 948, 948, 948, 636, 637, 637, 637, 637, 492,
2633  492, 492, 492, 492, 492, 492, 492, 494, 494, 494,
2634  494, 948, 636, 485, 386, 485, 948, 948, 486, 948,
2635  487, 488, 489, 489, 489, 489, 629, 629, 629, 948,
2636  948, 638, 948, 948, 482, 483, 483, 483, 483, 948,
2637  948, 948, 639, 640, 634, 640, 948, 948, 641, 494,
2638 
2639  494, 494, 494, 499, 500, 500, 500, 500, 948, 642,
2640  639, 485, 386, 485, 948, 948, 486, 948, 487, 488,
2641  489, 489, 489, 489, 948, 948, 948, 642, 385, 386,
2642  385, 948, 948, 387, 948, 948, 948, 492, 492, 492,
2643  492, 948, 948, 948, 388, 643, 643, 643, 643, 508,
2644  508, 508, 508, 499, 500, 500, 500, 500, 948, 948,
2645  948, 644, 388, 295, 186, 295, 948, 948, 296, 948,
2646  297, 298, 497, 497, 497, 497, 295, 186, 295, 644,
2647  948, 296, 948, 297, 298, 497, 497, 497, 497, 502,
2648  393, 502, 948, 948, 503, 948, 504, 505, 506, 506,
2649 
2650  506, 506, 502, 393, 502, 948, 948, 503, 948, 504,
2651  505, 506, 506, 506, 506, 393, 393, 393, 948, 948,
2652  394, 948, 948, 948, 508, 508, 508, 508, 306, 192,
2653  306, 948, 948, 307, 948, 308, 510, 511, 511, 511,
2654  511, 306, 192, 306, 948, 948, 307, 948, 308, 309,
2655  646, 646, 646, 646, 396, 397, 396, 948, 948, 398,
2656  948, 948, 510, 511, 511, 511, 511, 948, 948, 948,
2657  647, 514, 515, 515, 515, 515, 648, 648, 648, 648,
2658  524, 524, 524, 524, 524, 524, 524, 524, 647, 517,
2659  397, 517, 948, 948, 518, 948, 519, 520, 521, 521,
2660 
2661  521, 521, 393, 393, 393, 948, 948, 394, 948, 948,
2662  514, 515, 515, 515, 515, 948, 948, 948, 649, 526,
2663  527, 527, 527, 527, 309, 524, 524, 524, 524, 135,
2664  130, 931, 399, 948, 136, 948, 649, 517, 397, 517,
2665  948, 948, 518, 948, 519, 520, 521, 521, 521, 521,
2666  399, 651, 651, 651, 651, 526, 527, 527, 527, 527,
2667  948, 948, 948, 652, 535, 535, 535, 535, 541, 542,
2668  542, 542, 542, 656, 656, 656, 656, 551, 551, 551,
2669  551, 652, 529, 401, 529, 948, 948, 530, 948, 531,
2670  532, 533, 533, 533, 533, 529, 401, 529, 948, 948,
2671 
2672  530, 948, 531, 532, 533, 533, 533, 533, 401, 401,
2673  401, 948, 948, 402, 948, 948, 948, 535, 535, 535,
2674  535, 317, 198, 317, 948, 948, 318, 948, 319, 537,
2675  538, 538, 538, 538, 317, 198, 317, 948, 948, 318,
2676  948, 319, 320, 654, 654, 654, 654, 404, 405, 404,
2677  948, 948, 406, 948, 948, 537, 538, 538, 538, 538,
2678  948, 948, 948, 655, 551, 551, 551, 551, 659, 659,
2679  659, 659, 320, 551, 551, 551, 551, 948, 948, 948,
2680  407, 655, 544, 405, 544, 948, 948, 545, 948, 546,
2681  547, 548, 548, 548, 548, 401, 401, 401, 407, 948,
2682 
2683  402, 948, 948, 541, 542, 542, 542, 542, 948, 948,
2684  948, 657, 553, 554, 554, 554, 554, 562, 562, 562,
2685  562, 568, 569, 569, 569, 569, 948, 948, 948, 657,
2686  544, 405, 544, 948, 948, 545, 948, 546, 547, 548,
2687  548, 548, 548, 660, 660, 660, 948, 948, 661, 948,
2688  948, 553, 554, 554, 554, 554, 948, 948, 948, 662,
2689  663, 664, 663, 948, 948, 665, 672, 672, 672, 672,
2690  578, 578, 578, 578, 948, 948, 666, 662, 556, 409,
2691  556, 948, 948, 557, 948, 558, 559, 560, 560, 560,
2692  560, 556, 409, 556, 666, 948, 557, 948, 558, 559,
2693 
2694  560, 560, 560, 560, 409, 409, 409, 948, 948, 410,
2695  948, 948, 948, 562, 562, 562, 562, 331, 211, 331,
2696  948, 948, 332, 948, 333, 564, 565, 565, 565, 565,
2697  331, 211, 331, 948, 948, 332, 948, 333, 334, 667,
2698  667, 667, 667, 668, 669, 668, 948, 948, 670, 948,
2699  948, 564, 565, 565, 565, 565, 948, 948, 948, 671,
2700  675, 669, 675, 948, 948, 676, 578, 578, 578, 578,
2701  580, 580, 580, 580, 948, 948, 677, 671, 571, 413,
2702  571, 948, 948, 572, 948, 573, 574, 575, 575, 575,
2703  575, 664, 664, 664, 677, 948, 673, 948, 948, 568,
2704 
2705  569, 569, 569, 569, 948, 948, 948, 674, 580, 580,
2706  580, 580, 585, 586, 586, 586, 586, 678, 678, 678,
2707  678, 594, 594, 594, 594, 674, 571, 413, 571, 948,
2708  948, 572, 948, 573, 574, 575, 575, 575, 575, 412,
2709  413, 412, 948, 948, 414, 948, 948, 948, 578, 578,
2710  578, 578, 948, 948, 948, 415, 600, 601, 601, 601,
2711  601, 948, 948, 948, 585, 586, 586, 586, 586, 948,
2712  948, 948, 679, 415, 342, 221, 342, 948, 948, 343,
2713  948, 344, 345, 583, 583, 583, 583, 342, 221, 342,
2714  679, 948, 343, 948, 344, 345, 583, 583, 583, 583,
2715 
2716  588, 420, 588, 948, 948, 589, 948, 590, 591, 592,
2717  592, 592, 592, 588, 420, 588, 948, 948, 589, 948,
2718  590, 591, 592, 592, 592, 592, 420, 420, 420, 948,
2719  948, 421, 948, 948, 948, 594, 594, 594, 594, 353,
2720  227, 353, 948, 948, 354, 948, 355, 596, 597, 597,
2721  597, 597, 353, 227, 353, 948, 948, 354, 948, 355,
2722  356, 681, 681, 681, 681, 423, 424, 423, 948, 948,
2723  425, 948, 948, 596, 597, 597, 597, 597, 948, 948,
2724  948, 682, 683, 683, 683, 683, 610, 610, 610, 610,
2725  610, 610, 610, 610, 692, 692, 692, 692, 948, 682,
2726 
2727  603, 424, 603, 948, 948, 604, 948, 605, 606, 607,
2728  607, 607, 607, 420, 420, 420, 948, 948, 421, 948,
2729  948, 600, 601, 601, 601, 601, 135, 130, 135, 684,
2730  948, 136, 948, 948, 948, 356, 610, 610, 610, 610,
2731  135, 130, 135, 426, 948, 136, 948, 684, 603, 424,
2732  603, 948, 938, 604, 686, 605, 606, 607, 607, 607,
2733  607, 426, 616, 616, 616, 616, 948, 691, 691, 617,
2734  692, 692, 692, 692, 699, 699, 948, 700, 700, 700,
2735  700, 692, 692, 692, 692, 948, 948, 617, 439, 372,
2736  439, 948, 948, 440, 693, 694, 442, 695, 695, 695,
2737 
2738  695, 375, 376, 375, 948, 948, 377, 948, 260, 261,
2739  619, 619, 619, 619, 948, 713, 713, 620, 714, 714,
2740  714, 714, 746, 746, 948, 747, 747, 747, 747, 700,
2741  700, 700, 700, 948, 948, 620, 258, 156, 258, 948,
2742  948, 259, 696, 697, 261, 698, 698, 698, 698, 372,
2743  372, 372, 948, 948, 373, 948, 948, 948, 621, 621,
2744  621, 621, 948, 754, 754, 622, 755, 755, 755, 755,
2745  705, 706, 706, 706, 706, 643, 643, 643, 643, 948,
2746  948, 948, 644, 622, 454, 376, 454, 948, 948, 455,
2747  701, 702, 457, 703, 703, 703, 703, 625, 625, 625,
2748 
2749  644, 948, 626, 948, 948, 948, 624, 624, 624, 624,
2750  948, 762, 762, 627, 763, 763, 763, 763, 847, 847,
2751  847, 847, 948, 651, 651, 651, 651, 948, 948, 948,
2752  652, 627, 625, 625, 625, 948, 948, 626, 948, 704,
2753  705, 706, 706, 706, 706, 708, 625, 708, 652, 948,
2754  709, 948, 710, 711, 712, 712, 712, 712, 628, 629,
2755  628, 948, 948, 630, 948, 715, 716, 717, 717, 717,
2756  717, 629, 629, 629, 948, 948, 638, 948, 718, 719,
2757  720, 720, 720, 720, 722, 629, 722, 948, 948, 723,
2758  948, 724, 725, 726, 726, 726, 726, 470, 382, 470,
2759 
2760  948, 948, 471, 727, 728, 473, 729, 729, 729, 729,
2761  633, 634, 633, 948, 948, 635, 948, 284, 285, 632,
2762  632, 632, 632, 948, 767, 767, 636, 768, 768, 768,
2763  768, 775, 775, 948, 776, 776, 776, 776, 714, 714,
2764  714, 714, 948, 948, 636, 633, 634, 633, 948, 948,
2765  635, 948, 730, 731, 732, 732, 732, 732, 634, 634,
2766  634, 948, 948, 733, 948, 734, 735, 736, 736, 736,
2767  736, 738, 634, 738, 948, 948, 739, 948, 740, 741,
2768  742, 742, 742, 742, 282, 172, 282, 948, 948, 283,
2769  743, 744, 285, 745, 745, 745, 745, 629, 629, 629,
2770 
2771  948, 948, 638, 948, 948, 948, 637, 637, 637, 637,
2772  948, 789, 789, 639, 790, 790, 790, 790, 822, 822,
2773  948, 823, 823, 823, 823, 719, 720, 720, 720, 720,
2774  948, 639, 722, 629, 722, 948, 948, 723, 948, 724,
2775  725, 726, 726, 726, 726, 640, 634, 640, 948, 948,
2776  641, 948, 748, 749, 750, 750, 750, 750, 738, 634,
2777  738, 948, 948, 739, 948, 740, 741, 742, 742, 742,
2778  742, 485, 386, 485, 948, 948, 486, 751, 752, 488,
2779  753, 753, 753, 753, 502, 393, 502, 948, 948, 503,
2780  756, 757, 505, 758, 758, 758, 758, 396, 397, 396,
2781 
2782  948, 948, 398, 948, 308, 309, 646, 646, 646, 646,
2783  948, 830, 830, 647, 831, 831, 831, 831, 852, 852,
2784  852, 852, 948, 678, 678, 678, 678, 948, 948, 948,
2785  679, 647, 306, 192, 306, 948, 948, 307, 759, 760,
2786  309, 761, 761, 761, 761, 393, 393, 393, 679, 948,
2787  394, 948, 948, 948, 648, 648, 648, 648, 948, 838,
2788  838, 649, 839, 839, 839, 839, 729, 729, 729, 729,
2789  705, 706, 706, 706, 706, 948, 948, 948, 848, 649,
2790  517, 397, 517, 948, 948, 518, 764, 765, 520, 766,
2791  766, 766, 766, 529, 401, 529, 848, 948, 530, 769,
2792 
2793  770, 532, 771, 771, 771, 771, 404, 405, 404, 948,
2794  948, 406, 948, 319, 320, 654, 654, 654, 654, 948,
2795  948, 948, 655, 375, 376, 375, 948, 948, 377, 729,
2796  729, 729, 729, 735, 736, 736, 736, 736, 948, 378,
2797  655, 317, 198, 317, 948, 948, 318, 772, 773, 320,
2798  774, 774, 774, 774, 401, 401, 401, 378, 948, 402,
2799  948, 948, 948, 656, 656, 656, 656, 948, 948, 948,
2800  657, 857, 857, 857, 857, 745, 745, 745, 745, 473,
2801  729, 729, 729, 729, 948, 948, 948, 631, 657, 544,
2802  405, 544, 948, 948, 545, 777, 778, 547, 779, 779,
2803 
2804  779, 779, 660, 660, 660, 631, 948, 661, 948, 948,
2805  948, 659, 659, 659, 659, 948, 948, 948, 662, 745,
2806  745, 745, 745, 747, 747, 747, 747, 285, 745, 745,
2807  745, 745, 948, 948, 948, 388, 662, 660, 660, 660,
2808  948, 948, 661, 948, 780, 781, 782, 782, 782, 782,
2809  784, 660, 784, 388, 948, 785, 948, 786, 787, 788,
2810  788, 788, 788, 663, 664, 663, 948, 948, 665, 948,
2811  791, 792, 793, 793, 793, 793, 664, 664, 664, 948,
2812  948, 673, 948, 794, 795, 796, 796, 796, 796, 798,
2813  664, 798, 948, 948, 799, 948, 800, 801, 802, 802,
2814 
2815  802, 802, 556, 409, 556, 948, 948, 557, 803, 804,
2816  559, 805, 805, 805, 805, 668, 669, 668, 948, 948,
2817  670, 948, 333, 334, 667, 667, 667, 667, 948, 948,
2818  948, 671, 753, 753, 753, 753, 753, 753, 753, 753,
2819  488, 753, 753, 753, 753, 948, 948, 948, 642, 671,
2820  668, 669, 668, 948, 948, 670, 948, 806, 807, 808,
2821  808, 808, 808, 669, 669, 669, 642, 948, 809, 948,
2822  810, 811, 812, 812, 812, 812, 814, 669, 814, 948,
2823  948, 815, 948, 816, 817, 818, 818, 818, 818, 331,
2824  211, 331, 948, 948, 332, 819, 820, 334, 821, 821,
2825 
2826  821, 821, 664, 664, 664, 948, 948, 673, 948, 948,
2827  948, 672, 672, 672, 672, 948, 948, 948, 674, 755,
2828  755, 755, 755, 755, 755, 755, 755, 763, 763, 763,
2829  763, 768, 768, 768, 768, 948, 674, 798, 664, 798,
2830  948, 948, 799, 948, 800, 801, 802, 802, 802, 802,
2831  675, 669, 675, 948, 948, 676, 948, 824, 825, 826,
2832  826, 826, 826, 814, 669, 814, 948, 948, 815, 948,
2833  816, 817, 818, 818, 818, 818, 571, 413, 571, 948,
2834  948, 572, 827, 828, 574, 829, 829, 829, 829, 588,
2835  420, 588, 948, 948, 589, 832, 833, 591, 834, 834,
2836 
2837  834, 834, 423, 424, 423, 948, 948, 425, 948, 355,
2838  356, 681, 681, 681, 681, 948, 948, 948, 682, 396,
2839  397, 396, 948, 948, 398, 768, 768, 768, 768, 776,
2840  776, 776, 776, 948, 948, 399, 682, 353, 227, 353,
2841  948, 948, 354, 835, 836, 356, 837, 837, 837, 837,
2842  420, 420, 420, 399, 948, 421, 948, 948, 948, 683,
2843  683, 683, 683, 948, 948, 948, 684, 404, 405, 404,
2844  948, 948, 406, 781, 782, 782, 782, 782, 862, 862,
2845  862, 862, 948, 407, 684, 603, 424, 603, 948, 948,
2846  604, 840, 841, 606, 842, 842, 842, 842, 439, 372,
2847 
2848  439, 407, 948, 440, 948, 441, 442, 695, 695, 695,
2849  695, 439, 372, 439, 948, 948, 440, 948, 441, 442,
2850  695, 695, 695, 695, 258, 156, 258, 948, 948, 259,
2851  948, 260, 261, 698, 698, 698, 698, 258, 156, 258,
2852  948, 948, 259, 948, 260, 261, 698, 698, 698, 698,
2853  372, 372, 372, 948, 948, 373, 948, 948, 948, 700,
2854  700, 700, 700, 454, 376, 454, 948, 948, 455, 948,
2855  456, 457, 703, 703, 703, 703, 454, 376, 454, 948,
2856  948, 455, 948, 456, 457, 703, 703, 703, 703, 708,
2857  625, 708, 948, 948, 709, 948, 710, 711, 712, 712,
2858 
2859  712, 712, 708, 625, 708, 948, 948, 709, 948, 710,
2860  711, 712, 712, 712, 712, 625, 625, 625, 948, 948,
2861  626, 948, 948, 948, 714, 714, 714, 714, 470, 382,
2862  470, 948, 948, 471, 948, 472, 716, 717, 717, 717,
2863  717, 470, 382, 470, 948, 948, 471, 948, 472, 473,
2864  850, 850, 850, 850, 628, 629, 628, 948, 948, 630,
2865  948, 948, 716, 717, 717, 717, 717, 948, 948, 948,
2866  851, 790, 790, 790, 790, 948, 781, 782, 782, 782,
2867  782, 940, 941, 940, 863, 948, 942, 948, 851, 625,
2868  625, 625, 948, 948, 626, 948, 948, 719, 720, 720,
2869 
2870  720, 720, 863, 948, 948, 853, 795, 796, 796, 796,
2871  796, 867, 867, 867, 867, 805, 805, 805, 805, 805,
2872  805, 805, 805, 853, 722, 629, 722, 948, 948, 723,
2873  948, 724, 725, 726, 726, 726, 726, 722, 629, 722,
2874  948, 948, 723, 948, 724, 725, 726, 726, 726, 726,
2875  282, 172, 282, 948, 948, 283, 948, 284, 731, 732,
2876  732, 732, 732, 282, 172, 282, 948, 948, 283, 948,
2877  284, 285, 855, 855, 855, 855, 633, 634, 633, 948,
2878  948, 635, 948, 948, 731, 732, 732, 732, 732, 948,
2879  948, 948, 856, 811, 812, 812, 812, 812, 948, 948,
2880 
2881  948, 559, 805, 805, 805, 805, 948, 948, 948, 666,
2882  856, 738, 634, 738, 948, 948, 739, 948, 740, 741,
2883  742, 742, 742, 742, 629, 629, 629, 666, 948, 638,
2884  948, 948, 735, 736, 736, 736, 736, 948, 948, 948,
2885  858, 872, 872, 872, 872, 821, 821, 821, 821, 821,
2886  821, 821, 821, 823, 823, 823, 823, 948, 858, 738,
2887  634, 738, 948, 948, 739, 948, 740, 741, 742, 742,
2888  742, 742, 629, 629, 629, 948, 948, 638, 948, 948,
2889  948, 747, 747, 747, 747, 485, 386, 485, 948, 948,
2890  486, 948, 487, 749, 750, 750, 750, 750, 485, 386,
2891 
2892  485, 948, 948, 486, 948, 487, 488, 860, 860, 860,
2893  860, 640, 634, 640, 948, 948, 641, 948, 948, 749,
2894  750, 750, 750, 750, 948, 948, 948, 861, 829, 829,
2895  829, 829, 829, 829, 829, 829, 334, 821, 821, 821,
2896  821, 948, 948, 948, 415, 861, 502, 393, 502, 948,
2897  948, 503, 948, 504, 505, 758, 758, 758, 758, 502,
2898  393, 502, 415, 948, 503, 948, 504, 505, 758, 758,
2899  758, 758, 306, 192, 306, 948, 948, 307, 948, 308,
2900  309, 761, 761, 761, 761, 306, 192, 306, 948, 948,
2901  307, 948, 308, 309, 761, 761, 761, 761, 393, 393,
2902 
2903  393, 948, 948, 394, 948, 948, 948, 763, 763, 763,
2904  763, 517, 397, 517, 948, 948, 518, 948, 519, 520,
2905  766, 766, 766, 766, 517, 397, 517, 948, 948, 518,
2906  948, 519, 520, 766, 766, 766, 766, 529, 401, 529,
2907  948, 948, 530, 948, 531, 532, 771, 771, 771, 771,
2908  529, 401, 529, 948, 948, 530, 948, 531, 532, 771,
2909  771, 771, 771, 317, 198, 317, 948, 948, 318, 948,
2910  319, 320, 774, 774, 774, 774, 317, 198, 317, 948,
2911  948, 318, 948, 319, 320, 774, 774, 774, 774, 401,
2912  401, 401, 948, 948, 402, 948, 948, 948, 776, 776,
2913 
2914  776, 776, 544, 405, 544, 948, 948, 545, 948, 546,
2915  547, 779, 779, 779, 779, 544, 405, 544, 948, 948,
2916  545, 948, 546, 547, 779, 779, 779, 779, 784, 660,
2917  784, 948, 948, 785, 948, 786, 787, 788, 788, 788,
2918  788, 784, 660, 784, 948, 948, 785, 948, 786, 787,
2919  788, 788, 788, 788, 660, 660, 660, 948, 948, 661,
2920  948, 948, 948, 790, 790, 790, 790, 556, 409, 556,
2921  948, 948, 557, 948, 558, 792, 793, 793, 793, 793,
2922  556, 409, 556, 948, 948, 557, 948, 558, 559, 865,
2923  865, 865, 865, 663, 664, 663, 948, 948, 665, 948,
2924 
2925  948, 792, 793, 793, 793, 793, 948, 948, 948, 866,
2926  831, 831, 831, 831, 948, 574, 829, 829, 829, 829,
2927  940, 941, 940, 677, 948, 942, 948, 866, 660, 660,
2928  660, 948, 948, 661, 948, 948, 795, 796, 796, 796,
2929  796, 677, 948, 948, 868, 831, 831, 831, 831, 839,
2930  839, 839, 839, 135, 130, 135, 948, 948, 136, 948,
2931  948, 877, 868, 798, 664, 798, 948, 948, 799, 948,
2932  800, 801, 802, 802, 802, 802, 798, 664, 798, 948,
2933  948, 799, 948, 800, 801, 802, 802, 802, 802, 331,
2934  211, 331, 948, 948, 332, 948, 333, 807, 808, 808,
2935 
2936  808, 808, 331, 211, 331, 948, 948, 332, 948, 333,
2937  334, 870, 870, 870, 870, 668, 669, 668, 948, 948,
2938  670, 948, 948, 807, 808, 808, 808, 808, 948, 948,
2939  948, 871, 423, 424, 423, 880, 880, 425, 881, 881,
2940  881, 881, 559, 865, 865, 865, 865, 948, 426, 871,
2941  814, 669, 814, 948, 948, 815, 948, 816, 817, 818,
2942  818, 818, 818, 664, 664, 664, 426, 948, 673, 948,
2943  948, 811, 812, 812, 812, 812, 948, 888, 888, 873,
2944  889, 889, 889, 889, 948, 867, 867, 867, 867, 847,
2945  847, 847, 847, 948, 948, 948, 848, 873, 814, 669,
2946 
2947  814, 948, 948, 815, 948, 816, 817, 818, 818, 818,
2948  818, 664, 664, 664, 848, 948, 673, 948, 948, 948,
2949  823, 823, 823, 823, 571, 413, 571, 948, 948, 572,
2950  948, 573, 825, 826, 826, 826, 826, 571, 413, 571,
2951  948, 948, 572, 948, 573, 574, 875, 875, 875, 875,
2952  675, 669, 675, 948, 948, 676, 948, 948, 825, 826,
2953  826, 826, 826, 948, 896, 896, 876, 897, 897, 897,
2954  897, 334, 870, 870, 870, 870, 862, 862, 862, 862,
2955  948, 948, 948, 863, 876, 588, 420, 588, 948, 948,
2956  589, 948, 590, 591, 834, 834, 834, 834, 588, 420,
2957 
2958  588, 863, 948, 589, 948, 590, 591, 834, 834, 834,
2959  834, 353, 227, 353, 948, 948, 354, 948, 355, 356,
2960  837, 837, 837, 837, 353, 227, 353, 948, 948, 354,
2961  948, 355, 356, 837, 837, 837, 837, 420, 420, 420,
2962  948, 948, 421, 948, 948, 948, 839, 839, 839, 839,
2963  603, 424, 603, 948, 948, 604, 948, 605, 606, 842,
2964  842, 842, 842, 603, 424, 603, 948, 948, 604, 948,
2965  605, 606, 842, 842, 842, 842, 708, 625, 708, 948,
2966  948, 709, 882, 883, 711, 884, 884, 884, 884, 628,
2967  629, 628, 948, 948, 630, 948, 472, 473, 850, 850,
2968 
2969  850, 850, 948, 904, 904, 851, 905, 905, 905, 905,
2970  906, 907, 948, 908, 908, 908, 908, 948, 872, 872,
2971  872, 872, 948, 851, 470, 382, 470, 948, 948, 471,
2972  885, 886, 473, 887, 887, 887, 887, 625, 625, 625,
2973  948, 948, 626, 948, 948, 948, 852, 852, 852, 852,
2974  948, 909, 910, 853, 911, 911, 911, 911, 912, 912,
2975  948, 913, 913, 913, 913, 574, 875, 875, 875, 875,
2976  948, 853, 722, 629, 722, 948, 948, 723, 890, 891,
2977  725, 892, 892, 892, 892, 633, 634, 633, 948, 948,
2978  635, 948, 284, 285, 855, 855, 855, 855, 948, 914,
2979 
2980  915, 856, 916, 916, 916, 916, 917, 918, 948, 919,
2981  919, 919, 919, 881, 881, 881, 881, 948, 948, 856,
2982  282, 172, 282, 948, 948, 283, 893, 894, 285, 895,
2983  895, 895, 895, 629, 629, 629, 948, 948, 638, 948,
2984  948, 948, 857, 857, 857, 857, 948, 920, 920, 858,
2985  921, 921, 921, 921, 922, 923, 948, 924, 924, 924,
2986  924, 881, 881, 881, 881, 948, 948, 858, 738, 634,
2987  738, 948, 948, 739, 898, 899, 741, 900, 900, 900,
2988  900, 640, 634, 640, 948, 948, 641, 948, 487, 488,
2989  860, 860, 860, 860, 948, 925, 926, 861, 927, 927,
2990 
2991  927, 927, 135, 130, 135, 948, 948, 136, 940, 941,
2992  940, 928, 948, 942, 948, 861, 485, 386, 485, 948,
2993  948, 486, 901, 902, 488, 903, 903, 903, 903, 708,
2994  625, 708, 948, 948, 709, 948, 710, 711, 884, 884,
2995  884, 884, 628, 629, 628, 948, 948, 630, 469, 472,
2996  889, 889, 889, 889, 897, 897, 897, 897, 631, 905,
2997  905, 905, 905, 905, 905, 905, 905, 908, 908, 908,
2998  908, 908, 908, 908, 908, 948, 631, 625, 625, 625,
2999  948, 948, 626, 948, 948, 948, 889, 889, 889, 889,
3000  722, 629, 722, 948, 948, 723, 948, 724, 725, 892,
3001 
3002  892, 892, 892, 633, 634, 633, 948, 948, 635, 281,
3003  284, 908, 908, 908, 908, 948, 948, 948, 864, 388,
3004  911, 911, 911, 911, 911, 911, 911, 911, 913, 913,
3005  913, 913, 916, 916, 916, 916, 864, 388, 629, 629,
3006  629, 948, 948, 638, 948, 948, 948, 897, 897, 897,
3007  897, 738, 634, 738, 948, 948, 739, 948, 740, 741,
3008  900, 900, 900, 900, 640, 634, 640, 948, 948, 641,
3009  484, 487, 948, 559, 911, 911, 911, 911, 948, 948,
3010  642, 666, 916, 916, 916, 916, 948, 948, 916, 916,
3011  916, 916, 135, 130, 135, 869, 948, 136, 642, 666,
3012 
3013  660, 660, 660, 948, 948, 661, 948, 948, 948, 913,
3014  913, 913, 913, 869, 919, 919, 919, 919, 919, 919,
3015  919, 919, 334, 919, 919, 919, 919, 937, 948, 948,
3016  415, 921, 921, 921, 921, 921, 921, 921, 921, 924,
3017  924, 924, 924, 924, 924, 924, 924, 948, 415, 924,
3018  924, 924, 924, 948, 948, 948, 874, 927, 927, 927,
3019  927, 927, 927, 927, 927, 574, 927, 927, 927, 927,
3020  135, 130, 135, 677, 874, 136, 135, 130, 135, 948,
3021  943, 136, 943, 948, 948, 944, 948, 940, 941, 940,
3022  948, 677, 942, 943, 946, 943, 946, 948, 944, 947,
3023 
3024  946, 946, 946, 946, 948, 947, 947, 946, 948, 946,
3025  948, 948, 947, 934, 948, 948, 948, 948, 936, 46,
3026  46, 46, 46, 46, 46, 46, 46, 80, 80, 80,
3027  80, 80, 80, 80, 80, 110, 110, 110, 110, 110,
3028  110, 110, 110, 120, 120, 120, 120, 120, 120, 120,
3029  120, 134, 134, 134, 134, 134, 134, 134, 134, 138,
3030  948, 948, 138, 175, 948, 948, 175, 948, 175, 175,
3031  175, 176, 176, 176, 176, 176, 176, 176, 176, 214,
3032  948, 948, 214, 948, 214, 214, 215, 215, 215, 215,
3033  215, 215, 215, 215, 230, 230, 948, 230, 948, 230,
3034 
3035  230, 230, 233, 233, 233, 233, 233, 233, 233, 233,
3036  239, 239, 948, 239, 239, 239, 239, 239, 257, 257,
3037  257, 257, 257, 257, 257, 257, 270, 270, 270, 270,
3038  270, 270, 270, 270, 276, 276, 948, 948, 276, 276,
3039  281, 281, 281, 281, 281, 281, 281, 281, 294, 294,
3040  294, 294, 294, 294, 294, 294, 305, 305, 305, 305,
3041  305, 305, 305, 305, 316, 316, 316, 316, 316, 316,
3042  316, 316, 330, 330, 330, 330, 330, 330, 330, 330,
3043  341, 341, 341, 341, 341, 341, 341, 341, 352, 352,
3044  352, 352, 352, 352, 352, 352, 230, 230, 948, 230,
3045 
3046  948, 230, 230, 230, 233, 233, 233, 233, 233, 233,
3047  233, 233, 239, 239, 948, 239, 239, 239, 239, 239,
3048  134, 134, 134, 134, 134, 134, 134, 134, 138, 948,
3049  948, 138, 257, 257, 257, 257, 257, 257, 257, 257,
3050  270, 270, 270, 270, 270, 270, 270, 270, 276, 276,
3051  948, 948, 276, 276, 281, 281, 281, 281, 281, 281,
3052  281, 281, 438, 438, 438, 438, 438, 438, 438, 438,
3053  453, 453, 453, 453, 453, 453, 453, 453, 469, 469,
3054  469, 469, 469, 469, 469, 469, 484, 484, 484, 484,
3055  484, 484, 484, 484, 294, 294, 294, 294, 294, 294,
3056 
3057  294, 294, 501, 501, 501, 501, 501, 501, 501, 501,
3058  305, 305, 305, 305, 305, 305, 305, 305, 516, 516,
3059  516, 516, 516, 516, 516, 516, 528, 528, 528, 528,
3060  528, 528, 528, 528, 316, 316, 316, 316, 316, 316,
3061  316, 316, 543, 543, 543, 543, 543, 543, 543, 543,
3062  555, 555, 555, 555, 555, 555, 555, 555, 330, 330,
3063  330, 330, 330, 330, 330, 330, 570, 570, 570, 570,
3064  570, 570, 570, 570, 341, 341, 341, 341, 341, 341,
3065  341, 341, 587, 587, 587, 587, 587, 587, 587, 587,
3066  352, 352, 352, 352, 352, 352, 352, 352, 602, 602,
3067 
3068  602, 602, 602, 602, 602, 602, 134, 134, 134, 134,
3069  134, 134, 134, 134, 138, 948, 948, 138, 438, 438,
3070  438, 438, 438, 438, 438, 438, 257, 257, 257, 257,
3071  257, 257, 257, 257, 453, 453, 453, 453, 453, 453,
3072  453, 453, 469, 469, 469, 469, 469, 469, 469, 469,
3073  281, 281, 281, 281, 281, 281, 281, 281, 484, 484,
3074  484, 484, 484, 484, 484, 484, 294, 294, 294, 294,
3075  294, 294, 294, 294, 501, 501, 501, 501, 501, 501,
3076  501, 501, 305, 305, 305, 305, 305, 305, 305, 305,
3077  516, 516, 516, 516, 516, 516, 516, 516, 528, 528,
3078 
3079  528, 528, 528, 528, 528, 528, 316, 316, 316, 316,
3080  316, 316, 316, 316, 543, 543, 543, 543, 543, 543,
3081  543, 543, 555, 555, 555, 555, 555, 555, 555, 555,
3082  330, 330, 330, 330, 330, 330, 330, 330, 570, 570,
3083  570, 570, 570, 570, 570, 570, 341, 341, 341, 341,
3084  341, 341, 341, 341, 587, 587, 587, 587, 587, 587,
3085  587, 587, 352, 352, 352, 352, 352, 352, 352, 352,
3086  602, 602, 602, 602, 602, 602, 602, 602, 134, 134,
3087  134, 134, 134, 134, 134, 134, 138, 948, 948, 138,
3088  438, 438, 438, 438, 438, 438, 438, 438, 257, 257,
3089 
3090  257, 257, 257, 257, 257, 257, 453, 453, 453, 453,
3091  453, 453, 453, 453, 707, 707, 707, 707, 707, 707,
3092  707, 707, 469, 469, 469, 469, 469, 469, 469, 469,
3093  721, 721, 721, 721, 721, 721, 721, 721, 281, 281,
3094  281, 281, 281, 281, 281, 281, 737, 737, 737, 737,
3095  737, 737, 737, 737, 484, 484, 484, 484, 484, 484,
3096  484, 484, 501, 501, 501, 501, 501, 501, 501, 501,
3097  305, 305, 305, 305, 305, 305, 305, 305, 516, 516,
3098  516, 516, 516, 516, 516, 516, 528, 528, 528, 528,
3099  528, 528, 528, 528, 316, 316, 316, 316, 316, 316,
3100 
3101  316, 316, 543, 543, 543, 543, 543, 543, 543, 543,
3102  783, 783, 783, 783, 783, 783, 783, 783, 555, 555,
3103  555, 555, 555, 555, 555, 555, 797, 797, 797, 797,
3104  797, 797, 797, 797, 330, 330, 330, 330, 330, 330,
3105  330, 330, 813, 813, 813, 813, 813, 813, 813, 813,
3106  570, 570, 570, 570, 570, 570, 570, 570, 587, 587,
3107  587, 587, 587, 587, 587, 587, 352, 352, 352, 352,
3108  352, 352, 352, 352, 602, 602, 602, 602, 602, 602,
3109  602, 602, 134, 134, 134, 134, 134, 134, 134, 134,
3110  138, 948, 948, 138, 438, 438, 438, 438, 438, 438,
3111 
3112  438, 438, 257, 257, 257, 257, 257, 257, 257, 257,
3113  453, 453, 453, 453, 453, 453, 453, 453, 707, 707,
3114  707, 707, 707, 707, 707, 707, 469, 469, 469, 469,
3115  469, 469, 469, 469, 721, 721, 721, 721, 721, 721,
3116  721, 721, 281, 281, 281, 281, 281, 281, 281, 281,
3117  737, 737, 737, 737, 737, 737, 737, 737, 484, 484,
3118  484, 484, 484, 484, 484, 484, 501, 501, 501, 501,
3119  501, 501, 501, 501, 305, 305, 305, 305, 305, 305,
3120  305, 305, 516, 516, 516, 516, 516, 516, 516, 516,
3121  528, 528, 528, 528, 528, 528, 528, 528, 316, 316,
3122 
3123  316, 316, 316, 316, 316, 316, 543, 543, 543, 543,
3124  543, 543, 543, 543, 783, 783, 783, 783, 783, 783,
3125  783, 783, 555, 555, 555, 555, 555, 555, 555, 555,
3126  797, 797, 797, 797, 797, 797, 797, 797, 330, 330,
3127  330, 330, 330, 330, 330, 330, 813, 813, 813, 813,
3128  813, 813, 813, 813, 570, 570, 570, 570, 570, 570,
3129  570, 570, 587, 587, 587, 587, 587, 587, 587, 587,
3130  352, 352, 352, 352, 352, 352, 352, 352, 602, 602,
3131  602, 602, 602, 602, 602, 602, 134, 134, 134, 134,
3132  134, 134, 134, 134, 138, 948, 948, 138, 707, 707,
3133 
3134  707, 707, 707, 707, 707, 707, 469, 469, 469, 469,
3135  469, 469, 469, 469, 721, 721, 721, 721, 721, 721,
3136  721, 721, 281, 281, 281, 281, 281, 281, 281, 281,
3137  737, 737, 737, 737, 737, 737, 737, 737, 484, 484,
3138  484, 484, 484, 484, 484, 484, 939, 939, 939, 939,
3139  939, 939, 939, 939, 945, 945, 948, 945, 945, 945,
3140  945, 945, 45, 948, 948, 948, 948, 948, 948, 948,
3141  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
3142  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
3143  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
3144 
3145  948, 948, 948, 948, 948, 948, 948, 948, 948, 948
3146 } ;
3147 
3148 static const short int yy_chk[7711] =
3149 { 0,
3150  0, 1, 1, 1, 0, 0, 1, 2, 2, 2,
3151  885, 885, 2, 3, 3, 3, 3, 3, 3, 3,
3152  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3153  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3154  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3155  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3156  5, 5, 5, 60, 60, 5, 6, 6, 6, 431,
3157  1010, 6, 988, 431, 47, 47, 47, 5, 5, 47,
3158  48, 73, 48, 6, 6, 48, 5, 65, 65, 65,
3159  65, 65, 6, 7, 7, 7, 985, 73, 7, 983,
3160 
3161  7, 7, 7, 7, 7, 7, 66, 66, 66, 66,
3162  976, 7, 9, 9, 9, 9, 9, 9, 10, 10,
3163  10, 10, 10, 10, 11, 11, 11, 11, 11, 11,
3164  12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
3165  13, 13, 14, 14, 14, 14, 14, 14, 15, 15,
3166  15, 15, 15, 15, 16, 16, 16, 16, 16, 16,
3167  17, 17, 17, 970, 17, 17, 18, 18, 18, 965,
3168  18, 18, 19, 19, 19, 19, 19, 19, 17, 68,
3169  68, 68, 68, 68, 18, 20, 20, 20, 20, 20,
3170  20, 21, 21, 21, 21, 21, 21, 22, 22, 22,
3171 
3172  22, 22, 22, 23, 23, 23, 23, 23, 23, 24,
3173  24, 24, 24, 24, 24, 25, 25, 25, 25, 25,
3174  25, 275, 933, 39, 39, 39, 25, 39, 39, 40,
3175  40, 40, 930, 40, 40, 464, 929, 275, 25, 879,
3176  25, 26, 26, 26, 26, 26, 26, 299, 51, 51,
3177  51, 464, 26, 51, 39, 346, 443, 41, 41, 41,
3178  40, 41, 41, 878, 26, 299, 26, 27, 27, 27,
3179  27, 27, 27, 346, 443, 42, 42, 42, 27, 42,
3180  42, 49, 49, 49, 886, 886, 49, 846, 41, 458,
3181  27, 844, 27, 28, 28, 28, 28, 28, 28, 69,
3182 
3183  69, 69, 69, 130, 28, 130, 42, 458, 130, 49,
3184  71, 71, 71, 71, 690, 465, 28, 689, 28, 29,
3185  29, 29, 29, 29, 29, 74, 74, 74, 74, 687,
3186  29, 465, 43, 43, 43, 43, 43, 43, 76, 76,
3187  76, 76, 29, 43, 29, 30, 30, 30, 30, 30,
3188  30, 77, 77, 77, 77, 77, 30, 615, 44, 44,
3189  44, 44, 44, 44, 78, 78, 78, 78, 30, 44,
3190  30, 31, 31, 31, 31, 31, 31, 70, 70, 70,
3191  70, 70, 31, 893, 893, 70, 85, 85, 85, 85,
3192  75, 75, 75, 75, 31, 614, 31, 32, 32, 32,
3193 
3194  32, 32, 32, 70, 88, 88, 88, 88, 32, 613,
3195  75, 82, 82, 82, 612, 82, 82, 497, 894, 894,
3196  32, 432, 32, 33, 33, 33, 75, 33, 33, 84,
3197  84, 84, 84, 84, 506, 497, 86, 86, 86, 86,
3198  86, 33, 901, 901, 86, 87, 87, 87, 87, 87,
3199  902, 902, 506, 33, 521, 33, 34, 34, 34, 428,
3200  34, 34, 86, 90, 90, 90, 90, 90, 91, 91,
3201  91, 91, 521, 369, 34, 93, 93, 93, 93, 93,
3202  94, 94, 94, 94, 368, 367, 34, 366, 34, 35,
3203  35, 35, 35, 35, 35, 99, 99, 99, 99, 99,
3204 
3205  35, 100, 100, 100, 100, 101, 101, 101, 101, 101,
3206  365, 364, 35, 101, 35, 36, 36, 36, 36, 36,
3207  36, 103, 103, 103, 103, 362, 36, 104, 104, 104,
3208  104, 101, 105, 105, 105, 105, 253, 252, 36, 251,
3209  36, 37, 37, 37, 37, 37, 37, 104, 108, 108,
3210  108, 108, 37, 107, 107, 107, 107, 107, 114, 114,
3211  114, 114, 114, 104, 37, 533, 37, 38, 38, 38,
3212  38, 38, 38, 115, 115, 115, 115, 250, 38, 548,
3213  112, 112, 112, 533, 112, 112, 118, 118, 118, 118,
3214  38, 249, 38, 67, 67, 67, 247, 548, 67, 246,
3215 
3216  245, 67, 67, 67, 67, 67, 121, 121, 121, 67,
3217  112, 121, 112, 117, 117, 117, 117, 117, 123, 123,
3218  123, 244, 123, 123, 152, 150, 149, 67, 72, 72,
3219  72, 148, 147, 72, 146, 144, 143, 72, 72, 72,
3220  72, 126, 126, 126, 126, 127, 127, 127, 127, 128,
3221  128, 128, 128, 129, 129, 129, 142, 72, 129, 131,
3222  131, 131, 583, 140, 131, 127, 132, 133, 132, 133,
3223  139, 132, 133, 72, 79, 79, 79, 124, 592, 79,
3224  583, 127, 79, 79, 79, 79, 79, 134, 134, 134,
3225  79, 113, 134, 135, 135, 135, 592, 607, 135, 136,
3226 
3227  136, 136, 96, 83, 136, 695, 703, 64, 79, 89,
3228  89, 89, 712, 63, 89, 607, 62, 89, 89, 89,
3229  89, 89, 61, 695, 703, 89, 137, 137, 137, 726,
3230  712, 137, 153, 153, 153, 153, 155, 155, 155, 155,
3231  155, 59, 58, 89, 92, 92, 92, 726, 57, 92,
3232  137, 56, 92, 92, 92, 92, 92, 742, 158, 158,
3233  92, 158, 158, 158, 158, 159, 159, 159, 159, 161,
3234  161, 161, 161, 55, 758, 742, 161, 54, 92, 95,
3235  95, 95, 766, 53, 95, 52, 45, 95, 95, 95,
3236  95, 95, 758, 0, 161, 95, 167, 167, 167, 167,
3237 
3238  766, 160, 160, 160, 160, 160, 166, 166, 166, 160,
3239  0, 166, 0, 95, 109, 109, 109, 0, 0, 109,
3240  0, 0, 109, 109, 109, 109, 109, 160, 162, 162,
3241  109, 162, 162, 162, 162, 169, 169, 169, 169, 171,
3242  171, 171, 171, 171, 179, 179, 179, 179, 109, 116,
3243  116, 116, 0, 0, 116, 771, 0, 116, 116, 116,
3244  116, 116, 0, 174, 174, 116, 174, 174, 174, 174,
3245  176, 176, 176, 771, 176, 176, 177, 177, 177, 779,
3246  177, 177, 0, 116, 119, 119, 119, 0, 0, 119,
3247  0, 0, 119, 119, 119, 119, 119, 779, 182, 182,
3248 
3249  119, 182, 182, 182, 182, 183, 183, 183, 183, 180,
3250  180, 180, 180, 180, 0, 0, 0, 180, 119, 156,
3251  156, 156, 0, 0, 156, 0, 156, 156, 156, 156,
3252  156, 156, 157, 157, 157, 180, 0, 157, 0, 157,
3253  157, 157, 157, 157, 157, 164, 164, 164, 788, 0,
3254  164, 0, 164, 0, 164, 164, 164, 164, 165, 165,
3255  165, 0, 0, 165, 0, 165, 788, 165, 165, 165,
3256  165, 172, 172, 172, 0, 0, 172, 0, 172, 172,
3257  172, 172, 172, 172, 173, 173, 173, 0, 0, 173,
3258  0, 173, 173, 173, 173, 173, 173, 181, 181, 181,
3259 
3260  181, 0, 0, 802, 181, 185, 185, 185, 185, 185,
3261  188, 188, 0, 188, 188, 188, 188, 189, 189, 189,
3262  189, 802, 181, 186, 186, 186, 0, 0, 186, 0,
3263  186, 186, 186, 186, 186, 186, 187, 187, 187, 818,
3264  834, 187, 842, 187, 187, 187, 187, 187, 187, 191,
3265  191, 191, 191, 191, 192, 192, 192, 818, 834, 192,
3266  842, 192, 192, 192, 192, 192, 192, 193, 193, 193,
3267  0, 0, 193, 0, 193, 193, 193, 193, 193, 193,
3268  194, 194, 884, 194, 194, 194, 194, 195, 195, 195,
3269  195, 197, 197, 197, 197, 197, 198, 198, 198, 0,
3270 
3271  884, 198, 0, 198, 198, 198, 198, 198, 198, 199,
3272  199, 199, 0, 0, 199, 0, 199, 199, 199, 199,
3273  199, 199, 200, 200, 0, 200, 200, 200, 200, 202,
3274  202, 202, 202, 203, 203, 203, 203, 203, 0, 0,
3275  892, 203, 204, 204, 204, 204, 900, 205, 205, 204,
3276  205, 205, 205, 205, 206, 206, 206, 206, 892, 203,
3277  208, 208, 208, 208, 900, 0, 0, 204, 210, 210,
3278  210, 210, 210, 211, 211, 211, 0, 0, 211, 0,
3279  211, 211, 211, 211, 211, 211, 212, 212, 212, 0,
3280  0, 212, 0, 212, 212, 212, 212, 212, 212, 213,
3281 
3282  213, 0, 213, 213, 213, 213, 215, 215, 215, 0,
3283  215, 215, 216, 216, 216, 0, 216, 216, 218, 218,
3284  218, 218, 220, 220, 220, 220, 220, 223, 223, 0,
3285  223, 223, 223, 223, 0, 239, 215, 239, 215, 0,
3286  239, 0, 216, 0, 216, 221, 221, 221, 0, 0,
3287  221, 0, 221, 221, 221, 221, 221, 221, 222, 222,
3288  222, 0, 0, 222, 0, 222, 222, 222, 222, 222,
3289  222, 224, 224, 224, 224, 225, 225, 225, 0, 0,
3290  225, 0, 0, 225, 225, 225, 225, 225, 0, 0,
3291  0, 225, 226, 226, 226, 226, 226, 229, 229, 0,
3292 
3293  229, 229, 229, 229, 237, 237, 237, 237, 0, 225,
3294  227, 227, 227, 0, 0, 227, 0, 227, 227, 227,
3295  227, 227, 227, 228, 228, 228, 0, 0, 228, 0,
3296  228, 228, 228, 228, 228, 228, 231, 231, 231, 0,
3297  0, 231, 232, 232, 232, 0, 232, 232, 233, 233,
3298  233, 0, 233, 233, 234, 234, 234, 0, 234, 234,
3299  235, 235, 235, 0, 235, 235, 240, 241, 240, 241,
3300  0, 240, 241, 242, 242, 242, 0, 0, 242, 254,
3301  254, 254, 254, 254, 255, 255, 255, 255, 263, 263,
3302  263, 263, 0, 242, 256, 256, 256, 0, 0, 256,
3303 
3304  0, 0, 256, 256, 256, 256, 256, 0, 0, 0,
3305  256, 262, 262, 262, 0, 0, 262, 265, 265, 265,
3306  265, 266, 266, 266, 266, 0, 0, 262, 256, 257,
3307  257, 257, 0, 0, 257, 0, 257, 257, 257, 257,
3308  257, 257, 258, 258, 258, 262, 0, 258, 0, 258,
3309  258, 258, 258, 258, 258, 264, 264, 264, 0, 0,
3310  264, 0, 0, 0, 264, 264, 264, 264, 267, 267,
3311  267, 267, 268, 268, 268, 268, 269, 269, 269, 269,
3312  276, 276, 276, 0, 0, 276, 278, 278, 278, 278,
3313  278, 0, 268, 279, 279, 279, 279, 287, 287, 287,
3314 
3315  287, 289, 289, 289, 289, 0, 0, 0, 268, 270,
3316  270, 270, 0, 0, 270, 0, 270, 0, 270, 270,
3317  270, 270, 271, 271, 271, 0, 0, 271, 0, 271,
3318  0, 271, 271, 271, 271, 272, 272, 272, 0, 0,
3319  272, 0, 272, 0, 272, 272, 272, 272, 273, 273,
3320  273, 0, 0, 273, 0, 273, 0, 273, 273, 273,
3321  273, 274, 274, 274, 0, 0, 274, 0, 274, 0,
3322  274, 274, 274, 274, 0, 0, 286, 286, 286, 0,
3323  0, 286, 290, 290, 290, 290, 292, 292, 292, 292,
3324  274, 0, 286, 291, 291, 291, 291, 291, 300, 300,
3325 
3326  300, 300, 303, 303, 303, 303, 274, 280, 280, 280,
3327  286, 0, 280, 0, 0, 280, 280, 280, 280, 280,
3328  0, 0, 0, 280, 302, 302, 302, 302, 302, 0,
3329  0, 0, 293, 293, 293, 293, 293, 0, 0, 0,
3330  293, 280, 281, 281, 281, 0, 0, 281, 0, 281,
3331  281, 281, 281, 281, 281, 282, 282, 282, 293, 0,
3332  282, 0, 282, 282, 282, 282, 282, 282, 288, 288,
3333  288, 0, 0, 288, 0, 0, 0, 288, 288, 288,
3334  288, 294, 294, 294, 0, 0, 294, 0, 294, 294,
3335  294, 294, 294, 294, 301, 301, 301, 0, 0, 301,
3336 
3337  0, 0, 0, 301, 301, 301, 301, 304, 304, 304,
3338  0, 0, 304, 0, 0, 304, 304, 304, 304, 304,
3339  0, 0, 0, 304, 310, 310, 310, 0, 0, 310,
3340  311, 311, 311, 311, 313, 313, 313, 313, 313, 0,
3341  310, 304, 305, 305, 305, 0, 0, 305, 0, 305,
3342  305, 305, 305, 305, 305, 0, 0, 0, 310, 312,
3343  312, 312, 0, 0, 312, 0, 0, 0, 312, 312,
3344  312, 312, 314, 314, 314, 314, 315, 315, 315, 0,
3345  0, 315, 0, 0, 315, 315, 315, 315, 315, 0,
3346  0, 0, 315, 321, 321, 321, 0, 0, 321, 322,
3347 
3348  322, 322, 322, 324, 324, 324, 324, 0, 0, 321,
3349  315, 316, 316, 316, 0, 0, 316, 0, 316, 316,
3350  316, 316, 316, 316, 0, 0, 0, 321, 323, 323,
3351  323, 0, 0, 323, 0, 0, 0, 323, 323, 323,
3352  323, 325, 325, 325, 325, 327, 327, 327, 327, 327,
3353  328, 328, 328, 328, 329, 329, 329, 0, 0, 329,
3354  0, 0, 329, 329, 329, 329, 329, 0, 0, 0,
3355  329, 335, 335, 335, 0, 0, 335, 336, 336, 336,
3356  336, 338, 338, 338, 338, 338, 0, 335, 329, 330,
3357  330, 330, 0, 0, 330, 0, 330, 330, 330, 330,
3358 
3359  330, 330, 0, 0, 0, 335, 337, 337, 337, 0,
3360  0, 337, 0, 0, 0, 337, 337, 337, 337, 339,
3361  339, 339, 339, 340, 340, 340, 340, 340, 0, 0,
3362  0, 340, 347, 347, 347, 347, 349, 349, 349, 349,
3363  349, 350, 350, 350, 350, 358, 358, 358, 358, 340,
3364  341, 341, 341, 0, 0, 341, 0, 341, 341, 341,
3365  341, 341, 341, 348, 348, 348, 0, 0, 348, 0,
3366  0, 0, 348, 348, 348, 348, 351, 351, 351, 0,
3367  0, 351, 0, 0, 351, 351, 351, 351, 351, 0,
3368  0, 0, 351, 357, 357, 357, 0, 0, 357, 371,
3369 
3370  371, 371, 371, 371, 381, 381, 381, 381, 381, 357,
3371  351, 352, 352, 352, 0, 0, 352, 0, 352, 352,
3372  352, 352, 352, 352, 0, 0, 0, 357, 359, 359,
3373  359, 0, 0, 359, 0, 0, 0, 359, 359, 359,
3374  359, 361, 361, 361, 374, 374, 361, 374, 374, 374,
3375  374, 378, 378, 0, 378, 378, 378, 378, 0, 0,
3376  361, 372, 372, 372, 0, 0, 372, 0, 372, 372,
3377  372, 372, 372, 372, 373, 373, 373, 0, 0, 373,
3378  0, 373, 373, 373, 373, 373, 373, 375, 375, 375,
3379  0, 0, 375, 0, 375, 375, 375, 375, 375, 375,
3380 
3381  376, 376, 376, 0, 0, 376, 0, 376, 376, 376,
3382  376, 376, 376, 377, 377, 377, 0, 0, 377, 0,
3383  377, 377, 377, 377, 377, 377, 380, 380, 380, 380,
3384  380, 380, 380, 380, 380, 384, 384, 0, 384, 384,
3385  384, 384, 389, 389, 389, 389, 380, 0, 0, 389,
3386  380, 380, 380, 390, 390, 0, 390, 390, 390, 390,
3387  0, 0, 380, 382, 382, 382, 0, 389, 382, 0,
3388  382, 382, 382, 382, 382, 382, 383, 383, 383, 0,
3389  0, 383, 0, 383, 383, 383, 383, 383, 383, 385,
3390  385, 385, 0, 0, 385, 0, 385, 385, 385, 385,
3391 
3392  385, 385, 386, 386, 386, 0, 0, 386, 0, 386,
3393  386, 386, 386, 386, 386, 387, 387, 387, 0, 0,
3394  387, 0, 387, 387, 387, 387, 387, 387, 388, 388,
3395  388, 0, 0, 388, 388, 388, 388, 388, 388, 388,
3396  388, 391, 391, 391, 0, 0, 391, 391, 391, 391,
3397  391, 391, 391, 391, 392, 392, 392, 0, 0, 392,
3398  0, 0, 0, 392, 392, 392, 392, 0, 395, 395,
3399  392, 395, 395, 395, 395, 403, 403, 0, 403, 403,
3400  403, 403, 427, 427, 427, 0, 0, 427, 392, 393,
3401  393, 393, 0, 0, 393, 0, 393, 393, 393, 393,
3402 
3403  393, 393, 394, 394, 394, 0, 0, 394, 0, 394,
3404  394, 394, 394, 394, 394, 396, 396, 396, 0, 0,
3405  396, 0, 396, 396, 396, 396, 396, 396, 397, 397,
3406  397, 0, 0, 397, 0, 397, 397, 397, 397, 397,
3407  397, 398, 398, 398, 0, 0, 398, 0, 398, 398,
3408  398, 398, 398, 398, 399, 399, 399, 0, 0, 399,
3409  399, 399, 399, 399, 399, 399, 399, 400, 400, 400,
3410  0, 0, 400, 0, 0, 0, 400, 400, 400, 400,
3411  0, 411, 411, 400, 411, 411, 411, 411, 435, 435,
3412  435, 435, 435, 416, 416, 416, 416, 0, 0, 0,
3413 
3414  416, 400, 401, 401, 401, 0, 0, 401, 0, 401,
3415  401, 401, 401, 401, 401, 402, 402, 402, 416, 0,
3416  402, 0, 402, 402, 402, 402, 402, 402, 404, 404,
3417  404, 0, 0, 404, 0, 404, 404, 404, 404, 404,
3418  404, 405, 405, 405, 0, 0, 405, 0, 405, 405,
3419  405, 405, 405, 405, 406, 406, 406, 0, 0, 406,
3420  0, 406, 406, 406, 406, 406, 406, 407, 407, 407,
3421  0, 0, 407, 407, 407, 407, 407, 407, 407, 407,
3422  408, 408, 408, 0, 0, 408, 0, 0, 0, 408,
3423  408, 408, 408, 0, 417, 417, 408, 417, 417, 417,
3424 
3425  417, 422, 422, 0, 422, 422, 422, 422, 436, 436,
3426  436, 436, 0, 0, 408, 409, 409, 409, 0, 0,
3427  409, 0, 409, 409, 409, 409, 409, 409, 410, 410,
3428  410, 0, 0, 410, 0, 410, 410, 410, 410, 410,
3429  410, 412, 412, 412, 0, 0, 412, 0, 412, 412,
3430  412, 412, 412, 412, 413, 413, 413, 0, 0, 413,
3431  0, 413, 413, 413, 413, 413, 413, 414, 414, 414,
3432  0, 0, 414, 0, 414, 414, 414, 414, 414, 414,
3433  415, 415, 415, 0, 0, 415, 415, 415, 415, 415,
3434  415, 415, 415, 418, 418, 418, 0, 0, 418, 418,
3435 
3436  418, 418, 418, 418, 418, 418, 419, 419, 419, 0,
3437  0, 419, 0, 0, 0, 419, 419, 419, 419, 0,
3438  0, 0, 419, 444, 444, 444, 444, 451, 451, 451,
3439  451, 437, 437, 437, 437, 437, 0, 0, 0, 437,
3440  419, 420, 420, 420, 0, 0, 420, 0, 420, 420,
3441  420, 420, 420, 420, 421, 421, 421, 437, 0, 421,
3442  0, 421, 421, 421, 421, 421, 421, 423, 423, 423,
3443  0, 0, 423, 0, 423, 423, 423, 423, 423, 423,
3444  424, 424, 424, 0, 0, 424, 0, 424, 424, 424,
3445  424, 424, 424, 425, 425, 425, 0, 0, 425, 0,
3446 
3447  425, 425, 425, 425, 425, 425, 426, 426, 426, 0,
3448  0, 426, 426, 426, 426, 426, 426, 426, 426, 438,
3449  438, 438, 0, 0, 438, 0, 438, 438, 438, 438,
3450  438, 438, 439, 439, 439, 0, 0, 439, 0, 439,
3451  439, 439, 439, 439, 439, 445, 445, 445, 0, 0,
3452  445, 0, 0, 0, 445, 445, 445, 445, 446, 446,
3453  446, 0, 0, 446, 0, 446, 446, 446, 446, 446,
3454  446, 447, 447, 447, 0, 0, 447, 0, 447, 447,
3455  447, 447, 447, 447, 448, 448, 448, 0, 0, 448,
3456  0, 0, 448, 448, 448, 448, 448, 0, 0, 0,
3457 
3458  448, 450, 450, 450, 450, 450, 459, 459, 459, 459,
3459  460, 460, 460, 460, 467, 467, 467, 467, 448, 449,
3460  449, 449, 0, 0, 449, 0, 449, 449, 449, 449,
3461  449, 449, 452, 452, 452, 0, 0, 452, 0, 0,
3462  452, 452, 452, 452, 452, 0, 0, 0, 452, 466,
3463  466, 466, 466, 466, 461, 461, 461, 461, 461, 686,
3464  686, 686, 461, 0, 686, 0, 452, 453, 453, 453,
3465  686, 0, 453, 0, 453, 453, 453, 453, 453, 453,
3466  461, 463, 463, 463, 463, 463, 463, 463, 463, 463,
3467  463, 463, 463, 463, 463, 463, 463, 463, 463, 463,
3468 
3469  463, 463, 463, 463, 463, 463, 463, 463, 463, 463,
3470  463, 463, 463, 463, 463, 463, 463, 463, 463, 463,
3471  463, 463, 463, 463, 463, 463, 463, 463, 468, 468,
3472  468, 0, 0, 468, 0, 0, 468, 468, 468, 468,
3473  468, 0, 0, 0, 468, 474, 474, 474, 0, 0,
3474  474, 475, 475, 475, 475, 481, 481, 481, 481, 481,
3475  0, 474, 468, 469, 469, 469, 0, 0, 469, 0,
3476  469, 469, 469, 469, 469, 469, 470, 470, 470, 474,
3477  0, 470, 0, 470, 470, 470, 470, 470, 470, 476,
3478  476, 476, 0, 0, 476, 0, 0, 0, 476, 476,
3479 
3480  476, 476, 477, 477, 477, 0, 0, 477, 0, 477,
3481  477, 477, 477, 477, 477, 478, 478, 478, 0, 0,
3482  478, 0, 478, 478, 478, 478, 478, 478, 479, 479,
3483  479, 0, 0, 479, 0, 0, 479, 479, 479, 479,
3484  479, 0, 0, 0, 479, 482, 482, 482, 482, 490,
3485  490, 490, 490, 491, 491, 491, 491, 493, 493, 493,
3486  493, 0, 479, 480, 480, 480, 0, 0, 480, 0,
3487  480, 480, 480, 480, 480, 480, 483, 483, 483, 0,
3488  0, 483, 0, 0, 483, 483, 483, 483, 483, 0,
3489  0, 0, 483, 489, 489, 489, 0, 0, 489, 494,
3490 
3491  494, 494, 494, 498, 498, 498, 498, 498, 0, 489,
3492  483, 484, 484, 484, 0, 0, 484, 0, 484, 484,
3493  484, 484, 484, 484, 0, 0, 0, 489, 492, 492,
3494  492, 0, 0, 492, 0, 0, 0, 492, 492, 492,
3495  492, 0, 0, 0, 492, 499, 499, 499, 499, 507,
3496  507, 507, 507, 500, 500, 500, 500, 500, 0, 0,
3497  0, 500, 492, 495, 495, 495, 0, 0, 495, 0,
3498  495, 495, 495, 495, 495, 495, 496, 496, 496, 500,
3499  0, 496, 0, 496, 496, 496, 496, 496, 496, 501,
3500  501, 501, 0, 0, 501, 0, 501, 501, 501, 501,
3501 
3502  501, 501, 502, 502, 502, 0, 0, 502, 0, 502,
3503  502, 502, 502, 502, 502, 508, 508, 508, 0, 0,
3504  508, 0, 0, 0, 508, 508, 508, 508, 509, 509,
3505  509, 0, 0, 509, 0, 509, 509, 509, 509, 509,
3506  509, 510, 510, 510, 0, 0, 510, 0, 510, 510,
3507  510, 510, 510, 510, 511, 511, 511, 0, 0, 511,
3508  0, 0, 511, 511, 511, 511, 511, 0, 0, 0,
3509  511, 513, 513, 513, 513, 513, 514, 514, 514, 514,
3510  522, 522, 522, 522, 523, 523, 523, 523, 511, 512,
3511  512, 512, 0, 0, 512, 0, 512, 512, 512, 512,
3512 
3513  512, 512, 515, 515, 515, 0, 0, 515, 0, 0,
3514  515, 515, 515, 515, 515, 0, 0, 0, 515, 525,
3515  525, 525, 525, 525, 524, 524, 524, 524, 524, 928,
3516  928, 928, 524, 0, 928, 0, 515, 516, 516, 516,
3517  0, 0, 516, 0, 516, 516, 516, 516, 516, 516,
3518  524, 526, 526, 526, 526, 527, 527, 527, 527, 527,
3519  0, 0, 0, 527, 534, 534, 534, 534, 540, 540,
3520  540, 540, 540, 541, 541, 541, 541, 549, 549, 549,
3521  549, 527, 528, 528, 528, 0, 0, 528, 0, 528,
3522  528, 528, 528, 528, 528, 529, 529, 529, 0, 0,
3523 
3524  529, 0, 529, 529, 529, 529, 529, 529, 535, 535,
3525  535, 0, 0, 535, 0, 0, 0, 535, 535, 535,
3526  535, 536, 536, 536, 0, 0, 536, 0, 536, 536,
3527  536, 536, 536, 536, 537, 537, 537, 0, 0, 537,
3528  0, 537, 537, 537, 537, 537, 537, 538, 538, 538,
3529  0, 0, 538, 0, 0, 538, 538, 538, 538, 538,
3530  0, 0, 0, 538, 550, 550, 550, 550, 553, 553,
3531  553, 553, 551, 551, 551, 551, 551, 0, 0, 0,
3532  551, 538, 539, 539, 539, 0, 0, 539, 0, 539,
3533  539, 539, 539, 539, 539, 542, 542, 542, 551, 0,
3534 
3535  542, 0, 0, 542, 542, 542, 542, 542, 0, 0,
3536  0, 542, 552, 552, 552, 552, 552, 561, 561, 561,
3537  561, 567, 567, 567, 567, 567, 0, 0, 0, 542,
3538  543, 543, 543, 0, 0, 543, 0, 543, 543, 543,
3539  543, 543, 543, 554, 554, 554, 0, 0, 554, 0,
3540  0, 554, 554, 554, 554, 554, 0, 0, 0, 554,
3541  560, 560, 560, 0, 0, 560, 568, 568, 568, 568,
3542  576, 576, 576, 576, 0, 0, 560, 554, 555, 555,
3543  555, 0, 0, 555, 0, 555, 555, 555, 555, 555,
3544  555, 556, 556, 556, 560, 0, 556, 0, 556, 556,
3545 
3546  556, 556, 556, 556, 562, 562, 562, 0, 0, 562,
3547  0, 0, 0, 562, 562, 562, 562, 563, 563, 563,
3548  0, 0, 563, 0, 563, 563, 563, 563, 563, 563,
3549  564, 564, 564, 0, 0, 564, 0, 564, 564, 564,
3550  564, 564, 564, 565, 565, 565, 0, 0, 565, 0,
3551  0, 565, 565, 565, 565, 565, 0, 0, 0, 565,
3552  575, 575, 575, 0, 0, 575, 577, 577, 577, 577,
3553  579, 579, 579, 579, 0, 0, 575, 565, 566, 566,
3554  566, 0, 0, 566, 0, 566, 566, 566, 566, 566,
3555  566, 569, 569, 569, 575, 0, 569, 0, 0, 569,
3556 
3557  569, 569, 569, 569, 0, 0, 0, 569, 580, 580,
3558  580, 580, 584, 584, 584, 584, 584, 585, 585, 585,
3559  585, 593, 593, 593, 593, 569, 570, 570, 570, 0,
3560  0, 570, 0, 570, 570, 570, 570, 570, 570, 578,
3561  578, 578, 0, 0, 578, 0, 0, 0, 578, 578,
3562  578, 578, 0, 0, 0, 578, 599, 599, 599, 599,
3563  599, 0, 0, 0, 586, 586, 586, 586, 586, 0,
3564  0, 0, 586, 578, 581, 581, 581, 0, 0, 581,
3565  0, 581, 581, 581, 581, 581, 581, 582, 582, 582,
3566  586, 0, 582, 0, 582, 582, 582, 582, 582, 582,
3567 
3568  587, 587, 587, 0, 0, 587, 0, 587, 587, 587,
3569  587, 587, 587, 588, 588, 588, 0, 0, 588, 0,
3570  588, 588, 588, 588, 588, 588, 594, 594, 594, 0,
3571  0, 594, 0, 0, 0, 594, 594, 594, 594, 595,
3572  595, 595, 0, 0, 595, 0, 595, 595, 595, 595,
3573  595, 595, 596, 596, 596, 0, 0, 596, 0, 596,
3574  596, 596, 596, 596, 596, 597, 597, 597, 0, 0,
3575  597, 0, 0, 597, 597, 597, 597, 597, 0, 0,
3576  0, 597, 600, 600, 600, 600, 608, 608, 608, 608,
3577  609, 609, 609, 609, 691, 691, 691, 691, 0, 597,
3578 
3579  598, 598, 598, 0, 0, 598, 0, 598, 598, 598,
3580  598, 598, 598, 601, 601, 601, 0, 0, 601, 0,
3581  0, 601, 601, 601, 601, 601, 611, 611, 611, 601,
3582  0, 611, 0, 0, 0, 610, 610, 610, 610, 610,
3583  937, 937, 937, 610, 0, 937, 0, 601, 602, 602,
3584  602, 0, 937, 602, 611, 602, 602, 602, 602, 602,
3585  602, 610, 616, 616, 616, 616, 0, 617, 617, 616,
3586  617, 617, 617, 617, 622, 622, 0, 622, 622, 622,
3587  622, 692, 692, 692, 692, 0, 0, 616, 618, 618,
3588  618, 0, 0, 618, 618, 618, 618, 618, 618, 618,
3589 
3590  618, 619, 619, 619, 0, 0, 619, 0, 619, 619,
3591  619, 619, 619, 619, 0, 627, 627, 619, 627, 627,
3592  627, 627, 639, 639, 0, 639, 639, 639, 639, 699,
3593  699, 699, 699, 0, 0, 619, 620, 620, 620, 0,
3594  0, 620, 620, 620, 620, 620, 620, 620, 620, 621,
3595  621, 621, 0, 0, 621, 0, 0, 0, 621, 621,
3596  621, 621, 0, 644, 644, 621, 644, 644, 644, 644,
3597  704, 704, 704, 704, 704, 643, 643, 643, 643, 0,
3598  0, 0, 643, 621, 623, 623, 623, 0, 0, 623,
3599  623, 623, 623, 623, 623, 623, 623, 624, 624, 624,
3600 
3601  643, 0, 624, 0, 0, 0, 624, 624, 624, 624,
3602  0, 649, 649, 624, 649, 649, 649, 649, 705, 705,
3603  705, 705, 0, 651, 651, 651, 651, 0, 0, 0,
3604  651, 624, 625, 625, 625, 0, 0, 625, 0, 625,
3605  625, 625, 625, 625, 625, 626, 626, 626, 651, 0,
3606  626, 0, 626, 626, 626, 626, 626, 626, 628, 628,
3607  628, 0, 0, 628, 0, 628, 628, 628, 628, 628,
3608  628, 629, 629, 629, 0, 0, 629, 0, 629, 629,
3609  629, 629, 629, 629, 630, 630, 630, 0, 0, 630,
3610  0, 630, 630, 630, 630, 630, 630, 631, 631, 631,
3611 
3612  0, 0, 631, 631, 631, 631, 631, 631, 631, 631,
3613  632, 632, 632, 0, 0, 632, 0, 632, 632, 632,
3614  632, 632, 632, 0, 652, 652, 632, 652, 652, 652,
3615  652, 657, 657, 0, 657, 657, 657, 657, 713, 713,
3616  713, 713, 0, 0, 632, 633, 633, 633, 0, 0,
3617  633, 0, 633, 633, 633, 633, 633, 633, 634, 634,
3618  634, 0, 0, 634, 0, 634, 634, 634, 634, 634,
3619  634, 635, 635, 635, 0, 0, 635, 0, 635, 635,
3620  635, 635, 635, 635, 636, 636, 636, 0, 0, 636,
3621  636, 636, 636, 636, 636, 636, 636, 637, 637, 637,
3622 
3623  0, 0, 637, 0, 0, 0, 637, 637, 637, 637,
3624  0, 662, 662, 637, 662, 662, 662, 662, 674, 674,
3625  0, 674, 674, 674, 674, 718, 718, 718, 718, 718,
3626  0, 637, 638, 638, 638, 0, 0, 638, 0, 638,
3627  638, 638, 638, 638, 638, 640, 640, 640, 0, 0,
3628  640, 0, 640, 640, 640, 640, 640, 640, 641, 641,
3629  641, 0, 0, 641, 0, 641, 641, 641, 641, 641,
3630  641, 642, 642, 642, 0, 0, 642, 642, 642, 642,
3631  642, 642, 642, 642, 645, 645, 645, 0, 0, 645,
3632  645, 645, 645, 645, 645, 645, 645, 646, 646, 646,
3633 
3634  0, 0, 646, 0, 646, 646, 646, 646, 646, 646,
3635  0, 679, 679, 646, 679, 679, 679, 679, 719, 719,
3636  719, 719, 0, 678, 678, 678, 678, 0, 0, 0,
3637  678, 646, 647, 647, 647, 0, 0, 647, 647, 647,
3638  647, 647, 647, 647, 647, 648, 648, 648, 678, 0,
3639  648, 0, 0, 0, 648, 648, 648, 648, 0, 684,
3640  684, 648, 684, 684, 684, 684, 727, 727, 727, 727,
3641  706, 706, 706, 706, 706, 0, 0, 0, 706, 648,
3642  650, 650, 650, 0, 0, 650, 650, 650, 650, 650,
3643  650, 650, 650, 653, 653, 653, 706, 0, 653, 653,
3644 
3645  653, 653, 653, 653, 653, 653, 654, 654, 654, 0,
3646  0, 654, 0, 654, 654, 654, 654, 654, 654, 0,
3647  0, 0, 654, 698, 698, 698, 0, 0, 698, 728,
3648  728, 728, 728, 734, 734, 734, 734, 734, 0, 698,
3649  654, 655, 655, 655, 0, 0, 655, 655, 655, 655,
3650  655, 655, 655, 655, 656, 656, 656, 698, 0, 656,
3651  0, 0, 0, 656, 656, 656, 656, 0, 0, 0,
3652  656, 735, 735, 735, 735, 743, 743, 743, 743, 729,
3653  729, 729, 729, 729, 0, 0, 0, 729, 656, 658,
3654  658, 658, 0, 0, 658, 658, 658, 658, 658, 658,
3655 
3656  658, 658, 659, 659, 659, 729, 0, 659, 0, 0,
3657  0, 659, 659, 659, 659, 0, 0, 0, 659, 744,
3658  744, 744, 744, 746, 746, 746, 746, 745, 745, 745,
3659  745, 745, 0, 0, 0, 745, 659, 660, 660, 660,
3660  0, 0, 660, 0, 660, 660, 660, 660, 660, 660,
3661  661, 661, 661, 745, 0, 661, 0, 661, 661, 661,
3662  661, 661, 661, 663, 663, 663, 0, 0, 663, 0,
3663  663, 663, 663, 663, 663, 663, 664, 664, 664, 0,
3664  0, 664, 0, 664, 664, 664, 664, 664, 664, 665,
3665  665, 665, 0, 0, 665, 0, 665, 665, 665, 665,
3666 
3667  665, 665, 666, 666, 666, 0, 0, 666, 666, 666,
3668  666, 666, 666, 666, 666, 667, 667, 667, 0, 0,
3669  667, 0, 667, 667, 667, 667, 667, 667, 0, 0,
3670  0, 667, 751, 751, 751, 751, 752, 752, 752, 752,
3671  753, 753, 753, 753, 753, 0, 0, 0, 753, 667,
3672  668, 668, 668, 0, 0, 668, 0, 668, 668, 668,
3673  668, 668, 668, 669, 669, 669, 753, 0, 669, 0,
3674  669, 669, 669, 669, 669, 669, 670, 670, 670, 0,
3675  0, 670, 0, 670, 670, 670, 670, 670, 670, 671,
3676  671, 671, 0, 0, 671, 671, 671, 671, 671, 671,
3677 
3678  671, 671, 672, 672, 672, 0, 0, 672, 0, 0,
3679  0, 672, 672, 672, 672, 0, 0, 0, 672, 754,
3680  754, 754, 754, 755, 755, 755, 755, 762, 762, 762,
3681  762, 767, 767, 767, 767, 0, 672, 673, 673, 673,
3682  0, 0, 673, 0, 673, 673, 673, 673, 673, 673,
3683  675, 675, 675, 0, 0, 675, 0, 675, 675, 675,
3684  675, 675, 675, 676, 676, 676, 0, 0, 676, 0,
3685  676, 676, 676, 676, 676, 676, 677, 677, 677, 0,
3686  0, 677, 677, 677, 677, 677, 677, 677, 677, 680,
3687  680, 680, 0, 0, 680, 680, 680, 680, 680, 680,
3688 
3689  680, 680, 681, 681, 681, 0, 0, 681, 0, 681,
3690  681, 681, 681, 681, 681, 0, 0, 0, 681, 761,
3691  761, 761, 0, 0, 761, 768, 768, 768, 768, 775,
3692  775, 775, 775, 0, 0, 761, 681, 682, 682, 682,
3693  0, 0, 682, 682, 682, 682, 682, 682, 682, 682,
3694  683, 683, 683, 761, 0, 683, 0, 0, 0, 683,
3695  683, 683, 683, 0, 0, 0, 683, 774, 774, 774,
3696  0, 0, 774, 780, 780, 780, 780, 780, 781, 781,
3697  781, 781, 0, 774, 683, 685, 685, 685, 0, 0,
3698  685, 685, 685, 685, 685, 685, 685, 685, 693, 693,
3699 
3700  693, 774, 0, 693, 0, 693, 693, 693, 693, 693,
3701  693, 694, 694, 694, 0, 0, 694, 0, 694, 694,
3702  694, 694, 694, 694, 696, 696, 696, 0, 0, 696,
3703  0, 696, 696, 696, 696, 696, 696, 697, 697, 697,
3704  0, 0, 697, 0, 697, 697, 697, 697, 697, 697,
3705  700, 700, 700, 0, 0, 700, 0, 0, 0, 700,
3706  700, 700, 700, 701, 701, 701, 0, 0, 701, 0,
3707  701, 701, 701, 701, 701, 701, 702, 702, 702, 0,
3708  0, 702, 0, 702, 702, 702, 702, 702, 702, 707,
3709  707, 707, 0, 0, 707, 0, 707, 707, 707, 707,
3710 
3711  707, 707, 708, 708, 708, 0, 0, 708, 0, 708,
3712  708, 708, 708, 708, 708, 714, 714, 714, 0, 0,
3713  714, 0, 0, 0, 714, 714, 714, 714, 715, 715,
3714  715, 0, 0, 715, 0, 715, 715, 715, 715, 715,
3715  715, 716, 716, 716, 0, 0, 716, 0, 716, 716,
3716  716, 716, 716, 716, 717, 717, 717, 0, 0, 717,
3717  0, 0, 717, 717, 717, 717, 717, 0, 0, 0,
3718  717, 789, 789, 789, 789, 0, 782, 782, 782, 782,
3719  782, 938, 938, 938, 782, 0, 938, 0, 717, 720,
3720  720, 720, 0, 0, 720, 0, 0, 720, 720, 720,
3721 
3722  720, 720, 782, 0, 0, 720, 794, 794, 794, 794,
3723  794, 795, 795, 795, 795, 803, 803, 803, 803, 804,
3724  804, 804, 804, 720, 721, 721, 721, 0, 0, 721,
3725  0, 721, 721, 721, 721, 721, 721, 722, 722, 722,
3726  0, 0, 722, 0, 722, 722, 722, 722, 722, 722,
3727  730, 730, 730, 0, 0, 730, 0, 730, 730, 730,
3728  730, 730, 730, 731, 731, 731, 0, 0, 731, 0,
3729  731, 731, 731, 731, 731, 731, 732, 732, 732, 0,
3730  0, 732, 0, 0, 732, 732, 732, 732, 732, 0,
3731  0, 0, 732, 810, 810, 810, 810, 810, 0, 0,
3732 
3733  0, 805, 805, 805, 805, 805, 0, 0, 0, 805,
3734  732, 733, 733, 733, 0, 0, 733, 0, 733, 733,
3735  733, 733, 733, 733, 736, 736, 736, 805, 0, 736,
3736  0, 0, 736, 736, 736, 736, 736, 0, 0, 0,
3737  736, 811, 811, 811, 811, 819, 819, 819, 819, 820,
3738  820, 820, 820, 822, 822, 822, 822, 0, 736, 737,
3739  737, 737, 0, 0, 737, 0, 737, 737, 737, 737,
3740  737, 737, 747, 747, 747, 0, 0, 747, 0, 0,
3741  0, 747, 747, 747, 747, 748, 748, 748, 0, 0,
3742  748, 0, 748, 748, 748, 748, 748, 748, 749, 749,
3743 
3744  749, 0, 0, 749, 0, 749, 749, 749, 749, 749,
3745  749, 750, 750, 750, 0, 0, 750, 0, 0, 750,
3746  750, 750, 750, 750, 0, 0, 0, 750, 827, 827,
3747  827, 827, 828, 828, 828, 828, 821, 821, 821, 821,
3748  821, 0, 0, 0, 821, 750, 756, 756, 756, 0,
3749  0, 756, 0, 756, 756, 756, 756, 756, 756, 757,
3750  757, 757, 821, 0, 757, 0, 757, 757, 757, 757,
3751  757, 757, 759, 759, 759, 0, 0, 759, 0, 759,
3752  759, 759, 759, 759, 759, 760, 760, 760, 0, 0,
3753  760, 0, 760, 760, 760, 760, 760, 760, 763, 763,
3754 
3755  763, 0, 0, 763, 0, 0, 0, 763, 763, 763,
3756  763, 764, 764, 764, 0, 0, 764, 0, 764, 764,
3757  764, 764, 764, 764, 765, 765, 765, 0, 0, 765,
3758  0, 765, 765, 765, 765, 765, 765, 769, 769, 769,
3759  0, 0, 769, 0, 769, 769, 769, 769, 769, 769,
3760  770, 770, 770, 0, 0, 770, 0, 770, 770, 770,
3761  770, 770, 770, 772, 772, 772, 0, 0, 772, 0,
3762  772, 772, 772, 772, 772, 772, 773, 773, 773, 0,
3763  0, 773, 0, 773, 773, 773, 773, 773, 773, 776,
3764  776, 776, 0, 0, 776, 0, 0, 0, 776, 776,
3765 
3766  776, 776, 777, 777, 777, 0, 0, 777, 0, 777,
3767  777, 777, 777, 777, 777, 778, 778, 778, 0, 0,
3768  778, 0, 778, 778, 778, 778, 778, 778, 783, 783,
3769  783, 0, 0, 783, 0, 783, 783, 783, 783, 783,
3770  783, 784, 784, 784, 0, 0, 784, 0, 784, 784,
3771  784, 784, 784, 784, 790, 790, 790, 0, 0, 790,
3772  0, 0, 0, 790, 790, 790, 790, 791, 791, 791,
3773  0, 0, 791, 0, 791, 791, 791, 791, 791, 791,
3774  792, 792, 792, 0, 0, 792, 0, 792, 792, 792,
3775  792, 792, 792, 793, 793, 793, 0, 0, 793, 0,
3776 
3777  0, 793, 793, 793, 793, 793, 0, 0, 0, 793,
3778  830, 830, 830, 830, 0, 829, 829, 829, 829, 829,
3779  939, 939, 939, 829, 0, 939, 0, 793, 796, 796,
3780  796, 0, 0, 796, 0, 0, 796, 796, 796, 796,
3781  796, 829, 0, 0, 796, 831, 831, 831, 831, 838,
3782  838, 838, 838, 843, 843, 843, 0, 0, 843, 0,
3783  0, 843, 796, 797, 797, 797, 0, 0, 797, 0,
3784  797, 797, 797, 797, 797, 797, 798, 798, 798, 0,
3785  0, 798, 0, 798, 798, 798, 798, 798, 798, 806,
3786  806, 806, 0, 0, 806, 0, 806, 806, 806, 806,
3787 
3788  806, 806, 807, 807, 807, 0, 0, 807, 0, 807,
3789  807, 807, 807, 807, 807, 808, 808, 808, 0, 0,
3790  808, 0, 0, 808, 808, 808, 808, 808, 0, 0,
3791  0, 808, 837, 837, 837, 848, 848, 837, 848, 848,
3792  848, 848, 865, 865, 865, 865, 865, 0, 837, 808,
3793  809, 809, 809, 0, 0, 809, 0, 809, 809, 809,
3794  809, 809, 809, 812, 812, 812, 837, 0, 812, 0,
3795  0, 812, 812, 812, 812, 812, 0, 853, 853, 812,
3796  853, 853, 853, 853, 867, 867, 867, 867, 867, 847,
3797  847, 847, 847, 0, 0, 0, 847, 812, 813, 813,
3798 
3799  813, 0, 0, 813, 0, 813, 813, 813, 813, 813,
3800  813, 823, 823, 823, 847, 0, 823, 0, 0, 0,
3801  823, 823, 823, 823, 824, 824, 824, 0, 0, 824,
3802  0, 824, 824, 824, 824, 824, 824, 825, 825, 825,
3803  0, 0, 825, 0, 825, 825, 825, 825, 825, 825,
3804  826, 826, 826, 0, 0, 826, 0, 0, 826, 826,
3805  826, 826, 826, 0, 858, 858, 826, 858, 858, 858,
3806  858, 870, 870, 870, 870, 870, 862, 862, 862, 862,
3807  0, 0, 0, 862, 826, 832, 832, 832, 0, 0,
3808  832, 0, 832, 832, 832, 832, 832, 832, 833, 833,
3809 
3810  833, 862, 0, 833, 0, 833, 833, 833, 833, 833,
3811  833, 835, 835, 835, 0, 0, 835, 0, 835, 835,
3812  835, 835, 835, 835, 836, 836, 836, 0, 0, 836,
3813  0, 836, 836, 836, 836, 836, 836, 839, 839, 839,
3814  0, 0, 839, 0, 0, 0, 839, 839, 839, 839,
3815  840, 840, 840, 0, 0, 840, 0, 840, 840, 840,
3816  840, 840, 840, 841, 841, 841, 0, 0, 841, 0,
3817  841, 841, 841, 841, 841, 841, 849, 849, 849, 0,
3818  0, 849, 849, 849, 849, 849, 849, 849, 849, 850,
3819  850, 850, 0, 0, 850, 0, 850, 850, 850, 850,
3820 
3821  850, 850, 0, 863, 863, 850, 863, 863, 863, 863,
3822  864, 864, 0, 864, 864, 864, 864, 872, 872, 872,
3823  872, 872, 0, 850, 851, 851, 851, 0, 0, 851,
3824  851, 851, 851, 851, 851, 851, 851, 852, 852, 852,
3825  0, 0, 852, 0, 0, 0, 852, 852, 852, 852,
3826  0, 866, 866, 852, 866, 866, 866, 866, 868, 868,
3827  0, 868, 868, 868, 868, 875, 875, 875, 875, 875,
3828  0, 852, 854, 854, 854, 0, 0, 854, 854, 854,
3829  854, 854, 854, 854, 854, 855, 855, 855, 0, 0,
3830  855, 0, 855, 855, 855, 855, 855, 855, 0, 869,
3831 
3832  869, 855, 869, 869, 869, 869, 871, 871, 0, 871,
3833  871, 871, 871, 880, 880, 880, 880, 0, 0, 855,
3834  856, 856, 856, 0, 0, 856, 856, 856, 856, 856,
3835  856, 856, 856, 857, 857, 857, 0, 0, 857, 0,
3836  0, 0, 857, 857, 857, 857, 0, 873, 873, 857,
3837  873, 873, 873, 873, 874, 874, 0, 874, 874, 874,
3838  874, 881, 881, 881, 881, 0, 0, 857, 859, 859,
3839  859, 0, 0, 859, 859, 859, 859, 859, 859, 859,
3840  859, 860, 860, 860, 0, 0, 860, 0, 860, 860,
3841  860, 860, 860, 860, 0, 876, 876, 860, 876, 876,
3842 
3843  876, 876, 877, 877, 877, 0, 0, 877, 940, 940,
3844  940, 877, 0, 940, 0, 860, 861, 861, 861, 0,
3845  0, 861, 861, 861, 861, 861, 861, 861, 861, 882,
3846  882, 882, 0, 0, 882, 0, 882, 882, 882, 882,
3847  882, 882, 887, 887, 887, 0, 0, 887, 887, 887,
3848  888, 888, 888, 888, 896, 896, 896, 896, 887, 904,
3849  904, 904, 904, 905, 905, 905, 905, 906, 906, 906,
3850  906, 907, 907, 907, 907, 0, 887, 889, 889, 889,
3851  0, 0, 889, 0, 0, 0, 889, 889, 889, 889,
3852  890, 890, 890, 0, 0, 890, 0, 890, 890, 890,
3853 
3854  890, 890, 890, 895, 895, 895, 0, 0, 895, 895,
3855  895, 908, 908, 908, 908, 0, 0, 0, 908, 895,
3856  909, 909, 909, 909, 910, 910, 910, 910, 912, 912,
3857  912, 912, 914, 914, 914, 914, 908, 895, 897, 897,
3858  897, 0, 0, 897, 0, 0, 0, 897, 897, 897,
3859  897, 898, 898, 898, 0, 0, 898, 0, 898, 898,
3860  898, 898, 898, 898, 903, 903, 903, 0, 0, 903,
3861  903, 903, 0, 911, 911, 911, 911, 911, 0, 0,
3862  903, 911, 915, 915, 915, 915, 0, 0, 916, 916,
3863  916, 916, 936, 936, 936, 916, 0, 936, 903, 911,
3864 
3865  913, 913, 913, 0, 0, 913, 0, 0, 0, 913,
3866  913, 913, 913, 916, 917, 917, 917, 917, 918, 918,
3867  918, 918, 919, 919, 919, 919, 919, 936, 0, 0,
3868  919, 920, 920, 920, 920, 921, 921, 921, 921, 922,
3869  922, 922, 922, 923, 923, 923, 923, 0, 919, 924,
3870  924, 924, 924, 0, 0, 0, 924, 925, 925, 925,
3871  925, 926, 926, 926, 926, 927, 927, 927, 927, 927,
3872  931, 931, 931, 927, 924, 931, 934, 934, 934, 0,
3873  941, 934, 941, 0, 0, 941, 0, 942, 942, 942,
3874  0, 927, 942, 943, 944, 943, 944, 0, 943, 944,
3875 
3876  945, 946, 945, 946, 0, 945, 946, 947, 0, 947,
3877  0, 0, 947, 931, 0, 0, 0, 0, 934, 949,
3878  949, 949, 949, 949, 949, 949, 949, 950, 950, 950,
3879  950, 950, 950, 950, 950, 951, 951, 951, 951, 951,
3880  951, 951, 951, 952, 952, 952, 952, 952, 952, 952,
3881  952, 953, 953, 953, 953, 953, 953, 953, 953, 954,
3882  0, 0, 954, 955, 0, 0, 955, 0, 955, 955,
3883  955, 956, 956, 956, 956, 956, 956, 956, 956, 957,
3884  0, 0, 957, 0, 957, 957, 958, 958, 958, 958,
3885  958, 958, 958, 958, 959, 959, 0, 959, 0, 959,
3886 
3887  959, 959, 960, 960, 960, 960, 960, 960, 960, 960,
3888  961, 961, 0, 961, 961, 961, 961, 961, 962, 962,
3889  962, 962, 962, 962, 962, 962, 963, 963, 963, 963,
3890  963, 963, 963, 963, 964, 964, 0, 0, 964, 964,
3891  966, 966, 966, 966, 966, 966, 966, 966, 967, 967,
3892  967, 967, 967, 967, 967, 967, 968, 968, 968, 968,
3893  968, 968, 968, 968, 969, 969, 969, 969, 969, 969,
3894  969, 969, 971, 971, 971, 971, 971, 971, 971, 971,
3895  972, 972, 972, 972, 972, 972, 972, 972, 973, 973,
3896  973, 973, 973, 973, 973, 973, 974, 974, 0, 974,
3897 
3898  0, 974, 974, 974, 975, 975, 975, 975, 975, 975,
3899  975, 975, 977, 977, 0, 977, 977, 977, 977, 977,
3900  978, 978, 978, 978, 978, 978, 978, 978, 979, 0,
3901  0, 979, 980, 980, 980, 980, 980, 980, 980, 980,
3902  981, 981, 981, 981, 981, 981, 981, 981, 982, 982,
3903  0, 0, 982, 982, 984, 984, 984, 984, 984, 984,
3904  984, 984, 986, 986, 986, 986, 986, 986, 986, 986,
3905  987, 987, 987, 987, 987, 987, 987, 987, 989, 989,
3906  989, 989, 989, 989, 989, 989, 990, 990, 990, 990,
3907  990, 990, 990, 990, 991, 991, 991, 991, 991, 991,
3908 
3909  991, 991, 992, 992, 992, 992, 992, 992, 992, 992,
3910  993, 993, 993, 993, 993, 993, 993, 993, 994, 994,
3911  994, 994, 994, 994, 994, 994, 995, 995, 995, 995,
3912  995, 995, 995, 995, 996, 996, 996, 996, 996, 996,
3913  996, 996, 997, 997, 997, 997, 997, 997, 997, 997,
3914  998, 998, 998, 998, 998, 998, 998, 998, 999, 999,
3915  999, 999, 999, 999, 999, 999, 1000, 1000, 1000, 1000,
3916  1000, 1000, 1000, 1000, 1001, 1001, 1001, 1001, 1001, 1001,
3917  1001, 1001, 1002, 1002, 1002, 1002, 1002, 1002, 1002, 1002,
3918  1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1004, 1004,
3919 
3920  1004, 1004, 1004, 1004, 1004, 1004, 1005, 1005, 1005, 1005,
3921  1005, 1005, 1005, 1005, 1006, 0, 0, 1006, 1007, 1007,
3922  1007, 1007, 1007, 1007, 1007, 1007, 1008, 1008, 1008, 1008,
3923  1008, 1008, 1008, 1008, 1009, 1009, 1009, 1009, 1009, 1009,
3924  1009, 1009, 1011, 1011, 1011, 1011, 1011, 1011, 1011, 1011,
3925  1012, 1012, 1012, 1012, 1012, 1012, 1012, 1012, 1013, 1013,
3926  1013, 1013, 1013, 1013, 1013, 1013, 1014, 1014, 1014, 1014,
3927  1014, 1014, 1014, 1014, 1015, 1015, 1015, 1015, 1015, 1015,
3928  1015, 1015, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016,
3929  1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1018, 1018,
3930 
3931  1018, 1018, 1018, 1018, 1018, 1018, 1019, 1019, 1019, 1019,
3932  1019, 1019, 1019, 1019, 1020, 1020, 1020, 1020, 1020, 1020,
3933  1020, 1020, 1021, 1021, 1021, 1021, 1021, 1021, 1021, 1021,
3934  1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1023, 1023,
3935  1023, 1023, 1023, 1023, 1023, 1023, 1024, 1024, 1024, 1024,
3936  1024, 1024, 1024, 1024, 1025, 1025, 1025, 1025, 1025, 1025,
3937  1025, 1025, 1026, 1026, 1026, 1026, 1026, 1026, 1026, 1026,
3938  1027, 1027, 1027, 1027, 1027, 1027, 1027, 1027, 1028, 1028,
3939  1028, 1028, 1028, 1028, 1028, 1028, 1029, 0, 0, 1029,
3940  1030, 1030, 1030, 1030, 1030, 1030, 1030, 1030, 1031, 1031,
3941 
3942  1031, 1031, 1031, 1031, 1031, 1031, 1032, 1032, 1032, 1032,
3943  1032, 1032, 1032, 1032, 1033, 1033, 1033, 1033, 1033, 1033,
3944  1033, 1033, 1034, 1034, 1034, 1034, 1034, 1034, 1034, 1034,
3945  1035, 1035, 1035, 1035, 1035, 1035, 1035, 1035, 1036, 1036,
3946  1036, 1036, 1036, 1036, 1036, 1036, 1037, 1037, 1037, 1037,
3947  1037, 1037, 1037, 1037, 1038, 1038, 1038, 1038, 1038, 1038,
3948  1038, 1038, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1039,
3949  1040, 1040, 1040, 1040, 1040, 1040, 1040, 1040, 1041, 1041,
3950  1041, 1041, 1041, 1041, 1041, 1041, 1042, 1042, 1042, 1042,
3951  1042, 1042, 1042, 1042, 1043, 1043, 1043, 1043, 1043, 1043,
3952 
3953  1043, 1043, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044,
3954  1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1046, 1046,
3955  1046, 1046, 1046, 1046, 1046, 1046, 1047, 1047, 1047, 1047,
3956  1047, 1047, 1047, 1047, 1048, 1048, 1048, 1048, 1048, 1048,
3957  1048, 1048, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049,
3958  1050, 1050, 1050, 1050, 1050, 1050, 1050, 1050, 1051, 1051,
3959  1051, 1051, 1051, 1051, 1051, 1051, 1052, 1052, 1052, 1052,
3960  1052, 1052, 1052, 1052, 1053, 1053, 1053, 1053, 1053, 1053,
3961  1053, 1053, 1054, 1054, 1054, 1054, 1054, 1054, 1054, 1054,
3962  1055, 0, 0, 1055, 1056, 1056, 1056, 1056, 1056, 1056,
3963 
3964  1056, 1056, 1057, 1057, 1057, 1057, 1057, 1057, 1057, 1057,
3965  1058, 1058, 1058, 1058, 1058, 1058, 1058, 1058, 1059, 1059,
3966  1059, 1059, 1059, 1059, 1059, 1059, 1060, 1060, 1060, 1060,
3967  1060, 1060, 1060, 1060, 1061, 1061, 1061, 1061, 1061, 1061,
3968  1061, 1061, 1062, 1062, 1062, 1062, 1062, 1062, 1062, 1062,
3969  1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1064, 1064,
3970  1064, 1064, 1064, 1064, 1064, 1064, 1065, 1065, 1065, 1065,
3971  1065, 1065, 1065, 1065, 1066, 1066, 1066, 1066, 1066, 1066,
3972  1066, 1066, 1067, 1067, 1067, 1067, 1067, 1067, 1067, 1067,
3973  1068, 1068, 1068, 1068, 1068, 1068, 1068, 1068, 1069, 1069,
3974 
3975  1069, 1069, 1069, 1069, 1069, 1069, 1070, 1070, 1070, 1070,
3976  1070, 1070, 1070, 1070, 1071, 1071, 1071, 1071, 1071, 1071,
3977  1071, 1071, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072,
3978  1073, 1073, 1073, 1073, 1073, 1073, 1073, 1073, 1074, 1074,
3979  1074, 1074, 1074, 1074, 1074, 1074, 1075, 1075, 1075, 1075,
3980  1075, 1075, 1075, 1075, 1076, 1076, 1076, 1076, 1076, 1076,
3981  1076, 1076, 1077, 1077, 1077, 1077, 1077, 1077, 1077, 1077,
3982  1078, 1078, 1078, 1078, 1078, 1078, 1078, 1078, 1079, 1079,
3983  1079, 1079, 1079, 1079, 1079, 1079, 1080, 1080, 1080, 1080,
3984  1080, 1080, 1080, 1080, 1081, 0, 0, 1081, 1082, 1082,
3985 
3986  1082, 1082, 1082, 1082, 1082, 1082, 1083, 1083, 1083, 1083,
3987  1083, 1083, 1083, 1083, 1084, 1084, 1084, 1084, 1084, 1084,
3988  1084, 1084, 1085, 1085, 1085, 1085, 1085, 1085, 1085, 1085,
3989  1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1087, 1087,
3990  1087, 1087, 1087, 1087, 1087, 1087, 1088, 1088, 1088, 1088,
3991  1088, 1088, 1088, 1088, 1089, 1089, 0, 1089, 1089, 1089,
3992  1089, 1089, 948, 948, 948, 948, 948, 948, 948, 948,
3993  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
3994  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
3995  948, 948, 948, 948, 948, 948, 948, 948, 948, 948,
3996 
3997  948, 948, 948, 948, 948, 948, 948, 948, 948, 948
3998 } ;
3999 
4000 //static yy_state_type yy_last_accepting_state;
4001 //static char *yy_last_accepting_cpos;
4002 
4003 //extern int yy_flex_debug;
4004 //int yy_flex_debug = 1;
4005 
4006 static const short int yy_rule_linenum[49] =
4007 { 0,
4008  122, 127, 128, 129, 130, 131, 132, 133, 134, 135,
4009  136, 137, 138, 141, 145, 149, 157, 160, 164, 169,
4010  177, 178, 180, 184, 195, 199, 205, 206, 211, 220,
4011  234, 235, 240, 249, 260, 263, 264, 266, 270, 274,
4012  279, 281, 282, 289, 295, 302, 305, 309
4013 } ;
4014 
4015 /* The intent behind this definition is that it'll catch
4016  * any uses of REJECT which flex missed.
4017  */
4018 #define REJECT reject_used_but_not_detected
4019 #define yymore() yymore_used_but_not_detected
4020 #define YY_MORE_ADJ 0
4021 //char *yytext;
4022 /**************************************************
4023  * VRML 2.0 Parser
4024  *
4025  * Author(s) : Gavin Bell
4026  * Daniel Woods (first port)
4027  **************************************************
4028  */
4029 //#include "tokens.h"
4030 #include <string.h>
4031 
4032 // used to reset the lexer input after initialization of VRML nodes
4033 //static void (*theyyInput)(char *, int &, int);
4034 
4035 // We define the YY_INPUT so we an change the input source later
4036 #define YY_INPUT(buf, result, max_size) (*theyyInput)(buf, result, max_size,this)
4037 
4038 /* Current line number */
4039 //int currentLineNumber = 1;
4040 //void yyResetLineNumber() { currentLineNumber = 1; }
4041 
4042 //extern void yyerror(const char *);
4043 
4044  /* The YACC parser sets this to a token to direct the lexer */
4045  /* in cases where just syntax isn't enough: */
4046 //int expectToken = 0;
4047 
4048 /* True when parsing a multiple-valued field: */
4049 //static int parsing_mf = 0;
4050 
4051 /* These are used when parsing SFImage fields: */
4052 //static int sfImageIntsParsed = 0;
4053 //static int sfImageIntsExpected = 0;
4054 
4055 #ifdef __cplusplus
4056 //extern "C"
4057 #endif
4058 VTK_ABI_NAMESPACE_BEGIN
4059 inline int vtkVRMLYaccData::yywrap() { BEGIN INITIAL; return 1; }
4060 VTK_ABI_NAMESPACE_END
4061 
4062 /* Normal state: parsing nodes. The initial start state is used */
4063 /* only to recognize the VRML header. */
4064 /* Start tokens for all of the field types, */
4065 /* except for MFNode and SFNode, which are almost completely handled */
4066 /* by the parser: */
4067 /* Big hairy expression for floating point numbers: */
4068 /* Ints are decimal or hex (0x##): */
4069 /* Whitespace. Using this pattern can screw up currentLineNumber, */
4070 /* so it is only used wherever it is really convenient and it is */
4071 /* extremely unlikely that the user will put in a carriage return */
4072 /* (example: between the floats in an SFVec3f) */
4073 /* And the same pattern without the newline */
4074 /* Legal characters to start an identifier */
4075 /* Legal other characters in an identifier */
4076 
4077 /* Macros after this point can all be overridden by user definitions in
4078  * section 1.
4079  */
4080 
4081 #ifdef YY_MALLOC_DECL
4082 YY_MALLOC_DECL
4083 #else
4084 #if __STDC__
4085 #ifndef __cplusplus
4086 #include <stdlib.h>
4087 #endif
4088 #else
4089 /* Just try to get by without declaring the routines. This will fail
4090  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
4091  * or sizeof(void*) != sizeof(int).
4092  */
4093 #endif
4094 #endif
4095 
4096 /* Amount of stuff to slurp up with each read. */
4097 #ifndef YY_READ_BUF_SIZE
4098 #define YY_READ_BUF_SIZE 8192
4099 #endif
4100 
4101 /* Copy whatever the last rule matched to the standard output. */
4102 
4103 #ifndef ECHO
4104 /* This used to be an fputs(), but since the string might contain NUL's,
4105  * we now use fwrite().
4106  */
4107 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
4108 #endif
4109 
4110 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
4111  * is returned in "result".
4112  */
4113 #ifndef YY_INPUT
4114 #define YY_INPUT(buf,result,max_size) \
4115  if ( yy_current_buffer->yy_is_interactive ) \
4116  { \
4117  int c = getc( yyin ); \
4118  result = c == EOF ? 0 : 1; \
4119  buf[0] = (char) c; \
4120  } \
4121  else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
4122  && ferror( yyin ) ) \
4123  YY_FATAL_ERROR( "input in flex scanner failed" )
4124 #endif
4125 
4126 /* No semi-colon after return; correct usage is to write "yyterminate();" -
4127  * we don't want an extra ';' after the "return" because that will cause
4128  * some compilers to complain about unreachable statements.
4129  */
4130 #ifndef yyterminate
4131 #define yyterminate() return YY_NULL
4132 #endif
4133 
4134 /* Number of entries by which start-condition stack grows. */
4135 #ifndef YY_START_STACK_INCR
4136 #define YY_START_STACK_INCR 25
4137 #endif
4138 
4139 /* Report a fatal error. */
4140 #ifndef YY_FATAL_ERROR
4141 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
4142 #endif
4143 
4144 /* Default declaration of generated scanner - a define so the user can
4145  * easily add parameters.
4146  */
4147 #ifndef YY_DECL
4148 #define YY_DECL int yylex ( vtkVRMLImporter* self )
4149 #endif
4150 
4151 /* Code executed at the beginning of each rule, after yytext and yyleng
4152  * have been set up.
4153  */
4154 #ifndef YY_USER_ACTION
4155 #define YY_USER_ACTION
4156 #endif
4157 
4158 /* Code executed at the end of each rule. */
4159 #ifndef YY_BREAK
4160 #define YY_BREAK break;
4161 #endif
4162 
4163 
4164 VTK_ABI_NAMESPACE_BEGIN
4166 {
4167  yy_state_type yy_current_state;
4168  char *yy_cp, *yy_bp;
4169  int yy_act;
4170 
4171 
4172 
4173 
4174  /* Switch into a new start state if the parser */
4175  /* just told us that we've read a field name */
4176  /* and should expect a field value (or IS) */
4177  if (expectToken != 0) {
4178  if (yy_flex_debug)
4179  fprintf(stderr,"LEX--> Start State %d\n", expectToken);
4180 
4181  /*
4182  * Annoying. This big switch is necessary because
4183  * LEX wants to assign particular numbers to start
4184  * tokens, and YACC wants to define all the tokens
4185  * used, too. Sigh.
4186  */
4187  switch(expectToken) {
4188  case SFBOOL: BEGIN SFB; break;
4189  case SFCOLOR: BEGIN SFC; break;
4190  case SFFLOAT: BEGIN SFF; break;
4191  case SFIMAGE: BEGIN SFIMG; break;
4192  case SFINT32: BEGIN SFI; break;
4193  case SFROTATION: BEGIN SFR; break;
4194  case SFSTRING: BEGIN SFS; break;
4195  case SFTIME: BEGIN SFT; break;
4196  case SFVEC2F: BEGIN SFV2; break;
4197  case SFVEC3F: BEGIN SFV3; break;
4198  case MFCOLOR: BEGIN MFC; break;
4199  case MFFLOAT: BEGIN MFF; break;
4200  case MFINT32: BEGIN MFI; break;
4201  case MFROTATION: BEGIN MFR; break;
4202  case MFSTRING: BEGIN MFS; break;
4203  case MFVEC2F: BEGIN MFV2; break;
4204  case MFVEC3F: BEGIN MFV3; break;
4205 
4206  /* SFNode and MFNode are special. Here the lexer just returns */
4207  /* "marker tokens" so the parser knows what type of field is */
4208  /* being parsed; unlike the other fields, parsing of SFNode/MFNode */
4209  /* field happens in the parser. */
4210  case MFNODE: expectToken = 0; return MFNODE;
4211  case SFNODE: expectToken = 0; return SFNODE;
4212 
4213  default: yyerror("ACK: Bad expectToken"); break;
4214  }
4215  }
4216 
4217 
4218  /* This is more complicated than they really need to be because */
4219  /* I was ambitious and made the whitespace-matching rule aggressive */
4220 
4221  if ( yy_init )
4222  {
4223 #ifdef YY_USER_INIT
4224  YY_USER_INIT;
4225 #endif
4226 
4227  if ( ! yy_start )
4228  yy_start = 1; /* first start state */
4229 
4230  if ( ! yyin )
4231  yyin = stdin;
4232 
4233  if ( ! yyout )
4234  yyout = stdout;
4235 
4236  if ( yy_current_buffer )
4238  else
4241 
4243 
4244  yy_init = 0;
4245  }
4246 
4247  while ( true ) /* loops until end-of-file is reached */
4248  {
4249  yy_cp = yy_c_buf_p;
4250 
4251  /* Support of yytext. */
4252  *yy_cp = yy_hold_char;
4253 
4254  /* yy_bp points to the position in yy_ch_buf of the start of
4255  * the current run.
4256  */
4257  yy_bp = yy_cp;
4258 
4259  yy_current_state = yy_start;
4260  yy_match:
4261  do
4262  {
4263  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
4264  if ( yy_accept[yy_current_state] )
4265  {
4266  yy_last_accepting_state = yy_current_state;
4267  yy_last_accepting_cpos = yy_cp;
4268  }
4269  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4270  {
4271  yy_current_state = (int) yy_def[yy_current_state];
4272  if ( yy_current_state >= 949 )
4273  yy_c = yy_meta[(unsigned int) yy_c];
4274  }
4275  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
4276  ++yy_cp;
4277  }
4278  while ( yy_base[yy_current_state] != 7663 );
4279 
4280  yy_find_action:
4281  yy_act = yy_accept[yy_current_state];
4282 
4284 
4285 
4286  do_action: /* This label is used only to access EOF actions. */
4287 
4288  if ( yy_flex_debug )
4289  {
4290  if ( yy_act == 0 )
4291  fprintf( stderr, "--scanner backing up\n" );
4292  else if ( yy_act < 49 )
4293  fprintf( stderr, "--accepting rule at line %d (\"%s\")\n",
4294  yy_rule_linenum[yy_act], yytext );
4295  else if ( yy_act == 49 )
4296  fprintf( stderr, "--accepting default rule (\"%s\")\n",
4297  yytext );
4298  else if ( yy_act == 50 )
4299  fprintf( stderr, "--(end of buffer or a NUL)\n" );
4300  else
4301  fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
4302  }
4303 
4304  switch ( yy_act )
4305  { /* beginning of action switch */
4306  case 0: /* must back up */
4307  /* undo the effects of YY_DO_BEFORE_ACTION */
4308  *yy_cp = yy_hold_char;
4309  yy_cp = yy_last_accepting_cpos;
4310  yy_current_state = yy_last_accepting_state;
4311  goto yy_find_action;
4312 
4313  case 1:
4315  { BEGIN NODE; }
4316  YY_BREAK
4317  /* The lexer is in the NODE state when parsing nodes, either */
4318  /* top-level nodes in the .wrl file, in a prototype implementation, */
4319  /* or when parsing the contents of SFNode or MFNode fields. */
4320  case 2:
4322  { return PROTO; }
4323  case 3:
4325  { return EXTERNPROTO; }
4326  case 4:
4328  { return DEF; }
4329  case 5:
4331  { return USE; }
4332  case 6:
4334  { return TO; }
4335  case 7:
4337  { return IS; }
4338  case 8:
4340  { return ROUTE; }
4341  case 9:
4343  { return SFN_NULL; }
4344  case 10:
4346  { return EVENTIN; }
4347  case 11:
4349  { return EVENTOUT; }
4350  case 12:
4352  { return FIELD; }
4353  case 13:
4355  { return EXPOSEDFIELD; }
4356  /* Legal identifiers: */
4357  case 14:
4359  {
4360  yylval.string = vtkVRMLAllocator::StrDup(yytext);
4361  return IDENTIFIER; }
4362  /* All fields may have an IS declaration: */
4363  case 15:
4365  { BEGIN NODE;
4366  expectToken = 0;
4367  yyless(0);
4368  }
4369  YY_BREAK
4370  case 16:
4372  { BEGIN NODE;
4373  expectToken = 0;
4374  yyless(0); /* put back the IS */
4375  }
4376  YY_BREAK
4377  /* All MF field types other than MFNode are completely parsed here */
4378  /* in the lexer, and one token is returned to the parser. They all */
4379  /* share the same rules for open and closing brackets: */
4380  case 17:
4382  { if (parsing_mf) yyerror("Double [");
4383  parsing_mf = 1;
4384  yylval.vec2f = self->FloatArrayNew();
4386  }
4387  YY_BREAK
4388  case 18:
4390  { if (parsing_mf) yyerror("Double [");
4391  parsing_mf = 1;
4392  yylval.mfint32 = self->IdTypeArrayNew();
4393  }
4394  YY_BREAK
4395  case 19:
4397  { if (parsing_mf) yyerror("Double [");
4398  parsing_mf = 1;
4399  yylval.vec3f = self->PointsNew();
4400  }
4401  YY_BREAK
4402  case 20:
4404  { if (!parsing_mf) yyerror("Unmatched ]");
4405  int tokenFieldType = expectToken;
4406  BEGIN NODE;
4407  parsing_mf = 0;
4408  expectToken = 0;
4409  return tokenFieldType;
4410  }
4411  case 21:
4413  { BEGIN NODE; expectToken = 0; yylval.sfint = 1; return SFBOOL; }
4414  case 22:
4416  { BEGIN NODE; expectToken = 0; yylval.sfint = 0; return SFBOOL; }
4417  case 23:
4419  { BEGIN NODE; expectToken = 0;
4420  yylval.sfint = atoi(yytext);
4421  return SFINT32;
4422  }
4423  case 24:
4425  { if (parsing_mf) {
4426  int num;
4427  num = atoi(yytext);
4429  }
4430  else {
4431  BEGIN NODE; expectToken = 0; return MFINT32;
4432  }
4433  }
4434  YY_BREAK
4435  /* All the floating-point types are pretty similar: */
4436  case 25:
4438  { BEGIN NODE; expectToken = 0; float num;
4439  sscanf(yytext, "%f", &num);
4440  yylval.sffloat = num;
4441  return SFFLOAT; }
4442  case 26:
4444  { if (parsing_mf) ; /* Add to array... */
4445  else {
4446  /* No open bracket means a single value: */
4447  BEGIN NODE; expectToken = 0; return MFFLOAT;
4448  }
4449  }
4450  YY_BREAK
4451  case 27:
4453  { BEGIN NODE; expectToken = 0; return SFVEC2F; }
4454  case 28:
4456  {
4457  if (parsing_mf)
4458  {
4459  // .. add to array...
4460  float num[2];
4461  num[0] = atof(strtok(yytext, " \t"));
4462  num[1] = atof(strtok(nullptr, " \t"));
4463  // equivalent to: sscanf(yytext, "%f %f", &num[0], &num[1]);
4465  }
4466  else
4467  {
4468  BEGIN NODE; expectToken = 0;
4469  return MFVEC2F;
4470  }
4471  }
4472  YY_BREAK
4473  case 29:
4475  { BEGIN NODE; expectToken = 0;
4476  float num[3];
4477  yylval.vec3f = self->PointsNew();
4478  num[0] = atof(strtok(yytext, " \t"));
4479  num[1] = atof(strtok(nullptr, " \t"));
4480  num[2] = atof(strtok(nullptr, " \t"));
4481  //sscanf(yytext, "%f %f %f", &num[0], &num[1], &num[2]);
4482  yylval.vec3f->InsertPoint(0, num);
4483  return SFVEC3F; }
4484  case 30:
4486  { if (parsing_mf) { /* .. add to array... */
4487  float num[3];
4488  num[0] = atof(strtok(yytext, " \t"));
4489  num[1] = atof(strtok(nullptr, " \t"));
4490  num[2] = atof(strtok(nullptr, " \t"));
4491  //sscanf(yytext, "%f %f %f", &num[0], &num[1], &num[2]);
4493  //return MFVEC3F;
4494  }
4495  else {
4496  BEGIN NODE; expectToken = 0;
4497  return MFVEC3F;
4498  }
4499  }
4500  YY_BREAK
4501  case 31:
4503  { BEGIN NODE; expectToken = 0;
4504  yylval.vec4f[0] = atof(strtok(yytext, " \t"));
4505  yylval.vec4f[1] = atof(strtok(nullptr, " \t"));
4506  yylval.vec4f[2] = atof(strtok(nullptr, " \t"));
4507  yylval.vec4f[3] = atof(strtok(nullptr, " \t"));
4508  return SFROTATION; }
4509  case 32:
4511  { if (parsing_mf) ; /* .. add to array... */
4512  else {
4513  BEGIN NODE; expectToken = 0; return MFROTATION;
4514  }
4515  }
4516  YY_BREAK
4517  case 33:
4519  { BEGIN NODE; expectToken = 0;
4520  float num[3];
4521  yylval.vec3f = self->PointsNew();
4522  num[0] = atof(strtok(yytext, " \t"));
4523  num[1] = atof(strtok(nullptr, " \t"));
4524  num[2] = atof(strtok(nullptr, " \t"));
4525  //sscanf(yytext, "%f %f %f", &num[0], &num[1], &num[2]);
4526  yylval.vec3f->InsertPoint(0, num);
4527  return SFCOLOR; }
4528  case 34:
4530  { if (parsing_mf) { /* .. add to array... */
4531  float num[3];
4532  num[0] = atof(strtok(yytext, " \t"));
4533  num[1] = atof(strtok(nullptr, " \t"));
4534  num[2] = atof(strtok(nullptr, " \t"));
4536  }
4537  else {
4538  BEGIN NODE; expectToken = 0; return MFCOLOR;
4539  }
4540  }
4541  YY_BREAK
4542  case 35:
4544  { BEGIN NODE; expectToken = 0; return SFTIME; }
4545  /* SFString/MFString */
4546  case 36:
4548  { BEGIN IN_SFS; }
4549  YY_BREAK
4550  case 37:
4552  { BEGIN IN_MFS; }
4553  YY_BREAK
4554  /* Anything besides open-quote (or whitespace) is an error: */
4555  case 38:
4557  { yyerror("String missing open-quote");
4558  BEGIN NODE; expectToken = 0; return SFSTRING;
4559  }
4560  /* Expect open-quote, open-bracket, or whitespace: */
4561  case 39:
4563  { yyerror("String missing open-quote");
4564  BEGIN NODE; expectToken = 0; return MFSTRING;
4565  }
4566  /* Backslashed-quotes are OK: */
4567  case 40:
4569  ;
4570  YY_BREAK
4571  /* Gobble up anything besides quotes and newlines. */
4572  /* Newlines are legal in strings, but we exclude them here so */
4573  /* that line number are counted correctly by the catch-all newline */
4574  /* rule that applies to everything. */
4575  case 41:
4577  ;
4578  YY_BREAK
4579  /* Quote ends the string: */
4580  case 42:
4582  { BEGIN NODE; expectToken = 0; return SFSTRING; }
4583  case 43:
4585  { if (parsing_mf) BEGIN MFS; /* ... add to array ... */
4586  else {
4587  BEGIN NODE; expectToken = 0; return MFSTRING;
4588  }
4589  }
4590  YY_BREAK
4591  /* SFImage: width height numComponents then width*height integers: */
4592  case 44:
4594  { int w, h;
4595  sscanf(yytext, "%d %d", &w, &h);
4596  sfImageIntsExpected = 1+w*h;
4597  sfImageIntsParsed = 0;
4598  BEGIN IN_SFIMG;
4599  }
4600  YY_BREAK
4601  case 45:
4603  { ++sfImageIntsParsed;
4605  BEGIN NODE; expectToken = 0; return SFIMAGE;
4606  }
4607  }
4608  YY_BREAK
4609  /* Whitespace and catch-all rules apply to all start states: */
4610  case 46:
4612  ;
4613  YY_BREAK
4614  /* This is also whitespace, but we'll keep track of line number */
4615  /* to report in errors: */
4616  case 47:
4618  { ++currentLineNumber; }
4619  YY_BREAK
4620  /* This catch-all rule catches anything not covered by any of */
4621  /* the above: */
4622  case 48:
4624  { return yytext[0]; }
4625  case 49:
4627  YY_FATAL_ERROR( "flex scanner jammed" );
4628  YY_BREAK
4629  case YY_STATE_EOF(INITIAL):
4630  case YY_STATE_EOF(NODE):
4631  case YY_STATE_EOF(SFB):
4632  case YY_STATE_EOF(SFC):
4633  case YY_STATE_EOF(SFF):
4634  case YY_STATE_EOF(SFIMG):
4635  case YY_STATE_EOF(SFI):
4636  case YY_STATE_EOF(SFR):
4637  case YY_STATE_EOF(SFS):
4638  case YY_STATE_EOF(SFT):
4639  case YY_STATE_EOF(SFV2):
4640  case YY_STATE_EOF(SFV3):
4641  case YY_STATE_EOF(MFC):
4642  case YY_STATE_EOF(MFF):
4643  case YY_STATE_EOF(MFI):
4644  case YY_STATE_EOF(MFR):
4645  case YY_STATE_EOF(MFS):
4646  case YY_STATE_EOF(MFV2):
4647  case YY_STATE_EOF(MFV3):
4648  case YY_STATE_EOF(IN_SFS):
4649  case YY_STATE_EOF(IN_MFS):
4650  case YY_STATE_EOF(IN_SFIMG):
4651  yyterminate();
4652 
4653  case YY_END_OF_BUFFER:
4654  {
4655  /* Amount of text matched not including the EOB char. */
4656  int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
4657 
4658  /* Undo the effects of YY_DO_BEFORE_ACTION. */
4659  *yy_cp = yy_hold_char;
4660 
4662  {
4663  /* We're scanning a new file or input source. It's
4664  * possible that this happened because the user
4665  * just pointed yyin at a new source and called
4666  * yylex(). If so, then we have to assure
4667  * consistency between yy_current_buffer and our
4668  * globals. Here is the right place to do so, because
4669  * this is the first action (other than possibly a
4670  * back-up) that will match for the new input source.
4671  */
4675  }
4676 
4677  /* Note that here we test for yy_c_buf_p "<=" to the position
4678  * of the first EOB in the buffer, since yy_c_buf_p will
4679  * already have been incremented past the NUL character
4680  * (since all states make transitions on EOB to the
4681  * end-of-buffer state). Contrast this with the test
4682  * in input().
4683  */
4684  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
4685  { /* This was really a NUL. */
4686  yy_state_type yy_next_state;
4687 
4688  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
4689 
4690  yy_current_state = yy_get_previous_state();
4691 
4692  /* Okay, we're now positioned to make the NUL
4693  * transition. We couldn't have
4694  * yy_get_previous_state() go ahead and do it
4695  * for us because it doesn't know how to deal
4696  * with the possibility of jamming (and we don't
4697  * want to build jamming into it because then it
4698  * will run more slowly).
4699  */
4700 
4701  yy_next_state = yy_try_NUL_trans( yy_current_state );
4702 
4703  yy_bp = yytext_ptr + YY_MORE_ADJ;
4704 
4705  if ( yy_next_state )
4706  {
4707  /* Consume the NUL. */
4708  yy_cp = ++yy_c_buf_p;
4709  yy_current_state = yy_next_state;
4710  goto yy_match;
4711  }
4712 
4713  else
4714  {
4715  yy_cp = yy_c_buf_p;
4716  goto yy_find_action;
4717  }
4718  }
4719 
4720  else switch ( yy_get_next_buffer() )
4721  {
4722  case EOB_ACT_END_OF_FILE:
4723  {
4725 
4726  if ( yywrap() )
4727  {
4728  /* Note: because we've taken care in
4729  * yy_get_next_buffer() to have set up
4730  * yytext, we can now set up
4731  * yy_c_buf_p so that if some total
4732  * hoser (like flex itself) wants to
4733  * call the scanner after we return the
4734  * YY_NULL, it'll still work - another
4735  * YY_NULL will get returned.
4736  */
4738 
4739  yy_act = YY_STATE_EOF(YY_START);
4740  goto do_action;
4741  }
4742 
4743  else
4744  {
4746  YY_NEW_FILE;
4747  }
4748  break;
4749  }
4750 
4751  case EOB_ACT_CONTINUE_SCAN:
4752  yy_c_buf_p =
4753  yytext_ptr + yy_amount_of_matched_text;
4754 
4755  yy_current_state = yy_get_previous_state();
4756 
4757  yy_cp = yy_c_buf_p;
4758  yy_bp = yytext_ptr + YY_MORE_ADJ;
4759  goto yy_match;
4760 
4761  case EOB_ACT_LAST_MATCH:
4762  yy_c_buf_p =
4764 
4765  yy_current_state = yy_get_previous_state();
4766 
4767  yy_cp = yy_c_buf_p;
4768  yy_bp = yytext_ptr + YY_MORE_ADJ;
4769  goto yy_find_action;
4770  }
4771  break;
4772  }
4773 
4774  default:
4776  "fatal flex scanner internal error--no action found" );
4777  } /* end of action switch */
4778  } /* end of scanning one token */
4779 } /* end of yylex */
4780 
4781 
4782 /* yy_get_next_buffer - try to read in a new buffer
4783  *
4784  * Returns a code representing an action:
4785  * EOB_ACT_LAST_MATCH -
4786  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
4787  * EOB_ACT_END_OF_FILE - end of file
4788  */
4789 
4791 {
4792  char *dest = yy_current_buffer->yy_ch_buf;
4793  char *source = yytext_ptr - 1; /* copy prev. char, too */
4794  int number_to_move, i;
4795  int ret_val;
4796 
4799  "fatal flex scanner internal error--end of buffer missed" );
4800 
4801  if ( yy_current_buffer->yy_fill_buffer == 0 )
4802  { /* Don't try to fill the buffer, so this is an EOF. */
4803  if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
4804  {
4805  /* We matched a singled character, the EOB, so
4806  * treat this as a final EOF.
4807  */
4808  return EOB_ACT_END_OF_FILE;
4809  }
4810 
4811  else
4812  {
4813  /* We matched some text prior to the EOB, first
4814  * process it.
4815  */
4816  return EOB_ACT_LAST_MATCH;
4817  }
4818  }
4819 
4820  /* Try to read more data. */
4821 
4822  /* First move last chars to start of buffer. */
4823  number_to_move = yy_c_buf_p - yytext_ptr;
4824 
4825  for ( i = 0; i < number_to_move; ++i )
4826  *(dest++) = *(source++);
4827 
4829  /* don't do the read, it's not guaranteed to return an EOF,
4830  * just force an EOF
4831  */
4832  yy_n_chars = 0;
4833 
4834  else
4835  {
4836  int num_to_read =
4837  yy_current_buffer->yy_buf_size - number_to_move - 1;
4838 
4839  while ( num_to_read <= 0 )
4840  { /* Not enough room in the buffer - grow it. */
4841 #ifdef YY_USES_REJECT
4843  "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
4844 #else
4845 
4846  /* just a shorter name for the current buffer */
4848 
4849  int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
4850 
4851  b->yy_buf_size *= 2;
4852  b->yy_ch_buf = (char *)
4853  yy_flex_realloc( (void *) b->yy_ch_buf,
4854  b->yy_buf_size );
4855 
4856  if ( ! b->yy_ch_buf )
4858  "fatal error - scanner input buffer overflow" );
4859 
4860  yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
4861 
4862  num_to_read = yy_current_buffer->yy_buf_size -
4863  number_to_move - 1;
4864 #endif
4865  }
4866 
4867  if ( num_to_read > YY_READ_BUF_SIZE )
4868  num_to_read = YY_READ_BUF_SIZE;
4869 
4870  /* Read in more data. */
4871  YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
4872  yy_n_chars, num_to_read );
4873  }
4874 
4875  if ( yy_n_chars == 0 )
4876  {
4877  if ( number_to_move - YY_MORE_ADJ == 1 )
4878  {
4879  ret_val = EOB_ACT_END_OF_FILE;
4880  yyrestart( yyin );
4881  }
4882 
4883  else
4884  {
4885  ret_val = EOB_ACT_LAST_MATCH;
4888  }
4889  }
4890 
4891  else
4892  ret_val = EOB_ACT_CONTINUE_SCAN;
4893 
4894  yy_n_chars += number_to_move;
4897 
4898  /* yytext begins at the second character in yy_ch_buf; the first
4899  * character is the one which preceded it before reading in the latest
4900  * buffer; it needs to be kept around in case it's a newline, so
4901  * yy_get_previous_state() will have with '^' rules active.
4902  */
4903 
4905 
4906  return ret_val;
4907 }
4908 
4909 
4910 /* yy_get_previous_state - get the state just before the EOB char was reached */
4911 
4913 {
4914  yy_state_type yy_current_state;
4915  char *yy_cp;
4916 
4917  yy_current_state = yy_start;
4918 
4919  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
4920  {
4921  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
4922  if ( yy_accept[yy_current_state] )
4923  {
4924  yy_last_accepting_state = yy_current_state;
4925  yy_last_accepting_cpos = yy_cp;
4926  }
4927  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4928  {
4929  yy_current_state = (int) yy_def[yy_current_state];
4930  if ( yy_current_state >= 949 )
4931  yy_c = yy_meta[(unsigned int) yy_c];
4932  }
4933  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
4934  }
4935 
4936  return yy_current_state;
4937 }
4938 
4939 
4940 /* yy_try_NUL_trans - try to make a transition on the NUL character
4941  *
4942  * synopsis
4943  * next_state = yy_try_NUL_trans( current_state );
4944  */
4945 
4947 {
4948  int yy_is_jam;
4949  char *yy_cp = yy_c_buf_p;
4950 
4951  YY_CHAR yy_c = 1;
4952  if ( yy_accept[yy_current_state] )
4953  {
4954  yy_last_accepting_state = yy_current_state;
4955  yy_last_accepting_cpos = yy_cp;
4956  }
4957  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4958  {
4959  yy_current_state = (int) yy_def[yy_current_state];
4960  if ( yy_current_state >= 949 )
4961  yy_c = yy_meta[(unsigned int) yy_c];
4962  }
4963  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
4964  yy_is_jam = (yy_current_state == 948);
4965 
4966  return yy_is_jam ? 0 : yy_current_state;
4967 }
4968 
4969 
4970 
4971 inline void vtkVRMLYaccData::yyrestart( FILE *input_file )
4972 {
4973  if ( ! yy_current_buffer )
4975 
4976  yy_init_buffer( yy_current_buffer, input_file );
4978 }
4979 
4980 
4982 {
4983  if ( yy_current_buffer == new_buffer )
4984  return;
4985 
4986  if ( yy_current_buffer )
4987  {
4988  /* Flush out information for old buffer. */
4992  }
4993 
4994  yy_current_buffer = new_buffer;
4996 
4997  /* We don't actually know whether we did this switch during
4998  * EOF (yywrap()) processing, but the only time this flag
4999  * is looked at is after yywrap() is called, so it's safe
5000  * to go ahead and always set it.
5001  */
5003 }
5004 
5005 
5007 {
5012 }
5013 
5014 
5016 {
5017  YY_BUFFER_STATE b;
5018 
5019  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
5020 
5021  if ( ! b )
5022  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
5023 
5024  b->yy_buf_size = size;
5025 
5026  /* yy_ch_buf has to be 2 characters longer than the size given because
5027  * we need to put in 2 end-of-buffer characters.
5028  */
5029  b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
5030 
5031  if ( ! b->yy_ch_buf )
5032  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
5033 
5034  yy_init_buffer( b, file );
5035 
5036  return b;
5037 }
5038 
5039 
5041 {
5042  if ( b == yy_current_buffer )
5043  yy_current_buffer = (YY_BUFFER_STATE) nullptr;
5044 
5045  yy_flex_free( (void *) b->yy_ch_buf );
5046  yy_flex_free( (void *) b );
5047 }
5048 
5049 
5051 {
5052  b->yy_input_file = file;
5053 
5054  /* We put in the '\n' and start reading from [1] so that an
5055  * initial match-at-newline will be true.
5056  */
5057 
5058  b->yy_ch_buf[0] = '\n';
5059  b->yy_n_chars = 1;
5060 
5061  /* We always need two end-of-buffer characters. The first causes
5062  * a transition to the end-of-buffer state. The second causes
5063  * a jam in that state.
5064  */
5067 
5068  b->yy_buf_pos = &b->yy_ch_buf[1];
5069 
5070  b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
5071 
5072  b->yy_fill_buffer = 1;
5073 
5075 }
5076 
5077 
5078 inline void vtkVRMLYaccData::yy_fatal_error( const char msg[] )
5079 {
5080  (void) fprintf( stderr, "%s\n", msg );
5081  exit( 1 );
5082 }
5083 
5084 
5085 
5086 /* Redefine yyless() so it works in section 3 code. */
5087 
5088 #undef yyless
5089 #define yyless(n) \
5090  do \
5091  { \
5092  /* Undo effects of setting up yytext. */ \
5093  yytext[yyleng] = yy_hold_char; \
5094  yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
5095  yy_hold_char = *yy_c_buf_p; \
5096  *yy_c_buf_p = '\0'; \
5097  yyleng = n; \
5098  } \
5099  while ( 0 )
5100 
5101 
5102 /* Internal utility routines. */
5103 
5104 #ifndef yytext_ptr
5105 #ifdef YY_USE_PROTOS
5106 static void yy_flex_strncpy( char *s1, const char *s2, int n )
5107 #else
5108  static void yy_flex_strncpy( s1, s2, n )
5109  char *s1;
5110 const char *s2;
5111 int n;
5112 #endif
5113 {
5114  int i;
5115  for ( i = 0; i < n; ++i )
5116  s1[i] = s2[i];
5117 }
5118 #endif
5119 
5120 
5121 inline void *vtkVRMLYaccData::yy_flex_alloc( unsigned int size )
5122 {
5123  return (void *) malloc( size );
5124 }
5125 
5126 inline void *vtkVRMLYaccData::yy_flex_realloc( void *ptr, unsigned int size )
5127 {
5128  return (void *) realloc( ptr, size );
5129 }
5130 
5131 inline void vtkVRMLYaccData::yy_flex_free( void *ptr )
5132 {
5133  free( ptr );
5134 }
5135 // End of Auto-generated Lexer Code
5136 
5137 
5138 // Used by the lex input to get characters. Needed to read in memory structure
5139 
5140 inline void vtkVRMLYaccData::memyyInput(char *buf, int &result, int max_size,
5141  vtkVRMLYaccData* self) {
5142 
5143  result = static_cast<int>(
5144  strlen(strncpy(buf, standardNodes[self->memyyInput_i], max_size)));
5145  self->memyyInput_j = result - static_cast<int>(
5146  strlen(standardNodes[self->memyyInput_i]));
5147  if ( self->memyyInput_j == 0 )
5148  {
5149  self->memyyInput_i++;
5150  }
5151 }
5152 
5153 // Needed to reset the lex input routine to default.
5154 inline void vtkVRMLYaccData::defyyInput(char *buf, int &result, int max_size,
5155  vtkVRMLYaccData* self) {
5156  if ( self->yy_current_buffer->yy_is_interactive )
5157  {
5158  int c = getc( self->yyin );
5159  result = c == EOF ? 0 : 1;
5160  buf[0] = (char) c;
5161  }
5162  else if( ((result = static_cast<int>(fread( buf, 1, max_size, self->yyin ))) == 0)
5163  && ferror( self->yyin ) )
5164  {
5165  self->yy_fatal_error( "input in flex scanner failed" );
5166  }
5167 }
5168 
5169 
5170 VTK_ABI_NAMESPACE_END
5171 #endif
5172 // VTK-HeaderTest-Exclude: vtkVRMLImporter_Yacc.h
int hasEventOut(const char *name) const
void addField(const char *name, int type)
void addExposedField(const char *name, int type)
void addEventIn(const char *name, int type)
int hasEventIn(const char *name) const
int hasField(const char *name) const
void addEventOut(const char *name, int type)
VrmlNodeType(const char *nm)
int hasExposedField(const char *name) const
const char * getName() const
vtkIdType InsertNextTuple(const float *tuple) override
Insert the data tuple at the end of the array and return the tuple index at which the data was insert...
dynamic, self-adjusting array of float
void SetNumberOfComponents(int num) override
Set/Get the dimension (n) of the components.
vtkIdType InsertNextValue(ValueType value)
Insert data at the end of the array.
dynamic, self-adjusting array of vtkIdType
abstract base class for most VTK objects
Definition: vtkObject.h:161
represent and manipulate 3D points
Definition: vtkPoints.h:138
void InsertPoint(vtkIdType id, const float x[3])
Insert point into object.
Definition: vtkPoints.h:275
vtkIdType InsertNextPoint(const float x[3])
Insert point into next available slot.
Definition: vtkPoints.h:309
Computes the portion of a dataset which is inside a selection.
imports VRML 2.0 files.
vtkVRMLUseStruct(char *n, vtkObject *o)
int yyparse(vtkVRMLImporter *self)
void yyerror(const char *)
vtkVRMLVectorType< VrmlNodeType::FieldRec * > * currentField
yy_state_type yy_last_accepting_state
struct yy_buffer_state * YY_BUFFER_STATE
yy_state_type yy_get_previous_state()
void beginProto(const char *)
void(* theyyInput)(char *, int &, int, vtkVRMLYaccData *)
yy_state_type yy_try_NUL_trans(yy_state_type current_state)
struct vtkVRMLYaccData::yyltype yyltype
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
void * yy_flex_alloc(unsigned int)
void yyrestart(FILE *input_file)
vtkVRMLVectorType< vtkVRMLUseStruct * > * useList
int addField(const char *type, const char *name)
vtkVRMLVectorType< VrmlNodeType * > * CurrentProtoStack
static void memyyInput(char *buf, int &result, int max_size, vtkVRMLYaccData *self)
int add(void(VrmlNodeType::*)(const char *, int), const char *, const char *)
int addEventOut(const char *type, const char *name)
int addExposedField(const char *type, const char *name)
void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
void yy_delete_buffer(YY_BUFFER_STATE b)
vtkVRMLVectorType< VrmlNodeType * > * typeList
YY_BUFFER_STATE yy_current_buffer
void addToNameSpace(VrmlNodeType *)
int addEventIn(const char *type, const char *name)
static void defyyInput(char *buf, int &result, int max_size, vtkVRMLYaccData *self)
void yy_fatal_error(const char msg[])
int yylex(vtkVRMLImporter *self)
const VrmlNodeType * find(const char *nm)
void * yy_flex_realloc(void *, unsigned int)
int fieldType(const char *type)
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
@ length
Definition: vtkX3D.h:393
@ type
Definition: vtkX3D.h:516
@ name
Definition: vtkX3D.h:219
@ size
Definition: vtkX3D.h:253
const VrmlNodeType * nodeType
YY_BUFFER_STATUS_STATE yy_buffer_status
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
#define YY_NEW_FILE
#define MFI
#define YYLTYPE
#define SFVEC2F
static const short yycheck[]
#define SFFLOAT
static const short int yy_accept[949]
#define YYMAXDEPTH
#define SFS
#define YYNTBASE
#define SFB
#define USE
static const int yy_ec[256]
#define MFVEC3F
static const char yytranslate[]
#define MFV3
static const short yydefgoto[]
#define MFV2
#define MFVEC2F
#define SFBOOL
static const short int yy_base[1090]
#define DEF
#define YYEOF
#define YYABORT
static const short yyprhs[]
#define YY_BREAK
#define IN_SFS
#define IDENTIFIER
#define SFVEC3F
#define SFROTATION
#define MFC
#define SFIMAGE
#define SFN_NULL
#define SFF
#define MFFLOAT
#define SFV3
#define MFF
#define YYTRANSLATE(x)
#define SFT
#define ROUTE
#define YY_USER_ACTION
#define SFCOLOR
#define YYFINAL
#define SFTIME
#define YY_MORE_ADJ
#define MFR
#define IN_MFS
#define MFNODE
static void yy_memcpy(char *from, char *to, int count)
#define yytext_ptr
#define SFNODE
static const int yy_meta[48]
#define EOB_ACT_END_OF_FILE
#define MFCOLOR
static const short yytable[]
#define MFINT32
#define SFI
#define MFS
static const short yyrline[]
#define IN_SFIMG
static const short yypact[]
#define YY_START
#define EXTERNPROTO
#define EXPOSEDFIELD
static const short yypgoto[]
static const short yyr1[]
#define NODE
static const short yydefact[]
#define EVENTOUT
#define INITIAL
#define SFV2
#define PROTO
#define YYACCEPT
#define EVENTIN
#define YY_READ_BUF_SIZE
#define YY_INPUT(buf, result, max_size)
static const short yyr2[]
static const short int yy_def[1090]
#define YY_END_OF_BUFFER
#define YY_STATE_EOF(state)
#define BEGIN
static const char *const yytname[]
#define YY_END_OF_BUFFER_CHAR
#define YYFLAG
#define FIELD
static const short int yy_nxt[7711]
#define SFC
#define YY_FATAL_ERROR(msg)
#define yyterminate()
#define SFSTRING
#define YY_DO_BEFORE_ACTION
#define EOB_ACT_LAST_MATCH
#define MFROTATION
#define IS
#define YYTERROR
#define SFIMG
static const short yyrhs[]
#define EOB_ACT_CONTINUE_SCAN
#define YYEMPTY
#define yyless(n)
#define YYLAST
static const short int yy_chk[7711]
#define YY_BUF_SIZE
#define SFINT32
#define YYINITDEPTH
#define YY_SC_TO_UI(c)
#define TO
static const short int yy_rule_linenum[49]
#define SFR
#define MFSTRING