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