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