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