← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily

« back to all changes in this revision

Viewing changes to COLLADASaxFrameworkLoader/include/generated15/COLLADASaxFWLColladaParserAutoGen15ValidationData.h

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
COLLADASaxFrameworkLoader/include/generated15/COLLADASaxFWLColladaParserAutoGen15ValidationData.h
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of COLLADASaxFrameworkLoader.
 
5
 
 
6
    Licensed under the MIT Open Source License,
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
 
 
11
 
 
12
 
 
13
#ifndef __COLLADASAXFWL15_COLLADAPARSERAUTOGEN15VALIDATIONDATA_H__
 
14
#define __COLLADASAXFWL15_COLLADAPARSERAUTOGEN15VALIDATIONDATA_H__
 
15
 
 
16
 
 
17
namespace COLLADASaxFWL15
 
18
{
 
19
 
 
20
 
 
21
ParserError::ErrorType validate__version_enum( ParserString value );
 
22
ParserError::ErrorType validate__version_enum( const ParserChar* value, size_t length );
 
23
ParserError::ErrorType validate__version_enum__stream( const ParserChar* value, size_t length );
 
24
ParserError::ErrorType validate__version_enum__streamEnd( const ParserChar* value, size_t length );
 
25
 
 
26
struct COLLADA__ValidationData
 
27
{
 
28
    size_t validation_current_state;
 
29
    size_t asset;
 
30
    size_t library_animations;
 
31
    size_t library_animation_clips;
 
32
    size_t library_cameras;
 
33
    size_t library_controllers;
 
34
    size_t library_geometries;
 
35
    size_t library_effects;
 
36
    size_t library_force_fields;
 
37
    size_t library_images;
 
38
    size_t library_lights;
 
39
    size_t library_materials;
 
40
    size_t library_nodes;
 
41
    size_t library_physics_materials;
 
42
    size_t library_physics_models;
 
43
    size_t library_physics_scenes;
 
44
    size_t library_visual_scenes;
 
45
    size_t library_joints;
 
46
    size_t library_kinematics_models;
 
47
    size_t library_articulated_systems;
 
48
    size_t library_kinematics_scenes;
 
49
    size_t library_formulas;
 
50
    size_t scene;
 
51
    size_t extra;
 
52
};
 
53
 
 
54
struct asset__ValidationData
 
55
{
 
56
    size_t contributor;
 
57
    size_t coverage;
 
58
    size_t created;
 
59
    size_t keywords;
 
60
    size_t modified;
 
61
    size_t revision;
 
62
    size_t subject;
 
63
    size_t title;
 
64
    size_t unit;
 
65
    size_t up_axis;
 
66
    size_t extra;
 
67
};
 
68
 
 
69
struct contributor__ValidationData
 
70
{
 
71
    size_t author;
 
72
    size_t author_email;
 
73
    size_t author_website;
 
74
    size_t authoring_tool;
 
75
    size_t comments;
 
76
    size_t copyright;
 
77
    size_t source_data;
 
78
};
 
79
 
 
80
ParserError::ErrorType validate__author_email( ParserString value );
 
81
ParserError::ErrorType validate__author_email( const ParserChar* value, size_t length );
 
82
ParserError::ErrorType validate__author_email__stream( const ParserChar* value, size_t length );
 
83
ParserError::ErrorType validate__author_email__streamEnd( const ParserChar* value, size_t length );
 
84
 
 
85
struct coverage__ValidationData
 
86
{
 
87
    size_t geographic_location;
 
88
};
 
89
 
 
90
struct geographic_location__ValidationData
 
91
{
 
92
    size_t longitude;
 
93
    size_t latitude;
 
94
    size_t altitude;
 
95
};
 
96
 
 
97
ParserError::ErrorType validate__altitude_mode_enum( ParserString value );
 
98
ParserError::ErrorType validate__altitude_mode_enum( const ParserChar* value, size_t length );
 
99
ParserError::ErrorType validate__altitude_mode_enum__stream( const ParserChar* value, size_t length );
 
100
ParserError::ErrorType validate__altitude_mode_enum__streamEnd( const ParserChar* value, size_t length );
 
101
 
 
102
ParserError::ErrorType validate__NMTOKEN( ParserString value );
 
103
ParserError::ErrorType validate__NMTOKEN( const ParserChar* value, size_t length );
 
104
ParserError::ErrorType validate__NMTOKEN__stream( const ParserChar* value, size_t length );
 
105
ParserError::ErrorType validate__NMTOKEN__streamEnd( const ParserChar* value, size_t length );
 
106
 
 
107
ParserError::ErrorType validate__up_axis_enum( ParserString value );
 
108
ParserError::ErrorType validate__up_axis_enum( const ParserChar* value, size_t length );
 
109
ParserError::ErrorType validate__up_axis_enum__stream( const ParserChar* value, size_t length );
 
110
ParserError::ErrorType validate__up_axis_enum__streamEnd( const ParserChar* value, size_t length );
 
111
 
 
112
struct extra__ValidationData
 
113
{
 
114
    size_t asset;
 
115
    size_t technique;
 
116
};
 
117
 
 
118
struct technique____technique_type__ValidationData
 
119
{
 
120
    size_t _wildcard;
 
121
};
 
122
 
 
123
struct library_animations__ValidationData
 
124
{
 
125
    size_t asset;
 
126
    size_t animation;
 
127
    size_t extra;
 
128
};
 
129
 
 
130
struct animation__ValidationData
 
131
{
 
132
    size_t validation_current_state;
 
133
    size_t asset;
 
134
    size_t source;
 
135
    size_t sampler;
 
136
    size_t channel;
 
137
    size_t animation;
 
138
    size_t extra;
 
139
};
 
140
 
 
141
struct source__ValidationData
 
142
{
 
143
    size_t validation_current_state;
 
144
    size_t asset;
 
145
    size_t token_array;
 
146
    size_t IDREF_array;
 
147
    size_t Name_array;
 
148
    size_t bool_array;
 
149
    size_t float_array;
 
150
    size_t int_array;
 
151
    size_t SIDREF_array;
 
152
    size_t technique_common;
 
153
    size_t technique;
 
154
};
 
155
 
 
156
struct IDREF_array__ValidationData
 
157
{
 
158
    size_t validationWholeSize;
 
159
};
 
160
 
 
161
ParserError::ErrorType validate__IDREFS( const ParserString*value, size_t length );
 
162
ParserError::ErrorType validate__IDREFS__stream( const ParserString*value, size_t length );
 
163
ParserError::ErrorType validate__IDREFS__streamEnd( const ParserString*value, size_t length );
 
164
 
 
165
ParserError::ErrorType validate__Name( ParserString value );
 
166
ParserError::ErrorType validate__Name( const ParserChar* value, size_t length );
 
167
ParserError::ErrorType validate__Name__stream( const ParserChar* value, size_t length );
 
168
ParserError::ErrorType validate__Name__streamEnd( const ParserChar* value, size_t length );
 
169
 
 
170
ParserError::ErrorType validate__digits_type( const uint8 value );
 
171
 
 
172
ParserError::ErrorType validate__magnitude_type( const sint16 value );
 
173
 
 
174
ParserError::ErrorType validate__sidref_type( ParserString value );
 
175
ParserError::ErrorType validate__sidref_type( const ParserChar* value, size_t length );
 
176
ParserError::ErrorType validate__sidref_type__stream( const ParserChar* value, size_t length );
 
177
ParserError::ErrorType validate__sidref_type__streamEnd( const ParserChar* value, size_t length );
 
178
 
 
179
struct source_type____technique_common__ValidationData
 
180
{
 
181
    size_t accessor;
 
182
};
 
183
 
 
184
struct accessor__ValidationData
 
185
{
 
186
    size_t param;
 
187
};
 
188
 
 
189
ParserError::ErrorType validate__sid_type( ParserString value );
 
190
ParserError::ErrorType validate__sid_type( const ParserChar* value, size_t length );
 
191
ParserError::ErrorType validate__sid_type__stream( const ParserChar* value, size_t length );
 
192
ParserError::ErrorType validate__sid_type__streamEnd( const ParserChar* value, size_t length );
 
193
 
 
194
ParserError::ErrorType validate__sampler_behavior_enum( ParserString value );
 
195
ParserError::ErrorType validate__sampler_behavior_enum( const ParserChar* value, size_t length );
 
196
ParserError::ErrorType validate__sampler_behavior_enum__stream( const ParserChar* value, size_t length );
 
197
ParserError::ErrorType validate__sampler_behavior_enum__streamEnd( const ParserChar* value, size_t length );
 
198
 
 
199
struct sampler__ValidationData
 
200
{
 
201
    size_t input;
 
202
};
 
203
 
 
204
ParserError::ErrorType validate__urifragment_type( ParserString value );
 
205
ParserError::ErrorType validate__urifragment_type( const ParserChar* value, size_t length );
 
206
ParserError::ErrorType validate__urifragment_type__stream( const ParserChar* value, size_t length );
 
207
ParserError::ErrorType validate__urifragment_type__streamEnd( const ParserChar* value, size_t length );
 
208
 
 
209
struct library_animation_clips__ValidationData
 
210
{
 
211
    size_t asset;
 
212
    size_t animation_clip;
 
213
    size_t extra;
 
214
};
 
215
 
 
216
struct animation_clip__ValidationData
 
217
{
 
218
    size_t asset;
 
219
    size_t instance_animation;
 
220
    size_t instance_formula;
 
221
    size_t extra;
 
222
};
 
223
 
 
224
struct instance_animation__ValidationData
 
225
{
 
226
    size_t extra;
 
227
};
 
228
 
 
229
struct instance_formula__ValidationData
 
230
{
 
231
    size_t setparam;
 
232
};
 
233
 
 
234
struct setparam____formula_setparam_type__ValidationData
 
235
{
 
236
    size_t _float;
 
237
    size_t _int;
 
238
    size_t SIDREF;
 
239
    size_t _bool;
 
240
    size_t connect_param;
 
241
};
 
242
 
 
243
struct library_cameras__ValidationData
 
244
{
 
245
    size_t asset;
 
246
    size_t camera;
 
247
    size_t extra;
 
248
};
 
249
 
 
250
struct camera__ValidationData
 
251
{
 
252
    size_t asset;
 
253
    size_t optics;
 
254
    size_t imager;
 
255
    size_t extra;
 
256
};
 
257
 
 
258
struct optics__ValidationData
 
259
{
 
260
    size_t technique_common;
 
261
    size_t technique;
 
262
    size_t extra;
 
263
};
 
264
 
 
265
struct optics__technique_common__ValidationData
 
266
{
 
267
    size_t orthographic;
 
268
    size_t perspective;
 
269
};
 
270
 
 
271
struct orthographic__ValidationData
 
272
{
 
273
    size_t validation_current_state;
 
274
    size_t xmag;
 
275
    size_t ymag;
 
276
    size_t aspect_ratio;
 
277
    size_t znear;
 
278
    size_t zfar;
 
279
};
 
280
 
 
281
struct perspective__ValidationData
 
282
{
 
283
    size_t validation_current_state;
 
284
    size_t xfov;
 
285
    size_t yfov;
 
286
    size_t aspect_ratio;
 
287
    size_t znear;
 
288
    size_t zfar;
 
289
};
 
290
 
 
291
struct imager__ValidationData
 
292
{
 
293
    size_t technique;
 
294
    size_t extra;
 
295
};
 
296
 
 
297
struct library_controllers__ValidationData
 
298
{
 
299
    size_t asset;
 
300
    size_t controller;
 
301
    size_t extra;
 
302
};
 
303
 
 
304
struct controller__ValidationData
 
305
{
 
306
    size_t validation_current_state;
 
307
    size_t asset;
 
308
    size_t skin;
 
309
    size_t morph;
 
310
    size_t extra;
 
311
};
 
312
 
 
313
struct skin__ValidationData
 
314
{
 
315
    size_t bind_shape_matrix;
 
316
    size_t source;
 
317
    size_t joints;
 
318
    size_t vertex_weights;
 
319
    size_t extra;
 
320
};
 
321
 
 
322
struct bind_shape_matrix__ValidationData
 
323
{
 
324
    size_t validationWholeSize;
 
325
};
 
326
 
 
327
ParserError::ErrorType validate__float4x4_type( const float* value, size_t length );
 
328
ParserError::ErrorType validate__float4x4_type__stream( const float* value, size_t length );
 
329
ParserError::ErrorType validate__float4x4_type__streamEnd( const float* value, size_t length );
 
330
 
 
331
struct joints__ValidationData
 
332
{
 
333
    size_t input;
 
334
    size_t extra;
 
335
};
 
336
 
 
337
struct vertex_weights__ValidationData
 
338
{
 
339
    size_t input;
 
340
    size_t vcount;
 
341
    size_t v;
 
342
    size_t extra;
 
343
};
 
344
 
 
345
ParserError::ErrorType validate__morph_method_enum( ParserString value );
 
346
ParserError::ErrorType validate__morph_method_enum( const ParserChar* value, size_t length );
 
347
ParserError::ErrorType validate__morph_method_enum__stream( const ParserChar* value, size_t length );
 
348
ParserError::ErrorType validate__morph_method_enum__streamEnd( const ParserChar* value, size_t length );
 
349
 
 
350
struct morph__ValidationData
 
351
{
 
352
    size_t source;
 
353
    size_t targets;
 
354
    size_t extra;
 
355
};
 
356
 
 
357
struct targets__ValidationData
 
358
{
 
359
    size_t input;
 
360
    size_t extra;
 
361
};
 
362
 
 
363
struct library_geometries__ValidationData
 
364
{
 
365
    size_t asset;
 
366
    size_t geometry;
 
367
    size_t extra;
 
368
};
 
369
 
 
370
struct geometry__ValidationData
 
371
{
 
372
    size_t validation_current_state;
 
373
    size_t asset;
 
374
    size_t convex_mesh;
 
375
    size_t mesh;
 
376
    size_t spline;
 
377
    size_t brep;
 
378
    size_t extra;
 
379
};
 
380
 
 
381
struct convex_mesh__ValidationData
 
382
{
 
383
    size_t validation_current_state;
 
384
    size_t source;
 
385
    size_t vertices;
 
386
    size_t lines;
 
387
    size_t linestrips;
 
388
    size_t polygons;
 
389
    size_t polylist;
 
390
    size_t triangles;
 
391
    size_t trifans;
 
392
    size_t tristrips;
 
393
    size_t extra;
 
394
};
 
395
 
 
396
struct vertices__ValidationData
 
397
{
 
398
    size_t input;
 
399
    size_t extra;
 
400
};
 
401
 
 
402
ParserError::ErrorType validate__NCName( ParserString value );
 
403
ParserError::ErrorType validate__NCName( const ParserChar* value, size_t length );
 
404
ParserError::ErrorType validate__NCName__stream( const ParserChar* value, size_t length );
 
405
ParserError::ErrorType validate__NCName__streamEnd( const ParserChar* value, size_t length );
 
406
 
 
407
struct lines__ValidationData
 
408
{
 
409
    size_t input;
 
410
    size_t p;
 
411
    size_t extra;
 
412
};
 
413
 
 
414
struct linestrips__ValidationData
 
415
{
 
416
    size_t input;
 
417
    size_t p;
 
418
    size_t extra;
 
419
};
 
420
 
 
421
struct polygons__ValidationData
 
422
{
 
423
    size_t validation_current_state;
 
424
    size_t input;
 
425
    size_t p;
 
426
    size_t ph;
 
427
    size_t extra;
 
428
};
 
429
 
 
430
struct ph__ValidationData
 
431
{
 
432
    size_t p;
 
433
    size_t h;
 
434
};
 
435
 
 
436
struct polylist__ValidationData
 
437
{
 
438
    size_t input;
 
439
    size_t vcount;
 
440
    size_t p;
 
441
    size_t extra;
 
442
};
 
443
 
 
444
struct triangles__ValidationData
 
445
{
 
446
    size_t input;
 
447
    size_t p;
 
448
    size_t extra;
 
449
};
 
450
 
 
451
struct trifans__ValidationData
 
452
{
 
453
    size_t input;
 
454
    size_t p;
 
455
    size_t extra;
 
456
};
 
457
 
 
458
struct tristrips__ValidationData
 
459
{
 
460
    size_t input;
 
461
    size_t p;
 
462
    size_t extra;
 
463
};
 
464
 
 
465
struct mesh__ValidationData
 
466
{
 
467
    size_t validation_current_state;
 
468
    size_t source;
 
469
    size_t vertices;
 
470
    size_t lines;
 
471
    size_t linestrips;
 
472
    size_t polygons;
 
473
    size_t polylist;
 
474
    size_t triangles;
 
475
    size_t trifans;
 
476
    size_t tristrips;
 
477
    size_t extra;
 
478
};
 
479
 
 
480
struct spline__ValidationData
 
481
{
 
482
    size_t source;
 
483
    size_t control_vertices;
 
484
    size_t extra;
 
485
};
 
486
 
 
487
struct spline_type____control_vertices__ValidationData
 
488
{
 
489
    size_t input;
 
490
    size_t extra;
 
491
};
 
492
 
 
493
struct brep__ValidationData
 
494
{
 
495
    size_t curves;
 
496
    size_t surface_curves;
 
497
    size_t surfaces;
 
498
    size_t source;
 
499
    size_t vertices;
 
500
    size_t edges;
 
501
    size_t wires;
 
502
    size_t faces;
 
503
    size_t pcurves;
 
504
    size_t shells;
 
505
    size_t solids;
 
506
    size_t extra;
 
507
};
 
508
 
 
509
struct curves__ValidationData
 
510
{
 
511
    size_t curve;
 
512
    size_t extra;
 
513
};
 
514
 
 
515
struct curve__ValidationData
 
516
{
 
517
    size_t validation_current_state;
 
518
    size_t line;
 
519
    size_t circle;
 
520
    size_t ellipse;
 
521
    size_t parabola;
 
522
    size_t hyperbola;
 
523
    size_t nurbs;
 
524
    size_t orient;
 
525
    size_t origin;
 
526
};
 
527
 
 
528
struct line__ValidationData
 
529
{
 
530
    size_t origin;
 
531
    size_t direction;
 
532
    size_t extra;
 
533
};
 
534
 
 
535
struct origin____float3_type__ValidationData
 
536
{
 
537
    size_t validationWholeSize;
 
538
};
 
539
 
 
540
ParserError::ErrorType validate__float3_type( const float* value, size_t length );
 
541
ParserError::ErrorType validate__float3_type__stream( const float* value, size_t length );
 
542
ParserError::ErrorType validate__float3_type__streamEnd( const float* value, size_t length );
 
543
 
 
544
struct circle__ValidationData
 
545
{
 
546
    size_t radius;
 
547
    size_t extra;
 
548
};
 
549
 
 
550
struct ellipse__ValidationData
 
551
{
 
552
    size_t radius;
 
553
    size_t extra;
 
554
};
 
555
 
 
556
struct radius____float2_type__ValidationData
 
557
{
 
558
    size_t validationWholeSize;
 
559
};
 
560
 
 
561
ParserError::ErrorType validate__float2_type( const float* value, size_t length );
 
562
ParserError::ErrorType validate__float2_type__stream( const float* value, size_t length );
 
563
ParserError::ErrorType validate__float2_type__streamEnd( const float* value, size_t length );
 
564
 
 
565
struct parabola__ValidationData
 
566
{
 
567
    size_t focal;
 
568
    size_t extra;
 
569
};
 
570
 
 
571
struct hyperbola__ValidationData
 
572
{
 
573
    size_t radius;
 
574
    size_t extra;
 
575
};
 
576
 
 
577
struct nurbs__ValidationData
 
578
{
 
579
    size_t source;
 
580
    size_t control_vertices;
 
581
    size_t extra;
 
582
};
 
583
 
 
584
struct nurbs_type____control_vertices__ValidationData
 
585
{
 
586
    size_t input;
 
587
    size_t extra;
 
588
};
 
589
 
 
590
struct orient__ValidationData
 
591
{
 
592
    size_t validationWholeSize;
 
593
};
 
594
 
 
595
ParserError::ErrorType validate__float4_type( const float* value, size_t length );
 
596
ParserError::ErrorType validate__float4_type__stream( const float* value, size_t length );
 
597
ParserError::ErrorType validate__float4_type__streamEnd( const float* value, size_t length );
 
598
 
 
599
struct origin____origin_type__ValidationData
 
600
{
 
601
    size_t validationWholeSize;
 
602
};
 
603
 
 
604
struct surface_curves__ValidationData
 
605
{
 
606
    size_t curve;
 
607
    size_t extra;
 
608
};
 
609
 
 
610
struct surfaces__ValidationData
 
611
{
 
612
    size_t surface;
 
613
    size_t extra;
 
614
};
 
615
 
 
616
struct surface__ValidationData
 
617
{
 
618
    size_t validation_current_state;
 
619
    size_t plane;
 
620
    size_t sphere;
 
621
    size_t torus;
 
622
    size_t swept_surface;
 
623
    size_t nurbs_surface;
 
624
    size_t cone;
 
625
    size_t cylinder;
 
626
    size_t orient;
 
627
    size_t origin;
 
628
};
 
629
 
 
630
struct plane__ValidationData
 
631
{
 
632
    size_t equation;
 
633
    size_t extra;
 
634
};
 
635
 
 
636
struct sphere__ValidationData
 
637
{
 
638
    size_t radius;
 
639
    size_t extra;
 
640
};
 
641
 
 
642
struct torus__ValidationData
 
643
{
 
644
    size_t radius;
 
645
    size_t extra;
 
646
};
 
647
 
 
648
struct swept_surface__ValidationData
 
649
{
 
650
    size_t validation_current_state;
 
651
    size_t curve;
 
652
    size_t direction;
 
653
    size_t origin;
 
654
    size_t axis;
 
655
    size_t extra;
 
656
};
 
657
 
 
658
struct nurbs_surface__ValidationData
 
659
{
 
660
    size_t source;
 
661
    size_t control_vertices;
 
662
    size_t extra;
 
663
};
 
664
 
 
665
struct nurbs_surface_type____control_vertices__ValidationData
 
666
{
 
667
    size_t input;
 
668
    size_t extra;
 
669
};
 
670
 
 
671
struct cone__ValidationData
 
672
{
 
673
    size_t radius;
 
674
    size_t angle;
 
675
    size_t extra;
 
676
};
 
677
 
 
678
struct surface_type____cylinder__ValidationData
 
679
{
 
680
    size_t radius;
 
681
    size_t extra;
 
682
};
 
683
 
 
684
struct edges__ValidationData
 
685
{
 
686
    size_t input;
 
687
    size_t p;
 
688
    size_t extra;
 
689
};
 
690
 
 
691
struct wires__ValidationData
 
692
{
 
693
    size_t input;
 
694
    size_t vcount;
 
695
    size_t p;
 
696
    size_t extra;
 
697
};
 
698
 
 
699
struct faces__ValidationData
 
700
{
 
701
    size_t input;
 
702
    size_t vcount;
 
703
    size_t p;
 
704
    size_t extra;
 
705
};
 
706
 
 
707
struct pcurves__ValidationData
 
708
{
 
709
    size_t input;
 
710
    size_t vcount;
 
711
    size_t p;
 
712
    size_t extra;
 
713
};
 
714
 
 
715
struct shells__ValidationData
 
716
{
 
717
    size_t input;
 
718
    size_t vcount;
 
719
    size_t p;
 
720
    size_t extra;
 
721
};
 
722
 
 
723
struct solids__ValidationData
 
724
{
 
725
    size_t input;
 
726
    size_t vcount;
 
727
    size_t p;
 
728
    size_t extra;
 
729
};
 
730
 
 
731
struct library_effects__ValidationData
 
732
{
 
733
    size_t asset;
 
734
    size_t effect;
 
735
    size_t extra;
 
736
};
 
737
 
 
738
struct effect__ValidationData
 
739
{
 
740
    size_t validation_current_state;
 
741
    size_t asset;
 
742
    size_t annotate;
 
743
    size_t newparam;
 
744
    size_t profile_COMMON;
 
745
    size_t profile_BRIDGE;
 
746
    size_t profile_GLES2;
 
747
    size_t profile_GLSL;
 
748
    size_t profile_CG;
 
749
    size_t profile_GLES;
 
750
    size_t extra;
 
751
};
 
752
 
 
753
struct annotate__ValidationData
 
754
{
 
755
    size_t validation_current_state;
 
756
    size_t _bool;
 
757
    size_t bool2;
 
758
    size_t bool3;
 
759
    size_t bool4;
 
760
    size_t _int;
 
761
    size_t int2;
 
762
    size_t int3;
 
763
    size_t int4;
 
764
    size_t _float;
 
765
    size_t float2;
 
766
    size_t float3;
 
767
    size_t float4;
 
768
    size_t float2x2;
 
769
    size_t float3x3;
 
770
    size_t float4x4;
 
771
    size_t string;
 
772
};
 
773
 
 
774
struct bool2__ValidationData
 
775
{
 
776
    size_t validationWholeSize;
 
777
};
 
778
 
 
779
ParserError::ErrorType validate__bool2_type( const bool* value, size_t length );
 
780
ParserError::ErrorType validate__bool2_type__stream( const bool* value, size_t length );
 
781
ParserError::ErrorType validate__bool2_type__streamEnd( const bool* value, size_t length );
 
782
 
 
783
struct bool3__ValidationData
 
784
{
 
785
    size_t validationWholeSize;
 
786
};
 
787
 
 
788
ParserError::ErrorType validate__bool3_type( const bool* value, size_t length );
 
789
ParserError::ErrorType validate__bool3_type__stream( const bool* value, size_t length );
 
790
ParserError::ErrorType validate__bool3_type__streamEnd( const bool* value, size_t length );
 
791
 
 
792
struct bool4__ValidationData
 
793
{
 
794
    size_t validationWholeSize;
 
795
};
 
796
 
 
797
ParserError::ErrorType validate__bool4_type( const bool* value, size_t length );
 
798
ParserError::ErrorType validate__bool4_type__stream( const bool* value, size_t length );
 
799
ParserError::ErrorType validate__bool4_type__streamEnd( const bool* value, size_t length );
 
800
 
 
801
struct int2__ValidationData
 
802
{
 
803
    size_t validationWholeSize;
 
804
};
 
805
 
 
806
ParserError::ErrorType validate__int2_type( const sint64* value, size_t length );
 
807
ParserError::ErrorType validate__int2_type__stream( const sint64* value, size_t length );
 
808
ParserError::ErrorType validate__int2_type__streamEnd( const sint64* value, size_t length );
 
809
 
 
810
struct int3__ValidationData
 
811
{
 
812
    size_t validationWholeSize;
 
813
};
 
814
 
 
815
ParserError::ErrorType validate__int3_type( const sint64* value, size_t length );
 
816
ParserError::ErrorType validate__int3_type__stream( const sint64* value, size_t length );
 
817
ParserError::ErrorType validate__int3_type__streamEnd( const sint64* value, size_t length );
 
818
 
 
819
struct int4__ValidationData
 
820
{
 
821
    size_t validationWholeSize;
 
822
};
 
823
 
 
824
ParserError::ErrorType validate__int4_type( const sint64* value, size_t length );
 
825
ParserError::ErrorType validate__int4_type__stream( const sint64* value, size_t length );
 
826
ParserError::ErrorType validate__int4_type__streamEnd( const sint64* value, size_t length );
 
827
 
 
828
struct float2x2__ValidationData
 
829
{
 
830
    size_t validationWholeSize;
 
831
};
 
832
 
 
833
ParserError::ErrorType validate__float2x2_type( const float* value, size_t length );
 
834
ParserError::ErrorType validate__float2x2_type__stream( const float* value, size_t length );
 
835
ParserError::ErrorType validate__float2x2_type__streamEnd( const float* value, size_t length );
 
836
 
 
837
struct float3x3__ValidationData
 
838
{
 
839
    size_t validationWholeSize;
 
840
};
 
841
 
 
842
ParserError::ErrorType validate__float3x3_type( const float* value, size_t length );
 
843
ParserError::ErrorType validate__float3x3_type__stream( const float* value, size_t length );
 
844
ParserError::ErrorType validate__float3x3_type__streamEnd( const float* value, size_t length );
 
845
 
 
846
struct newparam____fx_newparam_type__ValidationData
 
847
{
 
848
    size_t validation_current_state;
 
849
    size_t annotate;
 
850
    size_t semantic;
 
851
    size_t modifier;
 
852
    size_t _bool;
 
853
    size_t bool2;
 
854
    size_t bool3;
 
855
    size_t bool4;
 
856
    size_t _int;
 
857
    size_t int2;
 
858
    size_t int3;
 
859
    size_t int4;
 
860
    size_t _float;
 
861
    size_t float2;
 
862
    size_t float3;
 
863
    size_t float4;
 
864
    size_t float2x1;
 
865
    size_t float2x2;
 
866
    size_t float2x3;
 
867
    size_t float2x4;
 
868
    size_t float3x1;
 
869
    size_t float3x2;
 
870
    size_t float3x3;
 
871
    size_t float3x4;
 
872
    size_t float4x1;
 
873
    size_t float4x2;
 
874
    size_t float4x3;
 
875
    size_t float4x4;
 
876
    size_t sampler1D;
 
877
    size_t sampler2D;
 
878
    size_t sampler3D;
 
879
    size_t samplerCUBE;
 
880
    size_t samplerRECT;
 
881
    size_t samplerDEPTH;
 
882
    size_t _enum;
 
883
};
 
884
 
 
885
ParserError::ErrorType validate__fx_modifier_enum( ParserString value );
 
886
ParserError::ErrorType validate__fx_modifier_enum( const ParserChar* value, size_t length );
 
887
ParserError::ErrorType validate__fx_modifier_enum__stream( const ParserChar* value, size_t length );
 
888
ParserError::ErrorType validate__fx_modifier_enum__streamEnd( const ParserChar* value, size_t length );
 
889
 
 
890
struct float2x3__ValidationData
 
891
{
 
892
    size_t validationWholeSize;
 
893
};
 
894
 
 
895
ParserError::ErrorType validate__float2x3_type( const float* value, size_t length );
 
896
ParserError::ErrorType validate__float2x3_type__stream( const float* value, size_t length );
 
897
ParserError::ErrorType validate__float2x3_type__streamEnd( const float* value, size_t length );
 
898
 
 
899
struct float2x4__ValidationData
 
900
{
 
901
    size_t validationWholeSize;
 
902
};
 
903
 
 
904
ParserError::ErrorType validate__float2x4_type( const float* value, size_t length );
 
905
ParserError::ErrorType validate__float2x4_type__stream( const float* value, size_t length );
 
906
ParserError::ErrorType validate__float2x4_type__streamEnd( const float* value, size_t length );
 
907
 
 
908
struct float3x2__ValidationData
 
909
{
 
910
    size_t validationWholeSize;
 
911
};
 
912
 
 
913
ParserError::ErrorType validate__float3x2_type( const float* value, size_t length );
 
914
ParserError::ErrorType validate__float3x2_type__stream( const float* value, size_t length );
 
915
ParserError::ErrorType validate__float3x2_type__streamEnd( const float* value, size_t length );
 
916
 
 
917
struct float3x4__ValidationData
 
918
{
 
919
    size_t validationWholeSize;
 
920
};
 
921
 
 
922
ParserError::ErrorType validate__float3x4_type( const float* value, size_t length );
 
923
ParserError::ErrorType validate__float3x4_type__stream( const float* value, size_t length );
 
924
ParserError::ErrorType validate__float3x4_type__streamEnd( const float* value, size_t length );
 
925
 
 
926
struct float4x2__ValidationData
 
927
{
 
928
    size_t validationWholeSize;
 
929
};
 
930
 
 
931
ParserError::ErrorType validate__float4x2_type( const float* value, size_t length );
 
932
ParserError::ErrorType validate__float4x2_type__stream( const float* value, size_t length );
 
933
ParserError::ErrorType validate__float4x2_type__streamEnd( const float* value, size_t length );
 
934
 
 
935
struct float4x3__ValidationData
 
936
{
 
937
    size_t validationWholeSize;
 
938
};
 
939
 
 
940
ParserError::ErrorType validate__float4x3_type( const float* value, size_t length );
 
941
ParserError::ErrorType validate__float4x3_type__stream( const float* value, size_t length );
 
942
ParserError::ErrorType validate__float4x3_type__streamEnd( const float* value, size_t length );
 
943
 
 
944
struct sampler1D__ValidationData
 
945
{
 
946
    size_t validation_current_state;
 
947
    size_t instance_image;
 
948
    size_t wrap_s;
 
949
    size_t wrap_t;
 
950
    size_t wrap_p;
 
951
    size_t minfilter;
 
952
    size_t magfilter;
 
953
    size_t mipfilter;
 
954
    size_t border_color;
 
955
    size_t mip_max_level;
 
956
    size_t mip_min_level;
 
957
    size_t mip_bias;
 
958
    size_t max_anisotropy;
 
959
    size_t extra;
 
960
};
 
961
 
 
962
struct instance_image__ValidationData
 
963
{
 
964
    size_t extra;
 
965
};
 
966
 
 
967
ParserError::ErrorType validate__fx_sampler_wrap_enum( ParserString value );
 
968
ParserError::ErrorType validate__fx_sampler_wrap_enum( const ParserChar* value, size_t length );
 
969
ParserError::ErrorType validate__fx_sampler_wrap_enum__stream( const ParserChar* value, size_t length );
 
970
ParserError::ErrorType validate__fx_sampler_wrap_enum__streamEnd( const ParserChar* value, size_t length );
 
971
 
 
972
ParserError::ErrorType validate__fx_sampler_min_filter_enum( ParserString value );
 
973
ParserError::ErrorType validate__fx_sampler_min_filter_enum( const ParserChar* value, size_t length );
 
974
ParserError::ErrorType validate__fx_sampler_min_filter_enum__stream( const ParserChar* value, size_t length );
 
975
ParserError::ErrorType validate__fx_sampler_min_filter_enum__streamEnd( const ParserChar* value, size_t length );
 
976
 
 
977
ParserError::ErrorType validate__fx_sampler_mag_filter_enum( ParserString value );
 
978
ParserError::ErrorType validate__fx_sampler_mag_filter_enum( const ParserChar* value, size_t length );
 
979
ParserError::ErrorType validate__fx_sampler_mag_filter_enum__stream( const ParserChar* value, size_t length );
 
980
ParserError::ErrorType validate__fx_sampler_mag_filter_enum__streamEnd( const ParserChar* value, size_t length );
 
981
 
 
982
ParserError::ErrorType validate__fx_sampler_mip_filter_enum( ParserString value );
 
983
ParserError::ErrorType validate__fx_sampler_mip_filter_enum( const ParserChar* value, size_t length );
 
984
ParserError::ErrorType validate__fx_sampler_mip_filter_enum__stream( const ParserChar* value, size_t length );
 
985
ParserError::ErrorType validate__fx_sampler_mip_filter_enum__streamEnd( const ParserChar* value, size_t length );
 
986
 
 
987
struct border_color__ValidationData
 
988
{
 
989
    size_t validationWholeSize;
 
990
};
 
991
 
 
992
ParserError::ErrorType validate__fx_color_type( const float* value, size_t length );
 
993
ParserError::ErrorType validate__fx_color_type__stream( const float* value, size_t length );
 
994
ParserError::ErrorType validate__fx_color_type__streamEnd( const float* value, size_t length );
 
995
 
 
996
struct sampler2D____fx_sampler2D_type__ValidationData
 
997
{
 
998
    size_t validation_current_state;
 
999
    size_t instance_image;
 
1000
    size_t wrap_s;
 
1001
    size_t wrap_t;
 
1002
    size_t wrap_p;
 
1003
    size_t minfilter;
 
1004
    size_t magfilter;
 
1005
    size_t mipfilter;
 
1006
    size_t border_color;
 
1007
    size_t mip_max_level;
 
1008
    size_t mip_min_level;
 
1009
    size_t mip_bias;
 
1010
    size_t max_anisotropy;
 
1011
    size_t extra;
 
1012
};
 
1013
 
 
1014
struct sampler3D__ValidationData
 
1015
{
 
1016
    size_t validation_current_state;
 
1017
    size_t instance_image;
 
1018
    size_t wrap_s;
 
1019
    size_t wrap_t;
 
1020
    size_t wrap_p;
 
1021
    size_t minfilter;
 
1022
    size_t magfilter;
 
1023
    size_t mipfilter;
 
1024
    size_t border_color;
 
1025
    size_t mip_max_level;
 
1026
    size_t mip_min_level;
 
1027
    size_t mip_bias;
 
1028
    size_t max_anisotropy;
 
1029
    size_t extra;
 
1030
};
 
1031
 
 
1032
struct samplerCUBE__ValidationData
 
1033
{
 
1034
    size_t validation_current_state;
 
1035
    size_t instance_image;
 
1036
    size_t wrap_s;
 
1037
    size_t wrap_t;
 
1038
    size_t wrap_p;
 
1039
    size_t minfilter;
 
1040
    size_t magfilter;
 
1041
    size_t mipfilter;
 
1042
    size_t border_color;
 
1043
    size_t mip_max_level;
 
1044
    size_t mip_min_level;
 
1045
    size_t mip_bias;
 
1046
    size_t max_anisotropy;
 
1047
    size_t extra;
 
1048
};
 
1049
 
 
1050
struct samplerRECT__ValidationData
 
1051
{
 
1052
    size_t validation_current_state;
 
1053
    size_t instance_image;
 
1054
    size_t wrap_s;
 
1055
    size_t wrap_t;
 
1056
    size_t wrap_p;
 
1057
    size_t minfilter;
 
1058
    size_t magfilter;
 
1059
    size_t mipfilter;
 
1060
    size_t border_color;
 
1061
    size_t mip_max_level;
 
1062
    size_t mip_min_level;
 
1063
    size_t mip_bias;
 
1064
    size_t max_anisotropy;
 
1065
    size_t extra;
 
1066
};
 
1067
 
 
1068
struct samplerDEPTH__ValidationData
 
1069
{
 
1070
    size_t validation_current_state;
 
1071
    size_t instance_image;
 
1072
    size_t wrap_s;
 
1073
    size_t wrap_t;
 
1074
    size_t wrap_p;
 
1075
    size_t minfilter;
 
1076
    size_t magfilter;
 
1077
    size_t mipfilter;
 
1078
    size_t border_color;
 
1079
    size_t mip_max_level;
 
1080
    size_t mip_min_level;
 
1081
    size_t mip_bias;
 
1082
    size_t max_anisotropy;
 
1083
    size_t extra;
 
1084
};
 
1085
 
 
1086
struct profile_COMMON__ValidationData
 
1087
{
 
1088
    size_t asset;
 
1089
    size_t newparam;
 
1090
    size_t technique;
 
1091
    size_t extra;
 
1092
};
 
1093
 
 
1094
struct newparam____fx_common_newparam_type__ValidationData
 
1095
{
 
1096
    size_t validation_current_state;
 
1097
    size_t semantic;
 
1098
    size_t _float;
 
1099
    size_t float2;
 
1100
    size_t float3;
 
1101
    size_t float4;
 
1102
    size_t sampler2D;
 
1103
};
 
1104
 
 
1105
struct profile_common_type____technique__ValidationData
 
1106
{
 
1107
    size_t validation_current_state;
 
1108
    size_t asset;
 
1109
    size_t constant;
 
1110
    size_t lambert;
 
1111
    size_t phong;
 
1112
    size_t blinn;
 
1113
    size_t extra;
 
1114
};
 
1115
 
 
1116
struct profile_COMMON__technique__constant__ValidationData
 
1117
{
 
1118
    size_t emission;
 
1119
    size_t reflective;
 
1120
    size_t reflectivity;
 
1121
    size_t transparent;
 
1122
    size_t transparency;
 
1123
    size_t index_of_refraction;
 
1124
};
 
1125
 
 
1126
struct emission__ValidationData
 
1127
{
 
1128
    size_t color;
 
1129
    size_t param;
 
1130
    size_t texture;
 
1131
};
 
1132
 
 
1133
struct fx_common_color_or_texture_type____color__ValidationData
 
1134
{
 
1135
    size_t validationWholeSize;
 
1136
};
 
1137
 
 
1138
struct texture__ValidationData
 
1139
{
 
1140
    size_t extra;
 
1141
};
 
1142
 
 
1143
struct reflectivity__ValidationData
 
1144
{
 
1145
    size_t _float;
 
1146
    size_t param;
 
1147
};
 
1148
 
 
1149
ParserError::ErrorType validate__fx_opaque_enum( ParserString value );
 
1150
ParserError::ErrorType validate__fx_opaque_enum( const ParserChar* value, size_t length );
 
1151
ParserError::ErrorType validate__fx_opaque_enum__stream( const ParserChar* value, size_t length );
 
1152
ParserError::ErrorType validate__fx_opaque_enum__streamEnd( const ParserChar* value, size_t length );
 
1153
 
 
1154
struct transparent__ValidationData
 
1155
{
 
1156
    size_t color;
 
1157
    size_t param;
 
1158
    size_t texture;
 
1159
};
 
1160
 
 
1161
struct lambert__ValidationData
 
1162
{
 
1163
    size_t emission;
 
1164
    size_t ambient;
 
1165
    size_t diffuse;
 
1166
    size_t reflective;
 
1167
    size_t reflectivity;
 
1168
    size_t transparent;
 
1169
    size_t transparency;
 
1170
    size_t index_of_refraction;
 
1171
};
 
1172
 
 
1173
struct phong__ValidationData
 
1174
{
 
1175
    size_t emission;
 
1176
    size_t ambient;
 
1177
    size_t diffuse;
 
1178
    size_t specular;
 
1179
    size_t shininess;
 
1180
    size_t reflective;
 
1181
    size_t reflectivity;
 
1182
    size_t transparent;
 
1183
    size_t transparency;
 
1184
    size_t index_of_refraction;
 
1185
};
 
1186
 
 
1187
struct blinn__ValidationData
 
1188
{
 
1189
    size_t emission;
 
1190
    size_t ambient;
 
1191
    size_t diffuse;
 
1192
    size_t specular;
 
1193
    size_t shininess;
 
1194
    size_t reflective;
 
1195
    size_t reflectivity;
 
1196
    size_t transparent;
 
1197
    size_t transparency;
 
1198
    size_t index_of_refraction;
 
1199
};
 
1200
 
 
1201
struct profile_BRIDGE__ValidationData
 
1202
{
 
1203
    size_t asset;
 
1204
    size_t extra;
 
1205
};
 
1206
 
 
1207
struct profile_GLES2__ValidationData
 
1208
{
 
1209
    size_t validation_current_state;
 
1210
    size_t asset;
 
1211
    size_t include;
 
1212
    size_t code;
 
1213
    size_t newparam;
 
1214
    size_t technique;
 
1215
    size_t extra;
 
1216
};
 
1217
 
 
1218
struct profile_gles2_type____newparam__ValidationData
 
1219
{
 
1220
    size_t validation_current_state;
 
1221
    size_t annotate;
 
1222
    size_t semantic;
 
1223
    size_t modifier;
 
1224
    size_t _bool;
 
1225
    size_t bvec2;
 
1226
    size_t bvec3;
 
1227
    size_t bvec4;
 
1228
    size_t _float;
 
1229
    size_t vec2;
 
1230
    size_t vec3;
 
1231
    size_t vec4;
 
1232
    size_t mat2;
 
1233
    size_t mat3;
 
1234
    size_t mat4;
 
1235
    size_t _int;
 
1236
    size_t ivec2;
 
1237
    size_t ivec3;
 
1238
    size_t ivec4;
 
1239
    size_t _enum;
 
1240
    size_t sampler2D;
 
1241
    size_t sampler3D;
 
1242
    size_t samplerCUBE;
 
1243
    size_t samplerDEPTH;
 
1244
    size_t usertype;
 
1245
    size_t array;
 
1246
};
 
1247
 
 
1248
struct profile_GLES2__newparam__usertype__ValidationData
 
1249
{
 
1250
    size_t setparam;
 
1251
};
 
1252
 
 
1253
struct profile_GLES2__newparam__usertype__setparam__ValidationData
 
1254
{
 
1255
    size_t validation_current_state;
 
1256
    size_t _bool;
 
1257
    size_t bvec2;
 
1258
    size_t bvec3;
 
1259
    size_t bvec4;
 
1260
    size_t _float;
 
1261
    size_t vec2;
 
1262
    size_t vec3;
 
1263
    size_t vec4;
 
1264
    size_t mat2;
 
1265
    size_t mat3;
 
1266
    size_t mat4;
 
1267
    size_t _int;
 
1268
    size_t ivec2;
 
1269
    size_t ivec3;
 
1270
    size_t ivec4;
 
1271
    size_t _enum;
 
1272
    size_t sampler2D;
 
1273
    size_t sampler3D;
 
1274
    size_t samplerCUBE;
 
1275
    size_t samplerDEPTH;
 
1276
    size_t usertype;
 
1277
    size_t array;
 
1278
};
 
1279
 
 
1280
ParserError::ErrorType validate__positiveInteger( const uint64 value );
 
1281
 
 
1282
struct profile_GLES2__newparam__usertype__setparam__array__ValidationData
 
1283
{
 
1284
    size_t validation_current_state;
 
1285
    size_t _bool;
 
1286
    size_t bvec2;
 
1287
    size_t bvec3;
 
1288
    size_t bvec4;
 
1289
    size_t _float;
 
1290
    size_t vec2;
 
1291
    size_t vec3;
 
1292
    size_t vec4;
 
1293
    size_t mat2;
 
1294
    size_t mat3;
 
1295
    size_t mat4;
 
1296
    size_t _int;
 
1297
    size_t ivec2;
 
1298
    size_t ivec3;
 
1299
    size_t ivec4;
 
1300
    size_t _enum;
 
1301
    size_t sampler2D;
 
1302
    size_t sampler3D;
 
1303
    size_t samplerCUBE;
 
1304
    size_t samplerDEPTH;
 
1305
    size_t usertype;
 
1306
    size_t array;
 
1307
};
 
1308
 
 
1309
struct profile_gles2_type____technique__ValidationData
 
1310
{
 
1311
    size_t asset;
 
1312
    size_t annotate;
 
1313
    size_t pass;
 
1314
    size_t extra;
 
1315
};
 
1316
 
 
1317
struct pass____gles2_pass_type__ValidationData
 
1318
{
 
1319
    size_t annotate;
 
1320
    size_t states;
 
1321
    size_t program;
 
1322
    size_t evaluate;
 
1323
    size_t extra;
 
1324
};
 
1325
 
 
1326
struct gles2_pass_type____states__ValidationData
 
1327
{
 
1328
    size_t validation_current_state;
 
1329
    size_t blend_color;
 
1330
    size_t blend_equation;
 
1331
    size_t blend_equation_separate;
 
1332
    size_t blend_func;
 
1333
    size_t blend_func_separate;
 
1334
    size_t color_mask;
 
1335
    size_t cull_face;
 
1336
    size_t depth_func;
 
1337
    size_t depth_mask;
 
1338
    size_t depth_range;
 
1339
    size_t front_face;
 
1340
    size_t line_width;
 
1341
    size_t polygon_offset;
 
1342
    size_t point_size;
 
1343
    size_t sample_coverage;
 
1344
    size_t scissor;
 
1345
    size_t stencil_func;
 
1346
    size_t stencil_func_separate;
 
1347
    size_t stencil_mask;
 
1348
    size_t stencil_mask_separate;
 
1349
    size_t stencil_op;
 
1350
    size_t stencil_op_separate;
 
1351
    size_t blend_enable;
 
1352
    size_t cull_face_enable;
 
1353
    size_t depth_test_enable;
 
1354
    size_t dither_enable;
 
1355
    size_t polygon_offset_fill_enable;
 
1356
    size_t point_size_enable;
 
1357
    size_t sample_alpha_to_coverage_enable;
 
1358
    size_t sample_coverage_enable;
 
1359
    size_t scissor_test_enable;
 
1360
    size_t stencil_test_enable;
 
1361
};
 
1362
 
 
1363
ParserError::ErrorType validate__gl_blend_equation_enum( ParserString value );
 
1364
ParserError::ErrorType validate__gl_blend_equation_enum( const ParserChar* value, size_t length );
 
1365
ParserError::ErrorType validate__gl_blend_equation_enum__stream( const ParserChar* value, size_t length );
 
1366
ParserError::ErrorType validate__gl_blend_equation_enum__streamEnd( const ParserChar* value, size_t length );
 
1367
 
 
1368
struct profile_GLES2__technique__pass__states__blend_equation_separate__ValidationData
 
1369
{
 
1370
    size_t rgb;
 
1371
    size_t alpha;
 
1372
};
 
1373
 
 
1374
struct profile_GLES2__technique__pass__states__blend_func__ValidationData
 
1375
{
 
1376
    size_t src;
 
1377
    size_t dest;
 
1378
};
 
1379
 
 
1380
ParserError::ErrorType validate__gl_blend_enum( ParserString value );
 
1381
ParserError::ErrorType validate__gl_blend_enum( const ParserChar* value, size_t length );
 
1382
ParserError::ErrorType validate__gl_blend_enum__stream( const ParserChar* value, size_t length );
 
1383
ParserError::ErrorType validate__gl_blend_enum__streamEnd( const ParserChar* value, size_t length );
 
1384
 
 
1385
struct profile_GLES2__technique__pass__states__blend_func_separate__ValidationData
 
1386
{
 
1387
    size_t src_rgb;
 
1388
    size_t dest_rgb;
 
1389
    size_t src_alpha;
 
1390
    size_t dest_alpha;
 
1391
};
 
1392
 
 
1393
ParserError::ErrorType validate__gl_face_enum( ParserString value );
 
1394
ParserError::ErrorType validate__gl_face_enum( const ParserChar* value, size_t length );
 
1395
ParserError::ErrorType validate__gl_face_enum__stream( const ParserChar* value, size_t length );
 
1396
ParserError::ErrorType validate__gl_face_enum__streamEnd( const ParserChar* value, size_t length );
 
1397
 
 
1398
ParserError::ErrorType validate__gl_func_enum( ParserString value );
 
1399
ParserError::ErrorType validate__gl_func_enum( const ParserChar* value, size_t length );
 
1400
ParserError::ErrorType validate__gl_func_enum__stream( const ParserChar* value, size_t length );
 
1401
ParserError::ErrorType validate__gl_func_enum__streamEnd( const ParserChar* value, size_t length );
 
1402
 
 
1403
ParserError::ErrorType validate__gl_front_face_enum( ParserString value );
 
1404
ParserError::ErrorType validate__gl_front_face_enum( const ParserChar* value, size_t length );
 
1405
ParserError::ErrorType validate__gl_front_face_enum__stream( const ParserChar* value, size_t length );
 
1406
ParserError::ErrorType validate__gl_front_face_enum__streamEnd( const ParserChar* value, size_t length );
 
1407
 
 
1408
struct sample_coverage__ValidationData
 
1409
{
 
1410
    size_t value;
 
1411
    size_t invert;
 
1412
};
 
1413
 
 
1414
struct profile_GLES2__technique__pass__states__stencil_func__ValidationData
 
1415
{
 
1416
    size_t func;
 
1417
    size_t ref;
 
1418
    size_t mask;
 
1419
};
 
1420
 
 
1421
struct profile_GLES2__technique__pass__states__stencil_func_separate__ValidationData
 
1422
{
 
1423
    size_t front;
 
1424
    size_t back;
 
1425
    size_t ref;
 
1426
    size_t mask;
 
1427
};
 
1428
 
 
1429
struct profile_GLES2__technique__pass__states__stencil_mask_separate__ValidationData
 
1430
{
 
1431
    size_t face;
 
1432
    size_t mask;
 
1433
};
 
1434
 
 
1435
struct profile_GLES2__technique__pass__states__stencil_op__ValidationData
 
1436
{
 
1437
    size_t fail;
 
1438
    size_t zfail;
 
1439
    size_t zpass;
 
1440
};
 
1441
 
 
1442
ParserError::ErrorType validate__gl_stencil_op_enum( ParserString value );
 
1443
ParserError::ErrorType validate__gl_stencil_op_enum( const ParserChar* value, size_t length );
 
1444
ParserError::ErrorType validate__gl_stencil_op_enum__stream( const ParserChar* value, size_t length );
 
1445
ParserError::ErrorType validate__gl_stencil_op_enum__streamEnd( const ParserChar* value, size_t length );
 
1446
 
 
1447
struct profile_GLES2__technique__pass__states__stencil_op_separate__ValidationData
 
1448
{
 
1449
    size_t face;
 
1450
    size_t fail;
 
1451
    size_t zfail;
 
1452
    size_t zpass;
 
1453
};
 
1454
 
 
1455
struct program____gles2_program_type__ValidationData
 
1456
{
 
1457
    size_t shader;
 
1458
    size_t linker;
 
1459
    size_t bind_attribute;
 
1460
    size_t bind_uniform;
 
1461
};
 
1462
 
 
1463
ParserError::ErrorType validate__fx_pipeline_stage_enum( ParserString value );
 
1464
ParserError::ErrorType validate__fx_pipeline_stage_enum( const ParserChar* value, size_t length );
 
1465
ParserError::ErrorType validate__fx_pipeline_stage_enum__stream( const ParserChar* value, size_t length );
 
1466
ParserError::ErrorType validate__fx_pipeline_stage_enum__streamEnd( const ParserChar* value, size_t length );
 
1467
 
 
1468
struct shader____gles2_shader_type__ValidationData
 
1469
{
 
1470
    size_t sources;
 
1471
    size_t compiler;
 
1472
    size_t extra;
 
1473
};
 
1474
 
 
1475
struct gles2_shader_type____sources__ValidationData
 
1476
{
 
1477
    size_t validation_current_state;
 
1478
    size_t inline_;
 
1479
    size_t import;
 
1480
};
 
1481
 
 
1482
struct compiler__ValidationData
 
1483
{
 
1484
    size_t binary;
 
1485
};
 
1486
 
 
1487
struct binary__ValidationData
 
1488
{
 
1489
    size_t ref;
 
1490
    size_t hex;
 
1491
};
 
1492
 
 
1493
struct gles2_program_type____bind_attribute__ValidationData
 
1494
{
 
1495
    size_t semantic;
 
1496
};
 
1497
 
 
1498
struct gles2_program_type____bind_uniform__ValidationData
 
1499
{
 
1500
    size_t validation_current_state;
 
1501
    size_t param;
 
1502
    size_t _bool;
 
1503
    size_t bvec2;
 
1504
    size_t bvec3;
 
1505
    size_t bvec4;
 
1506
    size_t _float;
 
1507
    size_t vec2;
 
1508
    size_t vec3;
 
1509
    size_t vec4;
 
1510
    size_t mat2;
 
1511
    size_t mat3;
 
1512
    size_t mat4;
 
1513
    size_t _int;
 
1514
    size_t ivec2;
 
1515
    size_t ivec3;
 
1516
    size_t ivec4;
 
1517
    size_t _enum;
 
1518
    size_t sampler2D;
 
1519
    size_t sampler3D;
 
1520
    size_t samplerCUBE;
 
1521
    size_t samplerDEPTH;
 
1522
    size_t usertype;
 
1523
    size_t array;
 
1524
};
 
1525
 
 
1526
struct gles2_pass_type____evaluate__ValidationData
 
1527
{
 
1528
    size_t color_target;
 
1529
    size_t depth_target;
 
1530
    size_t stencil_target;
 
1531
    size_t color_clear;
 
1532
    size_t stencil_clear;
 
1533
    size_t depth_clear;
 
1534
    size_t draw;
 
1535
};
 
1536
 
 
1537
ParserError::ErrorType validate__image_face_enum( ParserString value );
 
1538
ParserError::ErrorType validate__image_face_enum( const ParserChar* value, size_t length );
 
1539
ParserError::ErrorType validate__image_face_enum__stream( const ParserChar* value, size_t length );
 
1540
ParserError::ErrorType validate__image_face_enum__streamEnd( const ParserChar* value, size_t length );
 
1541
 
 
1542
struct color_target__ValidationData
 
1543
{
 
1544
    size_t param;
 
1545
    size_t instance_image;
 
1546
};
 
1547
 
 
1548
struct depth_target__ValidationData
 
1549
{
 
1550
    size_t param;
 
1551
    size_t instance_image;
 
1552
};
 
1553
 
 
1554
struct stencil_target__ValidationData
 
1555
{
 
1556
    size_t param;
 
1557
    size_t instance_image;
 
1558
};
 
1559
 
 
1560
struct color_clear__ValidationData
 
1561
{
 
1562
    size_t validationWholeSize;
 
1563
};
 
1564
 
 
1565
struct profile_GLSL__ValidationData
 
1566
{
 
1567
    size_t validation_current_state;
 
1568
    size_t asset;
 
1569
    size_t code;
 
1570
    size_t include;
 
1571
    size_t newparam;
 
1572
    size_t technique;
 
1573
    size_t extra;
 
1574
};
 
1575
 
 
1576
struct newparam____glsl_newparam_type__ValidationData
 
1577
{
 
1578
    size_t validation_current_state;
 
1579
    size_t annotate;
 
1580
    size_t semantic;
 
1581
    size_t modifier;
 
1582
    size_t _bool;
 
1583
    size_t bool2;
 
1584
    size_t bool3;
 
1585
    size_t bool4;
 
1586
    size_t _float;
 
1587
    size_t float2;
 
1588
    size_t float3;
 
1589
    size_t float4;
 
1590
    size_t float2x2;
 
1591
    size_t float3x3;
 
1592
    size_t float4x4;
 
1593
    size_t _int;
 
1594
    size_t int2;
 
1595
    size_t int3;
 
1596
    size_t int4;
 
1597
    size_t sampler1D;
 
1598
    size_t sampler2D;
 
1599
    size_t sampler3D;
 
1600
    size_t samplerCUBE;
 
1601
    size_t samplerRECT;
 
1602
    size_t samplerDEPTH;
 
1603
    size_t _enum;
 
1604
    size_t array;
 
1605
};
 
1606
 
 
1607
struct array____glsl_array_type__ValidationData
 
1608
{
 
1609
    size_t validation_current_state;
 
1610
    size_t _bool;
 
1611
    size_t bool2;
 
1612
    size_t bool3;
 
1613
    size_t bool4;
 
1614
    size_t _float;
 
1615
    size_t float2;
 
1616
    size_t float3;
 
1617
    size_t float4;
 
1618
    size_t float2x2;
 
1619
    size_t float3x3;
 
1620
    size_t float4x4;
 
1621
    size_t _int;
 
1622
    size_t int2;
 
1623
    size_t int3;
 
1624
    size_t int4;
 
1625
    size_t sampler1D;
 
1626
    size_t sampler2D;
 
1627
    size_t sampler3D;
 
1628
    size_t samplerCUBE;
 
1629
    size_t samplerRECT;
 
1630
    size_t samplerDEPTH;
 
1631
    size_t _enum;
 
1632
    size_t array;
 
1633
};
 
1634
 
 
1635
struct profile_glsl_type____technique__ValidationData
 
1636
{
 
1637
    size_t asset;
 
1638
    size_t annotate;
 
1639
    size_t pass;
 
1640
    size_t extra;
 
1641
};
 
1642
 
 
1643
struct profile_GLSL__technique__pass__ValidationData
 
1644
{
 
1645
    size_t annotate;
 
1646
    size_t states;
 
1647
    size_t program;
 
1648
    size_t evaluate;
 
1649
    size_t extra;
 
1650
};
 
1651
 
 
1652
struct profile_GLSL__technique__pass__states__ValidationData
 
1653
{
 
1654
    size_t validation_current_state;
 
1655
    size_t alpha_func;
 
1656
    size_t blend_func;
 
1657
    size_t blend_func_separate;
 
1658
    size_t blend_equation;
 
1659
    size_t blend_equation_separate;
 
1660
    size_t color_material;
 
1661
    size_t cull_face;
 
1662
    size_t depth_func;
 
1663
    size_t fog_mode;
 
1664
    size_t fog_coord_src;
 
1665
    size_t front_face;
 
1666
    size_t light_model_color_control;
 
1667
    size_t logic_op;
 
1668
    size_t polygon_mode;
 
1669
    size_t shade_model;
 
1670
    size_t stencil_func;
 
1671
    size_t stencil_op;
 
1672
    size_t stencil_func_separate;
 
1673
    size_t stencil_op_separate;
 
1674
    size_t stencil_mask_separate;
 
1675
    size_t light_enable;
 
1676
    size_t light_ambient;
 
1677
    size_t light_diffuse;
 
1678
    size_t light_specular;
 
1679
    size_t light_position;
 
1680
    size_t light_constant_attenuation;
 
1681
    size_t light_linear_attenuation;
 
1682
    size_t light_quadratic_attenuation;
 
1683
    size_t light_spot_cutoff;
 
1684
    size_t light_spot_direction;
 
1685
    size_t light_spot_exponent;
 
1686
    size_t texture1D;
 
1687
    size_t texture2D;
 
1688
    size_t texture3D;
 
1689
    size_t textureCUBE;
 
1690
    size_t textureRECT;
 
1691
    size_t textureDEPTH;
 
1692
    size_t texture1D_enable;
 
1693
    size_t texture2D_enable;
 
1694
    size_t texture3D_enable;
 
1695
    size_t textureCUBE_enable;
 
1696
    size_t textureRECT_enable;
 
1697
    size_t textureDEPTH_enable;
 
1698
    size_t texture_env_color;
 
1699
    size_t texture_env_mode;
 
1700
    size_t clip_plane;
 
1701
    size_t clip_plane_enable;
 
1702
    size_t blend_color;
 
1703
    size_t color_mask;
 
1704
    size_t depth_bounds;
 
1705
    size_t depth_mask;
 
1706
    size_t depth_range;
 
1707
    size_t fog_density;
 
1708
    size_t fog_start;
 
1709
    size_t fog_end;
 
1710
    size_t fog_color;
 
1711
    size_t light_model_ambient;
 
1712
    size_t lighting_enable;
 
1713
    size_t line_stipple;
 
1714
    size_t line_width;
 
1715
    size_t material_ambient;
 
1716
    size_t material_diffuse;
 
1717
    size_t material_emission;
 
1718
    size_t material_shininess;
 
1719
    size_t material_specular;
 
1720
    size_t model_view_matrix;
 
1721
    size_t point_distance_attenuation;
 
1722
    size_t point_fade_threshold_size;
 
1723
    size_t point_size;
 
1724
    size_t point_size_min;
 
1725
    size_t point_size_max;
 
1726
    size_t polygon_offset;
 
1727
    size_t projection_matrix;
 
1728
    size_t scissor;
 
1729
    size_t stencil_mask;
 
1730
    size_t alpha_test_enable;
 
1731
    size_t blend_enable;
 
1732
    size_t color_logic_op_enable;
 
1733
    size_t color_material_enable;
 
1734
    size_t cull_face_enable;
 
1735
    size_t depth_bounds_enable;
 
1736
    size_t depth_clamp_enable;
 
1737
    size_t depth_test_enable;
 
1738
    size_t dither_enable;
 
1739
    size_t fog_enable;
 
1740
    size_t light_model_local_viewer_enable;
 
1741
    size_t light_model_two_side_enable;
 
1742
    size_t line_smooth_enable;
 
1743
    size_t line_stipple_enable;
 
1744
    size_t logic_op_enable;
 
1745
    size_t multisample_enable;
 
1746
    size_t normalize_enable;
 
1747
    size_t point_smooth_enable;
 
1748
    size_t polygon_offset_fill_enable;
 
1749
    size_t polygon_offset_line_enable;
 
1750
    size_t polygon_offset_point_enable;
 
1751
    size_t polygon_smooth_enable;
 
1752
    size_t polygon_stipple_enable;
 
1753
    size_t rescale_normal_enable;
 
1754
    size_t sample_alpha_to_coverage_enable;
 
1755
    size_t sample_alpha_to_one_enable;
 
1756
    size_t sample_coverage_enable;
 
1757
    size_t scissor_test_enable;
 
1758
    size_t stencil_test_enable;
 
1759
};
 
1760
 
 
1761
struct profile_GLSL__technique__pass__states__alpha_func__ValidationData
 
1762
{
 
1763
    size_t func;
 
1764
    size_t value;
 
1765
};
 
1766
 
 
1767
ParserError::ErrorType validate__gl_alpha_value_type( const float value );
 
1768
 
 
1769
struct profile_GLSL__technique__pass__states__blend_func__ValidationData
 
1770
{
 
1771
    size_t src;
 
1772
    size_t dest;
 
1773
};
 
1774
 
 
1775
struct profile_GLSL__technique__pass__states__blend_func_separate__ValidationData
 
1776
{
 
1777
    size_t src_rgb;
 
1778
    size_t dest_rgb;
 
1779
    size_t src_alpha;
 
1780
    size_t dest_alpha;
 
1781
};
 
1782
 
 
1783
struct profile_GLSL__technique__pass__states__blend_equation_separate__ValidationData
 
1784
{
 
1785
    size_t rgb;
 
1786
    size_t alpha;
 
1787
};
 
1788
 
 
1789
struct color_material__ValidationData
 
1790
{
 
1791
    size_t face;
 
1792
    size_t mode;
 
1793
};
 
1794
 
 
1795
ParserError::ErrorType validate__gl_material_enum( ParserString value );
 
1796
ParserError::ErrorType validate__gl_material_enum( const ParserChar* value, size_t length );
 
1797
ParserError::ErrorType validate__gl_material_enum__stream( const ParserChar* value, size_t length );
 
1798
ParserError::ErrorType validate__gl_material_enum__streamEnd( const ParserChar* value, size_t length );
 
1799
 
 
1800
ParserError::ErrorType validate__gl_fog_enum( ParserString value );
 
1801
ParserError::ErrorType validate__gl_fog_enum( const ParserChar* value, size_t length );
 
1802
ParserError::ErrorType validate__gl_fog_enum__stream( const ParserChar* value, size_t length );
 
1803
ParserError::ErrorType validate__gl_fog_enum__streamEnd( const ParserChar* value, size_t length );
 
1804
 
 
1805
ParserError::ErrorType validate__gl_fog_coord_src_enum( ParserString value );
 
1806
ParserError::ErrorType validate__gl_fog_coord_src_enum( const ParserChar* value, size_t length );
 
1807
ParserError::ErrorType validate__gl_fog_coord_src_enum__stream( const ParserChar* value, size_t length );
 
1808
ParserError::ErrorType validate__gl_fog_coord_src_enum__streamEnd( const ParserChar* value, size_t length );
 
1809
 
 
1810
ParserError::ErrorType validate__gl_light_model_color_control_enum( ParserString value );
 
1811
ParserError::ErrorType validate__gl_light_model_color_control_enum( const ParserChar* value, size_t length );
 
1812
ParserError::ErrorType validate__gl_light_model_color_control_enum__stream( const ParserChar* value, size_t length );
 
1813
ParserError::ErrorType validate__gl_light_model_color_control_enum__streamEnd( const ParserChar* value, size_t length );
 
1814
 
 
1815
ParserError::ErrorType validate__gl_logic_op_enum( ParserString value );
 
1816
ParserError::ErrorType validate__gl_logic_op_enum( const ParserChar* value, size_t length );
 
1817
ParserError::ErrorType validate__gl_logic_op_enum__stream( const ParserChar* value, size_t length );
 
1818
ParserError::ErrorType validate__gl_logic_op_enum__streamEnd( const ParserChar* value, size_t length );
 
1819
 
 
1820
struct polygon_mode__ValidationData
 
1821
{
 
1822
    size_t face;
 
1823
    size_t mode;
 
1824
};
 
1825
 
 
1826
ParserError::ErrorType validate__gl_polygon_mode_enum( ParserString value );
 
1827
ParserError::ErrorType validate__gl_polygon_mode_enum( const ParserChar* value, size_t length );
 
1828
ParserError::ErrorType validate__gl_polygon_mode_enum__stream( const ParserChar* value, size_t length );
 
1829
ParserError::ErrorType validate__gl_polygon_mode_enum__streamEnd( const ParserChar* value, size_t length );
 
1830
 
 
1831
ParserError::ErrorType validate__gl_shade_model_enum( ParserString value );
 
1832
ParserError::ErrorType validate__gl_shade_model_enum( const ParserChar* value, size_t length );
 
1833
ParserError::ErrorType validate__gl_shade_model_enum__stream( const ParserChar* value, size_t length );
 
1834
ParserError::ErrorType validate__gl_shade_model_enum__streamEnd( const ParserChar* value, size_t length );
 
1835
 
 
1836
struct profile_GLSL__technique__pass__states__stencil_func__ValidationData
 
1837
{
 
1838
    size_t func;
 
1839
    size_t ref;
 
1840
    size_t mask;
 
1841
};
 
1842
 
 
1843
struct profile_GLSL__technique__pass__states__stencil_op__ValidationData
 
1844
{
 
1845
    size_t fail;
 
1846
    size_t zfail;
 
1847
    size_t zpass;
 
1848
};
 
1849
 
 
1850
struct profile_GLSL__technique__pass__states__stencil_func_separate__ValidationData
 
1851
{
 
1852
    size_t front;
 
1853
    size_t back;
 
1854
    size_t ref;
 
1855
    size_t mask;
 
1856
};
 
1857
 
 
1858
struct profile_GLSL__technique__pass__states__stencil_op_separate__ValidationData
 
1859
{
 
1860
    size_t face;
 
1861
    size_t fail;
 
1862
    size_t zfail;
 
1863
    size_t zpass;
 
1864
};
 
1865
 
 
1866
struct profile_GLSL__technique__pass__states__stencil_mask_separate__ValidationData
 
1867
{
 
1868
    size_t face;
 
1869
    size_t mask;
 
1870
};
 
1871
 
 
1872
struct texture1D__ValidationData
 
1873
{
 
1874
    size_t value;
 
1875
    size_t param;
 
1876
};
 
1877
 
 
1878
struct texture2D__ValidationData
 
1879
{
 
1880
    size_t value;
 
1881
    size_t param;
 
1882
};
 
1883
 
 
1884
struct texture3D__ValidationData
 
1885
{
 
1886
    size_t value;
 
1887
    size_t param;
 
1888
};
 
1889
 
 
1890
struct textureCUBE__ValidationData
 
1891
{
 
1892
    size_t value;
 
1893
    size_t param;
 
1894
};
 
1895
 
 
1896
struct textureRECT__ValidationData
 
1897
{
 
1898
    size_t value;
 
1899
    size_t param;
 
1900
};
 
1901
 
 
1902
struct textureDEPTH__ValidationData
 
1903
{
 
1904
    size_t value;
 
1905
    size_t param;
 
1906
};
 
1907
 
 
1908
struct program____glsl_program_type__ValidationData
 
1909
{
 
1910
    size_t shader;
 
1911
    size_t bind_attribute;
 
1912
    size_t bind_uniform;
 
1913
};
 
1914
 
 
1915
struct shader____glsl_shader_type__ValidationData
 
1916
{
 
1917
    size_t sources;
 
1918
    size_t extra;
 
1919
};
 
1920
 
 
1921
struct sources____fx_sources_type__ValidationData
 
1922
{
 
1923
    size_t validation_current_state;
 
1924
    size_t inline_;
 
1925
    size_t import;
 
1926
};
 
1927
 
 
1928
struct glsl_program_type____bind_attribute__ValidationData
 
1929
{
 
1930
    size_t semantic;
 
1931
};
 
1932
 
 
1933
struct glsl_program_type____bind_uniform__ValidationData
 
1934
{
 
1935
    size_t validation_current_state;
 
1936
    size_t param;
 
1937
    size_t _bool;
 
1938
    size_t bool2;
 
1939
    size_t bool3;
 
1940
    size_t bool4;
 
1941
    size_t _float;
 
1942
    size_t float2;
 
1943
    size_t float3;
 
1944
    size_t float4;
 
1945
    size_t float2x2;
 
1946
    size_t float3x3;
 
1947
    size_t float4x4;
 
1948
    size_t _int;
 
1949
    size_t int2;
 
1950
    size_t int3;
 
1951
    size_t int4;
 
1952
    size_t sampler1D;
 
1953
    size_t sampler2D;
 
1954
    size_t sampler3D;
 
1955
    size_t samplerCUBE;
 
1956
    size_t samplerRECT;
 
1957
    size_t samplerDEPTH;
 
1958
    size_t _enum;
 
1959
    size_t array;
 
1960
};
 
1961
 
 
1962
struct profile_GLSL__technique__pass__evaluate__ValidationData
 
1963
{
 
1964
    size_t color_target;
 
1965
    size_t depth_target;
 
1966
    size_t stencil_target;
 
1967
    size_t color_clear;
 
1968
    size_t depth_clear;
 
1969
    size_t stencil_clear;
 
1970
    size_t draw;
 
1971
};
 
1972
 
 
1973
struct profile_CG__ValidationData
 
1974
{
 
1975
    size_t validation_current_state;
 
1976
    size_t asset;
 
1977
    size_t code;
 
1978
    size_t include;
 
1979
    size_t newparam;
 
1980
    size_t technique;
 
1981
    size_t extra;
 
1982
};
 
1983
 
 
1984
struct newparam____cg_newparam_type__ValidationData
 
1985
{
 
1986
    size_t validation_current_state;
 
1987
    size_t annotate;
 
1988
    size_t semantic;
 
1989
    size_t modifier;
 
1990
    size_t _bool;
 
1991
    size_t bool2;
 
1992
    size_t bool3;
 
1993
    size_t bool4;
 
1994
    size_t bool2x1;
 
1995
    size_t bool2x2;
 
1996
    size_t bool2x3;
 
1997
    size_t bool2x4;
 
1998
    size_t bool3x1;
 
1999
    size_t bool3x2;
 
2000
    size_t bool3x3;
 
2001
    size_t bool3x4;
 
2002
    size_t bool4x1;
 
2003
    size_t bool4x2;
 
2004
    size_t bool4x3;
 
2005
    size_t bool4x4;
 
2006
    size_t _float;
 
2007
    size_t float2;
 
2008
    size_t float3;
 
2009
    size_t float4;
 
2010
    size_t float2x1;
 
2011
    size_t float2x2;
 
2012
    size_t float2x3;
 
2013
    size_t float2x4;
 
2014
    size_t float3x1;
 
2015
    size_t float3x2;
 
2016
    size_t float3x3;
 
2017
    size_t float3x4;
 
2018
    size_t float4x1;
 
2019
    size_t float4x2;
 
2020
    size_t float4x3;
 
2021
    size_t float4x4;
 
2022
    size_t _int;
 
2023
    size_t int2;
 
2024
    size_t int3;
 
2025
    size_t int4;
 
2026
    size_t int2x1;
 
2027
    size_t int2x2;
 
2028
    size_t int2x3;
 
2029
    size_t int2x4;
 
2030
    size_t int3x1;
 
2031
    size_t int3x2;
 
2032
    size_t int3x3;
 
2033
    size_t int3x4;
 
2034
    size_t int4x1;
 
2035
    size_t int4x2;
 
2036
    size_t int4x3;
 
2037
    size_t int4x4;
 
2038
    size_t half;
 
2039
    size_t half2;
 
2040
    size_t half3;
 
2041
    size_t half4;
 
2042
    size_t half2x1;
 
2043
    size_t half2x2;
 
2044
    size_t half2x3;
 
2045
    size_t half2x4;
 
2046
    size_t half3x1;
 
2047
    size_t half3x2;
 
2048
    size_t half3x3;
 
2049
    size_t half3x4;
 
2050
    size_t half4x1;
 
2051
    size_t half4x2;
 
2052
    size_t half4x3;
 
2053
    size_t _half4x4;
 
2054
    size_t fixed;
 
2055
    size_t fixed2;
 
2056
    size_t fixed3;
 
2057
    size_t fixed4;
 
2058
    size_t fixed2x1;
 
2059
    size_t fixed2x2;
 
2060
    size_t fixed2x3;
 
2061
    size_t fixed2x4;
 
2062
    size_t fixed3x1;
 
2063
    size_t fixed3x2;
 
2064
    size_t fixed3x3;
 
2065
    size_t fixed3x4;
 
2066
    size_t fixed4x1;
 
2067
    size_t fixed4x2;
 
2068
    size_t fixed4x3;
 
2069
    size_t fixed4x4;
 
2070
    size_t sampler1D;
 
2071
    size_t sampler2D;
 
2072
    size_t sampler3D;
 
2073
    size_t samplerRECT;
 
2074
    size_t samplerCUBE;
 
2075
    size_t samplerDEPTH;
 
2076
    size_t string;
 
2077
    size_t _enum;
 
2078
    size_t array;
 
2079
    size_t usertype;
 
2080
};
 
2081
 
 
2082
struct bool2x2__ValidationData
 
2083
{
 
2084
    size_t validationWholeSize;
 
2085
};
 
2086
 
 
2087
ParserError::ErrorType validate__bool2x2_type( const bool* value, size_t length );
 
2088
ParserError::ErrorType validate__bool2x2_type__stream( const bool* value, size_t length );
 
2089
ParserError::ErrorType validate__bool2x2_type__streamEnd( const bool* value, size_t length );
 
2090
 
 
2091
struct bool2x3__ValidationData
 
2092
{
 
2093
    size_t validationWholeSize;
 
2094
};
 
2095
 
 
2096
ParserError::ErrorType validate__bool2x3_type( const bool* value, size_t length );
 
2097
ParserError::ErrorType validate__bool2x3_type__stream( const bool* value, size_t length );
 
2098
ParserError::ErrorType validate__bool2x3_type__streamEnd( const bool* value, size_t length );
 
2099
 
 
2100
struct bool2x4__ValidationData
 
2101
{
 
2102
    size_t validationWholeSize;
 
2103
};
 
2104
 
 
2105
ParserError::ErrorType validate__bool2x4_type( const bool* value, size_t length );
 
2106
ParserError::ErrorType validate__bool2x4_type__stream( const bool* value, size_t length );
 
2107
ParserError::ErrorType validate__bool2x4_type__streamEnd( const bool* value, size_t length );
 
2108
 
 
2109
struct bool3x2__ValidationData
 
2110
{
 
2111
    size_t validationWholeSize;
 
2112
};
 
2113
 
 
2114
ParserError::ErrorType validate__bool3x2_type( const bool* value, size_t length );
 
2115
ParserError::ErrorType validate__bool3x2_type__stream( const bool* value, size_t length );
 
2116
ParserError::ErrorType validate__bool3x2_type__streamEnd( const bool* value, size_t length );
 
2117
 
 
2118
struct bool3x3__ValidationData
 
2119
{
 
2120
    size_t validationWholeSize;
 
2121
};
 
2122
 
 
2123
ParserError::ErrorType validate__bool3x3_type( const bool* value, size_t length );
 
2124
ParserError::ErrorType validate__bool3x3_type__stream( const bool* value, size_t length );
 
2125
ParserError::ErrorType validate__bool3x3_type__streamEnd( const bool* value, size_t length );
 
2126
 
 
2127
struct bool3x4__ValidationData
 
2128
{
 
2129
    size_t validationWholeSize;
 
2130
};
 
2131
 
 
2132
ParserError::ErrorType validate__bool3x4_type( const bool* value, size_t length );
 
2133
ParserError::ErrorType validate__bool3x4_type__stream( const bool* value, size_t length );
 
2134
ParserError::ErrorType validate__bool3x4_type__streamEnd( const bool* value, size_t length );
 
2135
 
 
2136
struct bool4x2__ValidationData
 
2137
{
 
2138
    size_t validationWholeSize;
 
2139
};
 
2140
 
 
2141
ParserError::ErrorType validate__bool4x2_type( const bool* value, size_t length );
 
2142
ParserError::ErrorType validate__bool4x2_type__stream( const bool* value, size_t length );
 
2143
ParserError::ErrorType validate__bool4x2_type__streamEnd( const bool* value, size_t length );
 
2144
 
 
2145
struct bool4x3__ValidationData
 
2146
{
 
2147
    size_t validationWholeSize;
 
2148
};
 
2149
 
 
2150
ParserError::ErrorType validate__bool4x3_type( const bool* value, size_t length );
 
2151
ParserError::ErrorType validate__bool4x3_type__stream( const bool* value, size_t length );
 
2152
ParserError::ErrorType validate__bool4x3_type__streamEnd( const bool* value, size_t length );
 
2153
 
 
2154
struct bool4x4__ValidationData
 
2155
{
 
2156
    size_t validationWholeSize;
 
2157
};
 
2158
 
 
2159
ParserError::ErrorType validate__bool4x4_type( const bool* value, size_t length );
 
2160
ParserError::ErrorType validate__bool4x4_type__stream( const bool* value, size_t length );
 
2161
ParserError::ErrorType validate__bool4x4_type__streamEnd( const bool* value, size_t length );
 
2162
 
 
2163
struct int2x2__ValidationData
 
2164
{
 
2165
    size_t validationWholeSize;
 
2166
};
 
2167
 
 
2168
ParserError::ErrorType validate__int2x2_type( const sint64* value, size_t length );
 
2169
ParserError::ErrorType validate__int2x2_type__stream( const sint64* value, size_t length );
 
2170
ParserError::ErrorType validate__int2x2_type__streamEnd( const sint64* value, size_t length );
 
2171
 
 
2172
struct int2x3__ValidationData
 
2173
{
 
2174
    size_t validationWholeSize;
 
2175
};
 
2176
 
 
2177
ParserError::ErrorType validate__int2x3_type( const sint64* value, size_t length );
 
2178
ParserError::ErrorType validate__int2x3_type__stream( const sint64* value, size_t length );
 
2179
ParserError::ErrorType validate__int2x3_type__streamEnd( const sint64* value, size_t length );
 
2180
 
 
2181
struct int2x4__ValidationData
 
2182
{
 
2183
    size_t validationWholeSize;
 
2184
};
 
2185
 
 
2186
ParserError::ErrorType validate__int2x4_type( const sint64* value, size_t length );
 
2187
ParserError::ErrorType validate__int2x4_type__stream( const sint64* value, size_t length );
 
2188
ParserError::ErrorType validate__int2x4_type__streamEnd( const sint64* value, size_t length );
 
2189
 
 
2190
struct int3x2__ValidationData
 
2191
{
 
2192
    size_t validationWholeSize;
 
2193
};
 
2194
 
 
2195
ParserError::ErrorType validate__int3x2_type( const sint64* value, size_t length );
 
2196
ParserError::ErrorType validate__int3x2_type__stream( const sint64* value, size_t length );
 
2197
ParserError::ErrorType validate__int3x2_type__streamEnd( const sint64* value, size_t length );
 
2198
 
 
2199
struct int3x3__ValidationData
 
2200
{
 
2201
    size_t validationWholeSize;
 
2202
};
 
2203
 
 
2204
ParserError::ErrorType validate__int3x3_type( const sint64* value, size_t length );
 
2205
ParserError::ErrorType validate__int3x3_type__stream( const sint64* value, size_t length );
 
2206
ParserError::ErrorType validate__int3x3_type__streamEnd( const sint64* value, size_t length );
 
2207
 
 
2208
struct int3x4__ValidationData
 
2209
{
 
2210
    size_t validationWholeSize;
 
2211
};
 
2212
 
 
2213
ParserError::ErrorType validate__int3x4_type( const sint64* value, size_t length );
 
2214
ParserError::ErrorType validate__int3x4_type__stream( const sint64* value, size_t length );
 
2215
ParserError::ErrorType validate__int3x4_type__streamEnd( const sint64* value, size_t length );
 
2216
 
 
2217
struct int4x2__ValidationData
 
2218
{
 
2219
    size_t validationWholeSize;
 
2220
};
 
2221
 
 
2222
ParserError::ErrorType validate__int4x2_type( const sint64* value, size_t length );
 
2223
ParserError::ErrorType validate__int4x2_type__stream( const sint64* value, size_t length );
 
2224
ParserError::ErrorType validate__int4x2_type__streamEnd( const sint64* value, size_t length );
 
2225
 
 
2226
struct int4x3__ValidationData
 
2227
{
 
2228
    size_t validationWholeSize;
 
2229
};
 
2230
 
 
2231
ParserError::ErrorType validate__int4x3_type( const sint64* value, size_t length );
 
2232
ParserError::ErrorType validate__int4x3_type__stream( const sint64* value, size_t length );
 
2233
ParserError::ErrorType validate__int4x3_type__streamEnd( const sint64* value, size_t length );
 
2234
 
 
2235
struct int4x4__ValidationData
 
2236
{
 
2237
    size_t validationWholeSize;
 
2238
};
 
2239
 
 
2240
ParserError::ErrorType validate__int4x4_type( const sint64* value, size_t length );
 
2241
ParserError::ErrorType validate__int4x4_type__stream( const sint64* value, size_t length );
 
2242
ParserError::ErrorType validate__int4x4_type__streamEnd( const sint64* value, size_t length );
 
2243
 
 
2244
struct array____cg_array_type__ValidationData
 
2245
{
 
2246
    size_t validation_current_state;
 
2247
    size_t _bool;
 
2248
    size_t bool2;
 
2249
    size_t bool3;
 
2250
    size_t bool4;
 
2251
    size_t bool2x1;
 
2252
    size_t bool2x2;
 
2253
    size_t bool2x3;
 
2254
    size_t bool2x4;
 
2255
    size_t bool3x1;
 
2256
    size_t bool3x2;
 
2257
    size_t bool3x3;
 
2258
    size_t bool3x4;
 
2259
    size_t bool4x1;
 
2260
    size_t bool4x2;
 
2261
    size_t bool4x3;
 
2262
    size_t bool4x4;
 
2263
    size_t _float;
 
2264
    size_t float2;
 
2265
    size_t float3;
 
2266
    size_t float4;
 
2267
    size_t float2x1;
 
2268
    size_t float2x2;
 
2269
    size_t float2x3;
 
2270
    size_t float2x4;
 
2271
    size_t float3x1;
 
2272
    size_t float3x2;
 
2273
    size_t float3x3;
 
2274
    size_t float3x4;
 
2275
    size_t float4x1;
 
2276
    size_t float4x2;
 
2277
    size_t float4x3;
 
2278
    size_t float4x4;
 
2279
    size_t _int;
 
2280
    size_t int2;
 
2281
    size_t int3;
 
2282
    size_t int4;
 
2283
    size_t int2x1;
 
2284
    size_t int2x2;
 
2285
    size_t int2x3;
 
2286
    size_t int2x4;
 
2287
    size_t int3x1;
 
2288
    size_t int3x2;
 
2289
    size_t int3x3;
 
2290
    size_t int3x4;
 
2291
    size_t int4x1;
 
2292
    size_t int4x2;
 
2293
    size_t int4x3;
 
2294
    size_t int4x4;
 
2295
    size_t half;
 
2296
    size_t half2;
 
2297
    size_t half3;
 
2298
    size_t half4;
 
2299
    size_t half2x1;
 
2300
    size_t half2x2;
 
2301
    size_t half2x3;
 
2302
    size_t half2x4;
 
2303
    size_t half3x1;
 
2304
    size_t half3x2;
 
2305
    size_t half3x3;
 
2306
    size_t half3x4;
 
2307
    size_t half4x1;
 
2308
    size_t half4x2;
 
2309
    size_t half4x3;
 
2310
    size_t _half4x4;
 
2311
    size_t fixed;
 
2312
    size_t fixed2;
 
2313
    size_t fixed3;
 
2314
    size_t fixed4;
 
2315
    size_t fixed2x1;
 
2316
    size_t fixed2x2;
 
2317
    size_t fixed2x3;
 
2318
    size_t fixed2x4;
 
2319
    size_t fixed3x1;
 
2320
    size_t fixed3x2;
 
2321
    size_t fixed3x3;
 
2322
    size_t fixed3x4;
 
2323
    size_t fixed4x1;
 
2324
    size_t fixed4x2;
 
2325
    size_t fixed4x3;
 
2326
    size_t fixed4x4;
 
2327
    size_t sampler1D;
 
2328
    size_t sampler2D;
 
2329
    size_t sampler3D;
 
2330
    size_t samplerRECT;
 
2331
    size_t samplerCUBE;
 
2332
    size_t samplerDEPTH;
 
2333
    size_t string;
 
2334
    size_t _enum;
 
2335
    size_t array;
 
2336
    size_t usertype;
 
2337
};
 
2338
 
 
2339
struct usertype____cg_user_type__ValidationData
 
2340
{
 
2341
    size_t setparam;
 
2342
};
 
2343
 
 
2344
struct setparam____cg_setparam_type__ValidationData
 
2345
{
 
2346
    size_t validation_current_state;
 
2347
    size_t _bool;
 
2348
    size_t bool2;
 
2349
    size_t bool3;
 
2350
    size_t bool4;
 
2351
    size_t bool2x1;
 
2352
    size_t bool2x2;
 
2353
    size_t bool2x3;
 
2354
    size_t bool2x4;
 
2355
    size_t bool3x1;
 
2356
    size_t bool3x2;
 
2357
    size_t bool3x3;
 
2358
    size_t bool3x4;
 
2359
    size_t bool4x1;
 
2360
    size_t bool4x2;
 
2361
    size_t bool4x3;
 
2362
    size_t bool4x4;
 
2363
    size_t _float;
 
2364
    size_t float2;
 
2365
    size_t float3;
 
2366
    size_t float4;
 
2367
    size_t float2x1;
 
2368
    size_t float2x2;
 
2369
    size_t float2x3;
 
2370
    size_t float2x4;
 
2371
    size_t float3x1;
 
2372
    size_t float3x2;
 
2373
    size_t float3x3;
 
2374
    size_t float3x4;
 
2375
    size_t float4x1;
 
2376
    size_t float4x2;
 
2377
    size_t float4x3;
 
2378
    size_t float4x4;
 
2379
    size_t _int;
 
2380
    size_t int2;
 
2381
    size_t int3;
 
2382
    size_t int4;
 
2383
    size_t int2x1;
 
2384
    size_t int2x2;
 
2385
    size_t int2x3;
 
2386
    size_t int2x4;
 
2387
    size_t int3x1;
 
2388
    size_t int3x2;
 
2389
    size_t int3x3;
 
2390
    size_t int3x4;
 
2391
    size_t int4x1;
 
2392
    size_t int4x2;
 
2393
    size_t int4x3;
 
2394
    size_t int4x4;
 
2395
    size_t half;
 
2396
    size_t half2;
 
2397
    size_t half3;
 
2398
    size_t half4;
 
2399
    size_t half2x1;
 
2400
    size_t half2x2;
 
2401
    size_t half2x3;
 
2402
    size_t half2x4;
 
2403
    size_t half3x1;
 
2404
    size_t half3x2;
 
2405
    size_t half3x3;
 
2406
    size_t half3x4;
 
2407
    size_t half4x1;
 
2408
    size_t half4x2;
 
2409
    size_t half4x3;
 
2410
    size_t _half4x4;
 
2411
    size_t fixed;
 
2412
    size_t fixed2;
 
2413
    size_t fixed3;
 
2414
    size_t fixed4;
 
2415
    size_t fixed2x1;
 
2416
    size_t fixed2x2;
 
2417
    size_t fixed2x3;
 
2418
    size_t fixed2x4;
 
2419
    size_t fixed3x1;
 
2420
    size_t fixed3x2;
 
2421
    size_t fixed3x3;
 
2422
    size_t fixed3x4;
 
2423
    size_t fixed4x1;
 
2424
    size_t fixed4x2;
 
2425
    size_t fixed4x3;
 
2426
    size_t fixed4x4;
 
2427
    size_t sampler1D;
 
2428
    size_t sampler2D;
 
2429
    size_t sampler3D;
 
2430
    size_t samplerRECT;
 
2431
    size_t samplerCUBE;
 
2432
    size_t samplerDEPTH;
 
2433
    size_t string;
 
2434
    size_t _enum;
 
2435
    size_t array;
 
2436
    size_t usertype;
 
2437
};
 
2438
 
 
2439
struct profile_cg_type____technique__ValidationData
 
2440
{
 
2441
    size_t asset;
 
2442
    size_t annotate;
 
2443
    size_t pass;
 
2444
    size_t extra;
 
2445
};
 
2446
 
 
2447
struct pass____cg_pass_type__ValidationData
 
2448
{
 
2449
    size_t annotate;
 
2450
    size_t states;
 
2451
    size_t program;
 
2452
    size_t evaluate;
 
2453
    size_t extra;
 
2454
};
 
2455
 
 
2456
struct cg_pass_type____states__ValidationData
 
2457
{
 
2458
    size_t validation_current_state;
 
2459
    size_t alpha_func;
 
2460
    size_t blend_func;
 
2461
    size_t blend_func_separate;
 
2462
    size_t blend_equation;
 
2463
    size_t blend_equation_separate;
 
2464
    size_t color_material;
 
2465
    size_t cull_face;
 
2466
    size_t depth_func;
 
2467
    size_t fog_mode;
 
2468
    size_t fog_coord_src;
 
2469
    size_t front_face;
 
2470
    size_t light_model_color_control;
 
2471
    size_t logic_op;
 
2472
    size_t polygon_mode;
 
2473
    size_t shade_model;
 
2474
    size_t stencil_func;
 
2475
    size_t stencil_op;
 
2476
    size_t stencil_func_separate;
 
2477
    size_t stencil_op_separate;
 
2478
    size_t stencil_mask_separate;
 
2479
    size_t light_enable;
 
2480
    size_t light_ambient;
 
2481
    size_t light_diffuse;
 
2482
    size_t light_specular;
 
2483
    size_t light_position;
 
2484
    size_t light_constant_attenuation;
 
2485
    size_t light_linear_attenuation;
 
2486
    size_t light_quadratic_attenuation;
 
2487
    size_t light_spot_cutoff;
 
2488
    size_t light_spot_direction;
 
2489
    size_t light_spot_exponent;
 
2490
    size_t texture1D;
 
2491
    size_t texture2D;
 
2492
    size_t texture3D;
 
2493
    size_t textureCUBE;
 
2494
    size_t textureRECT;
 
2495
    size_t textureDEPTH;
 
2496
    size_t texture1D_enable;
 
2497
    size_t texture2D_enable;
 
2498
    size_t texture3D_enable;
 
2499
    size_t textureCUBE_enable;
 
2500
    size_t textureRECT_enable;
 
2501
    size_t textureDEPTH_enable;
 
2502
    size_t texture_env_color;
 
2503
    size_t texture_env_mode;
 
2504
    size_t clip_plane;
 
2505
    size_t clip_plane_enable;
 
2506
    size_t blend_color;
 
2507
    size_t color_mask;
 
2508
    size_t depth_bounds;
 
2509
    size_t depth_mask;
 
2510
    size_t depth_range;
 
2511
    size_t fog_density;
 
2512
    size_t fog_start;
 
2513
    size_t fog_end;
 
2514
    size_t fog_color;
 
2515
    size_t light_model_ambient;
 
2516
    size_t lighting_enable;
 
2517
    size_t line_stipple;
 
2518
    size_t line_width;
 
2519
    size_t material_ambient;
 
2520
    size_t material_diffuse;
 
2521
    size_t material_emission;
 
2522
    size_t material_shininess;
 
2523
    size_t material_specular;
 
2524
    size_t model_view_matrix;
 
2525
    size_t point_distance_attenuation;
 
2526
    size_t point_fade_threshold_size;
 
2527
    size_t point_size;
 
2528
    size_t point_size_min;
 
2529
    size_t point_size_max;
 
2530
    size_t polygon_offset;
 
2531
    size_t projection_matrix;
 
2532
    size_t scissor;
 
2533
    size_t stencil_mask;
 
2534
    size_t alpha_test_enable;
 
2535
    size_t blend_enable;
 
2536
    size_t color_logic_op_enable;
 
2537
    size_t color_material_enable;
 
2538
    size_t cull_face_enable;
 
2539
    size_t depth_bounds_enable;
 
2540
    size_t depth_clamp_enable;
 
2541
    size_t depth_test_enable;
 
2542
    size_t dither_enable;
 
2543
    size_t fog_enable;
 
2544
    size_t light_model_local_viewer_enable;
 
2545
    size_t light_model_two_side_enable;
 
2546
    size_t line_smooth_enable;
 
2547
    size_t line_stipple_enable;
 
2548
    size_t logic_op_enable;
 
2549
    size_t multisample_enable;
 
2550
    size_t normalize_enable;
 
2551
    size_t point_smooth_enable;
 
2552
    size_t polygon_offset_fill_enable;
 
2553
    size_t polygon_offset_line_enable;
 
2554
    size_t polygon_offset_point_enable;
 
2555
    size_t polygon_smooth_enable;
 
2556
    size_t polygon_stipple_enable;
 
2557
    size_t rescale_normal_enable;
 
2558
    size_t sample_alpha_to_coverage_enable;
 
2559
    size_t sample_alpha_to_one_enable;
 
2560
    size_t sample_coverage_enable;
 
2561
    size_t scissor_test_enable;
 
2562
    size_t stencil_test_enable;
 
2563
};
 
2564
 
 
2565
struct cg_pass_type____program__ValidationData
 
2566
{
 
2567
    size_t shader;
 
2568
};
 
2569
 
 
2570
struct profile_CG__technique__pass__program__shader__ValidationData
 
2571
{
 
2572
    size_t sources;
 
2573
    size_t compiler;
 
2574
    size_t bind_uniform;
 
2575
};
 
2576
 
 
2577
struct profile_CG__technique__pass__program__shader__sources__ValidationData
 
2578
{
 
2579
    size_t validation_current_state;
 
2580
    size_t inline_;
 
2581
    size_t import;
 
2582
};
 
2583
 
 
2584
struct profile_CG__technique__pass__program__shader__bind_uniform__ValidationData
 
2585
{
 
2586
    size_t validation_current_state;
 
2587
    size_t param;
 
2588
    size_t _bool;
 
2589
    size_t bool2;
 
2590
    size_t bool3;
 
2591
    size_t bool4;
 
2592
    size_t bool2x1;
 
2593
    size_t bool2x2;
 
2594
    size_t bool2x3;
 
2595
    size_t bool2x4;
 
2596
    size_t bool3x1;
 
2597
    size_t bool3x2;
 
2598
    size_t bool3x3;
 
2599
    size_t bool3x4;
 
2600
    size_t bool4x1;
 
2601
    size_t bool4x2;
 
2602
    size_t bool4x3;
 
2603
    size_t bool4x4;
 
2604
    size_t _float;
 
2605
    size_t float2;
 
2606
    size_t float3;
 
2607
    size_t float4;
 
2608
    size_t float2x1;
 
2609
    size_t float2x2;
 
2610
    size_t float2x3;
 
2611
    size_t float2x4;
 
2612
    size_t float3x1;
 
2613
    size_t float3x2;
 
2614
    size_t float3x3;
 
2615
    size_t float3x4;
 
2616
    size_t float4x1;
 
2617
    size_t float4x2;
 
2618
    size_t float4x3;
 
2619
    size_t float4x4;
 
2620
    size_t _int;
 
2621
    size_t int2;
 
2622
    size_t int3;
 
2623
    size_t int4;
 
2624
    size_t int2x1;
 
2625
    size_t int2x2;
 
2626
    size_t int2x3;
 
2627
    size_t int2x4;
 
2628
    size_t int3x1;
 
2629
    size_t int3x2;
 
2630
    size_t int3x3;
 
2631
    size_t int3x4;
 
2632
    size_t int4x1;
 
2633
    size_t int4x2;
 
2634
    size_t int4x3;
 
2635
    size_t int4x4;
 
2636
    size_t half;
 
2637
    size_t half2;
 
2638
    size_t half3;
 
2639
    size_t half4;
 
2640
    size_t half2x1;
 
2641
    size_t half2x2;
 
2642
    size_t half2x3;
 
2643
    size_t half2x4;
 
2644
    size_t half3x1;
 
2645
    size_t half3x2;
 
2646
    size_t half3x3;
 
2647
    size_t half3x4;
 
2648
    size_t half4x1;
 
2649
    size_t half4x2;
 
2650
    size_t half4x3;
 
2651
    size_t _half4x4;
 
2652
    size_t fixed;
 
2653
    size_t fixed2;
 
2654
    size_t fixed3;
 
2655
    size_t fixed4;
 
2656
    size_t fixed2x1;
 
2657
    size_t fixed2x2;
 
2658
    size_t fixed2x3;
 
2659
    size_t fixed2x4;
 
2660
    size_t fixed3x1;
 
2661
    size_t fixed3x2;
 
2662
    size_t fixed3x3;
 
2663
    size_t fixed3x4;
 
2664
    size_t fixed4x1;
 
2665
    size_t fixed4x2;
 
2666
    size_t fixed4x3;
 
2667
    size_t fixed4x4;
 
2668
    size_t sampler1D;
 
2669
    size_t sampler2D;
 
2670
    size_t sampler3D;
 
2671
    size_t samplerRECT;
 
2672
    size_t samplerCUBE;
 
2673
    size_t samplerDEPTH;
 
2674
    size_t string;
 
2675
    size_t _enum;
 
2676
    size_t array;
 
2677
    size_t usertype;
 
2678
};
 
2679
 
 
2680
struct cg_pass_type____evaluate__ValidationData
 
2681
{
 
2682
    size_t color_target;
 
2683
    size_t depth_target;
 
2684
    size_t stencil_target;
 
2685
    size_t color_clear;
 
2686
    size_t depth_clear;
 
2687
    size_t stencil_clear;
 
2688
    size_t draw;
 
2689
};
 
2690
 
 
2691
struct profile_GLES__ValidationData
 
2692
{
 
2693
    size_t asset;
 
2694
    size_t newparam;
 
2695
    size_t technique;
 
2696
    size_t extra;
 
2697
};
 
2698
 
 
2699
struct newparam____gles_newparam_type__ValidationData
 
2700
{
 
2701
    size_t validation_current_state;
 
2702
    size_t annotate;
 
2703
    size_t semantic;
 
2704
    size_t modifier;
 
2705
    size_t _bool;
 
2706
    size_t bool2;
 
2707
    size_t bool3;
 
2708
    size_t bool4;
 
2709
    size_t _int;
 
2710
    size_t int2;
 
2711
    size_t int3;
 
2712
    size_t int4;
 
2713
    size_t _float;
 
2714
    size_t float2;
 
2715
    size_t float3;
 
2716
    size_t float4;
 
2717
    size_t float1x1;
 
2718
    size_t float1x2;
 
2719
    size_t float1x3;
 
2720
    size_t float1x4;
 
2721
    size_t float2x1;
 
2722
    size_t float2x2;
 
2723
    size_t float2x3;
 
2724
    size_t float2x4;
 
2725
    size_t float3x1;
 
2726
    size_t float3x2;
 
2727
    size_t float3x3;
 
2728
    size_t float3x4;
 
2729
    size_t float4x1;
 
2730
    size_t float4x2;
 
2731
    size_t float4x3;
 
2732
    size_t float4x4;
 
2733
    size_t sampler2D;
 
2734
    size_t _enum;
 
2735
};
 
2736
 
 
2737
struct sampler2D____gles_sampler_type__ValidationData
 
2738
{
 
2739
    size_t validation_current_state;
 
2740
    size_t instance_image;
 
2741
    size_t texcoord;
 
2742
    size_t wrap_s;
 
2743
    size_t wrap_t;
 
2744
    size_t minfilter;
 
2745
    size_t magfilter;
 
2746
    size_t mipfilter;
 
2747
    size_t mip_max_level;
 
2748
    size_t mip_bias;
 
2749
    size_t extra;
 
2750
};
 
2751
 
 
2752
ParserError::ErrorType validate__gles_sampler_wrap_enum( ParserString value );
 
2753
ParserError::ErrorType validate__gles_sampler_wrap_enum( const ParserChar* value, size_t length );
 
2754
ParserError::ErrorType validate__gles_sampler_wrap_enum__stream( const ParserChar* value, size_t length );
 
2755
ParserError::ErrorType validate__gles_sampler_wrap_enum__streamEnd( const ParserChar* value, size_t length );
 
2756
 
 
2757
struct profile_gles_type____technique__ValidationData
 
2758
{
 
2759
    size_t asset;
 
2760
    size_t annotate;
 
2761
    size_t pass;
 
2762
    size_t extra;
 
2763
};
 
2764
 
 
2765
struct profile_GLES__technique__pass__ValidationData
 
2766
{
 
2767
    size_t annotate;
 
2768
    size_t states;
 
2769
    size_t evaluate;
 
2770
    size_t extra;
 
2771
};
 
2772
 
 
2773
struct profile_GLES__technique__pass__states__ValidationData
 
2774
{
 
2775
    size_t validation_current_state;
 
2776
    size_t alpha_func;
 
2777
    size_t blend_func;
 
2778
    size_t clip_plane;
 
2779
    size_t color_mask;
 
2780
    size_t cull_face;
 
2781
    size_t depth_func;
 
2782
    size_t depth_mask;
 
2783
    size_t depth_range;
 
2784
    size_t fog_color;
 
2785
    size_t fog_density;
 
2786
    size_t fog_mode;
 
2787
    size_t fog_start;
 
2788
    size_t fog_end;
 
2789
    size_t front_face;
 
2790
    size_t logic_op;
 
2791
    size_t light_ambient;
 
2792
    size_t light_diffuse;
 
2793
    size_t light_specular;
 
2794
    size_t light_position;
 
2795
    size_t light_constant_attenuation;
 
2796
    size_t light_linear_attenuation;
 
2797
    size_t light_quadratic_attenuation;
 
2798
    size_t light_spot_cutoff;
 
2799
    size_t light_spot_direction;
 
2800
    size_t light_spot_exponent;
 
2801
    size_t light_model_ambient;
 
2802
    size_t line_width;
 
2803
    size_t material_ambient;
 
2804
    size_t material_diffuse;
 
2805
    size_t material_emission;
 
2806
    size_t material_shininess;
 
2807
    size_t material_specular;
 
2808
    size_t model_view_matrix;
 
2809
    size_t point_distance_attenuation;
 
2810
    size_t point_fade_threshold_size;
 
2811
    size_t point_size;
 
2812
    size_t point_size_min;
 
2813
    size_t point_size_max;
 
2814
    size_t polygon_offset;
 
2815
    size_t projection_matrix;
 
2816
    size_t scissor;
 
2817
    size_t shade_model;
 
2818
    size_t stencil_func;
 
2819
    size_t stencil_mask;
 
2820
    size_t stencil_op;
 
2821
    size_t texture_pipeline;
 
2822
    size_t alpha_test_enable;
 
2823
    size_t blend_enable;
 
2824
    size_t clip_plane_enable;
 
2825
    size_t color_logic_op_enable;
 
2826
    size_t color_material_enable;
 
2827
    size_t cull_face_enable;
 
2828
    size_t depth_test_enable;
 
2829
    size_t dither_enable;
 
2830
    size_t fog_enable;
 
2831
    size_t light_enable;
 
2832
    size_t lighting_enable;
 
2833
    size_t light_model_two_side_enable;
 
2834
    size_t line_smooth_enable;
 
2835
    size_t multisample_enable;
 
2836
    size_t normalize_enable;
 
2837
    size_t point_smooth_enable;
 
2838
    size_t polygon_offset_fill_enable;
 
2839
    size_t rescale_normal_enable;
 
2840
    size_t sample_alpha_to_coverage_enable;
 
2841
    size_t sample_alpha_to_one_enable;
 
2842
    size_t sample_coverage_enable;
 
2843
    size_t scissor_test_enable;
 
2844
    size_t stencil_test_enable;
 
2845
};
 
2846
 
 
2847
struct profile_GLES__technique__pass__states__alpha_func__ValidationData
 
2848
{
 
2849
    size_t func;
 
2850
    size_t value;
 
2851
};
 
2852
 
 
2853
struct profile_GLES__technique__pass__states__blend_func__ValidationData
 
2854
{
 
2855
    size_t src;
 
2856
    size_t dest;
 
2857
};
 
2858
 
 
2859
ParserError::ErrorType validate__gles_max_clip_planes_index_type( const uint64 value );
 
2860
 
 
2861
ParserError::ErrorType validate__gles_max_lights_index_type( const uint64 value );
 
2862
 
 
2863
struct profile_GLES__technique__pass__states__stencil_func__ValidationData
 
2864
{
 
2865
    size_t func;
 
2866
    size_t ref;
 
2867
    size_t mask;
 
2868
};
 
2869
 
 
2870
struct profile_GLES__technique__pass__states__stencil_op__ValidationData
 
2871
{
 
2872
    size_t fail;
 
2873
    size_t zfail;
 
2874
    size_t zpass;
 
2875
};
 
2876
 
 
2877
ParserError::ErrorType validate__gles_stencil_op_enum( ParserString value );
 
2878
ParserError::ErrorType validate__gles_stencil_op_enum( const ParserChar* value, size_t length );
 
2879
ParserError::ErrorType validate__gles_stencil_op_enum__stream( const ParserChar* value, size_t length );
 
2880
ParserError::ErrorType validate__gles_stencil_op_enum__streamEnd( const ParserChar* value, size_t length );
 
2881
 
 
2882
struct texture_pipeline__ValidationData
 
2883
{
 
2884
    size_t value;
 
2885
};
 
2886
 
 
2887
struct value____gles_texture_pipeline_type__ValidationData
 
2888
{
 
2889
    size_t texcombiner;
 
2890
    size_t texenv;
 
2891
    size_t extra;
 
2892
};
 
2893
 
 
2894
struct texcombiner__ValidationData
 
2895
{
 
2896
    size_t constant;
 
2897
    size_t RGB;
 
2898
    size_t alpha;
 
2899
};
 
2900
 
 
2901
ParserError::ErrorType validate__gles_texcombiner_operator_rgb_enum( ParserString value );
 
2902
ParserError::ErrorType validate__gles_texcombiner_operator_rgb_enum( const ParserChar* value, size_t length );
 
2903
ParserError::ErrorType validate__gles_texcombiner_operator_rgb_enum__stream( const ParserChar* value, size_t length );
 
2904
ParserError::ErrorType validate__gles_texcombiner_operator_rgb_enum__streamEnd( const ParserChar* value, size_t length );
 
2905
 
 
2906
struct RGB__ValidationData
 
2907
{
 
2908
    size_t argument;
 
2909
};
 
2910
 
 
2911
ParserError::ErrorType validate__gles_texcombiner_source_enum( ParserString value );
 
2912
ParserError::ErrorType validate__gles_texcombiner_source_enum( const ParserChar* value, size_t length );
 
2913
ParserError::ErrorType validate__gles_texcombiner_source_enum__stream( const ParserChar* value, size_t length );
 
2914
ParserError::ErrorType validate__gles_texcombiner_source_enum__streamEnd( const ParserChar* value, size_t length );
 
2915
 
 
2916
ParserError::ErrorType validate__gles_texcombiner_operand_rgb_enum( ParserString value );
 
2917
ParserError::ErrorType validate__gles_texcombiner_operand_rgb_enum( const ParserChar* value, size_t length );
 
2918
ParserError::ErrorType validate__gles_texcombiner_operand_rgb_enum__stream( const ParserChar* value, size_t length );
 
2919
ParserError::ErrorType validate__gles_texcombiner_operand_rgb_enum__streamEnd( const ParserChar* value, size_t length );
 
2920
 
 
2921
ParserError::ErrorType validate__gles_texcombiner_operator_alpha_enum( ParserString value );
 
2922
ParserError::ErrorType validate__gles_texcombiner_operator_alpha_enum( const ParserChar* value, size_t length );
 
2923
ParserError::ErrorType validate__gles_texcombiner_operator_alpha_enum__stream( const ParserChar* value, size_t length );
 
2924
ParserError::ErrorType validate__gles_texcombiner_operator_alpha_enum__streamEnd( const ParserChar* value, size_t length );
 
2925
 
 
2926
struct alpha____gles_texcombiner_command_alpha_type__ValidationData
 
2927
{
 
2928
    size_t argument;
 
2929
};
 
2930
 
 
2931
ParserError::ErrorType validate__gles_texcombiner_operand_alpha_enum( ParserString value );
 
2932
ParserError::ErrorType validate__gles_texcombiner_operand_alpha_enum( const ParserChar* value, size_t length );
 
2933
ParserError::ErrorType validate__gles_texcombiner_operand_alpha_enum__stream( const ParserChar* value, size_t length );
 
2934
ParserError::ErrorType validate__gles_texcombiner_operand_alpha_enum__streamEnd( const ParserChar* value, size_t length );
 
2935
 
 
2936
ParserError::ErrorType validate__gles_texenv_mode_enum( ParserString value );
 
2937
ParserError::ErrorType validate__gles_texenv_mode_enum( const ParserChar* value, size_t length );
 
2938
ParserError::ErrorType validate__gles_texenv_mode_enum__stream( const ParserChar* value, size_t length );
 
2939
ParserError::ErrorType validate__gles_texenv_mode_enum__streamEnd( const ParserChar* value, size_t length );
 
2940
 
 
2941
struct texenv__ValidationData
 
2942
{
 
2943
    size_t constant;
 
2944
};
 
2945
 
 
2946
struct profile_GLES__technique__pass__evaluate__ValidationData
 
2947
{
 
2948
    size_t color_target;
 
2949
    size_t depth_target;
 
2950
    size_t stencil_target;
 
2951
    size_t color_clear;
 
2952
    size_t depth_clear;
 
2953
    size_t stencil_clear;
 
2954
    size_t draw;
 
2955
};
 
2956
 
 
2957
struct library_force_fields__ValidationData
 
2958
{
 
2959
    size_t asset;
 
2960
    size_t force_field;
 
2961
    size_t extra;
 
2962
};
 
2963
 
 
2964
struct force_field__ValidationData
 
2965
{
 
2966
    size_t asset;
 
2967
    size_t technique;
 
2968
    size_t extra;
 
2969
};
 
2970
 
 
2971
struct library_images__ValidationData
 
2972
{
 
2973
    size_t asset;
 
2974
    size_t image;
 
2975
    size_t extra;
 
2976
};
 
2977
 
 
2978
struct image____image_type__ValidationData
 
2979
{
 
2980
    size_t validation_current_state;
 
2981
    size_t asset;
 
2982
    size_t renderable;
 
2983
    size_t init_from;
 
2984
    size_t create_2d;
 
2985
    size_t create_3d;
 
2986
    size_t create_cube;
 
2987
    size_t extra;
 
2988
};
 
2989
 
 
2990
struct image_type____init_from__ValidationData
 
2991
{
 
2992
    size_t ref;
 
2993
    size_t hex;
 
2994
};
 
2995
 
 
2996
struct create_2d__ValidationData
 
2997
{
 
2998
    size_t validation_current_state;
 
2999
    size_t size_exact;
 
3000
    size_t size_ratio;
 
3001
    size_t mips;
 
3002
    size_t unnormalized;
 
3003
    size_t array;
 
3004
    size_t format;
 
3005
    size_t init_from;
 
3006
};
 
3007
 
 
3008
struct unnormalized__ValidationData
 
3009
{
 
3010
    size_t _wildcard;
 
3011
    size_t validationWholeSize;
 
3012
};
 
3013
 
 
3014
struct create_2d__format__ValidationData
 
3015
{
 
3016
    size_t hint;
 
3017
    size_t exact;
 
3018
};
 
3019
 
 
3020
ParserError::ErrorType validate__image_format_hint_channels_enum( ParserString value );
 
3021
ParserError::ErrorType validate__image_format_hint_channels_enum( const ParserChar* value, size_t length );
 
3022
ParserError::ErrorType validate__image_format_hint_channels_enum__stream( const ParserChar* value, size_t length );
 
3023
ParserError::ErrorType validate__image_format_hint_channels_enum__streamEnd( const ParserChar* value, size_t length );
 
3024
 
 
3025
ParserError::ErrorType validate__image_format_hint_range_enum( ParserString value );
 
3026
ParserError::ErrorType validate__image_format_hint_range_enum( const ParserChar* value, size_t length );
 
3027
ParserError::ErrorType validate__image_format_hint_range_enum__stream( const ParserChar* value, size_t length );
 
3028
ParserError::ErrorType validate__image_format_hint_range_enum__streamEnd( const ParserChar* value, size_t length );
 
3029
 
 
3030
ParserError::ErrorType validate__image_format_hint_precision_enum( ParserString value );
 
3031
ParserError::ErrorType validate__image_format_hint_precision_enum( const ParserChar* value, size_t length );
 
3032
ParserError::ErrorType validate__image_format_hint_precision_enum__stream( const ParserChar* value, size_t length );
 
3033
ParserError::ErrorType validate__image_format_hint_precision_enum__streamEnd( const ParserChar* value, size_t length );
 
3034
 
 
3035
struct create_2d__init_from__ValidationData
 
3036
{
 
3037
    size_t ref;
 
3038
    size_t hex;
 
3039
};
 
3040
 
 
3041
struct create_3d__ValidationData
 
3042
{
 
3043
    size_t size;
 
3044
    size_t mips;
 
3045
    size_t array;
 
3046
    size_t format;
 
3047
    size_t init_from;
 
3048
};
 
3049
 
 
3050
struct create_3d__format__ValidationData
 
3051
{
 
3052
    size_t hint;
 
3053
    size_t exact;
 
3054
};
 
3055
 
 
3056
struct create_3d__init_from__ValidationData
 
3057
{
 
3058
    size_t ref;
 
3059
    size_t hex;
 
3060
};
 
3061
 
 
3062
struct create_cube__ValidationData
 
3063
{
 
3064
    size_t size;
 
3065
    size_t mips;
 
3066
    size_t array;
 
3067
    size_t format;
 
3068
    size_t init_from;
 
3069
};
 
3070
 
 
3071
struct create_cube__format__ValidationData
 
3072
{
 
3073
    size_t hint;
 
3074
    size_t exact;
 
3075
};
 
3076
 
 
3077
struct create_cube__init_from__ValidationData
 
3078
{
 
3079
    size_t ref;
 
3080
    size_t hex;
 
3081
};
 
3082
 
 
3083
struct library_lights__ValidationData
 
3084
{
 
3085
    size_t asset;
 
3086
    size_t light;
 
3087
    size_t extra;
 
3088
};
 
3089
 
 
3090
struct light__ValidationData
 
3091
{
 
3092
    size_t asset;
 
3093
    size_t technique_common;
 
3094
    size_t technique;
 
3095
    size_t extra;
 
3096
};
 
3097
 
 
3098
struct light_type____technique_common__ValidationData
 
3099
{
 
3100
    size_t ambient;
 
3101
    size_t directional;
 
3102
    size_t point;
 
3103
    size_t spot;
 
3104
};
 
3105
 
 
3106
struct light__technique_common__ambient__ValidationData
 
3107
{
 
3108
    size_t color;
 
3109
};
 
3110
 
 
3111
struct color____targetable_float3_type__ValidationData
 
3112
{
 
3113
    size_t validationWholeSize;
 
3114
};
 
3115
 
 
3116
struct directional__ValidationData
 
3117
{
 
3118
    size_t color;
 
3119
};
 
3120
 
 
3121
struct point__ValidationData
 
3122
{
 
3123
    size_t color;
 
3124
    size_t constant_attenuation;
 
3125
    size_t linear_attenuation;
 
3126
    size_t quadratic_attenuation;
 
3127
};
 
3128
 
 
3129
struct spot__ValidationData
 
3130
{
 
3131
    size_t color;
 
3132
    size_t constant_attenuation;
 
3133
    size_t linear_attenuation;
 
3134
    size_t quadratic_attenuation;
 
3135
    size_t falloff_angle;
 
3136
    size_t falloff_exponent;
 
3137
};
 
3138
 
 
3139
struct library_materials__ValidationData
 
3140
{
 
3141
    size_t asset;
 
3142
    size_t material;
 
3143
    size_t extra;
 
3144
};
 
3145
 
 
3146
struct material__ValidationData
 
3147
{
 
3148
    size_t asset;
 
3149
    size_t instance_effect;
 
3150
    size_t extra;
 
3151
};
 
3152
 
 
3153
struct instance_effect__ValidationData
 
3154
{
 
3155
    size_t technique_hint;
 
3156
    size_t setparam;
 
3157
    size_t extra;
 
3158
};
 
3159
 
 
3160
struct instance_effect_type____setparam__ValidationData
 
3161
{
 
3162
    size_t validation_current_state;
 
3163
    size_t _bool;
 
3164
    size_t bool2;
 
3165
    size_t bool3;
 
3166
    size_t bool4;
 
3167
    size_t _int;
 
3168
    size_t int2;
 
3169
    size_t int3;
 
3170
    size_t int4;
 
3171
    size_t _float;
 
3172
    size_t float2;
 
3173
    size_t float3;
 
3174
    size_t float4;
 
3175
    size_t float2x1;
 
3176
    size_t float2x2;
 
3177
    size_t float2x3;
 
3178
    size_t float2x4;
 
3179
    size_t float3x1;
 
3180
    size_t float3x2;
 
3181
    size_t float3x3;
 
3182
    size_t float3x4;
 
3183
    size_t float4x1;
 
3184
    size_t float4x2;
 
3185
    size_t float4x3;
 
3186
    size_t float4x4;
 
3187
    size_t _enum;
 
3188
    size_t sampler_image;
 
3189
    size_t sampler_states;
 
3190
};
 
3191
 
 
3192
struct sampler_states__ValidationData
 
3193
{
 
3194
    size_t wrap_s;
 
3195
    size_t wrap_t;
 
3196
    size_t wrap_p;
 
3197
    size_t minfilter;
 
3198
    size_t magfilter;
 
3199
    size_t mipfilter;
 
3200
    size_t border_color;
 
3201
    size_t mip_max_level;
 
3202
    size_t mip_min_level;
 
3203
    size_t mip_bias;
 
3204
    size_t max_anisotropy;
 
3205
    size_t extra;
 
3206
};
 
3207
 
 
3208
struct library_nodes__ValidationData
 
3209
{
 
3210
    size_t asset;
 
3211
    size_t node;
 
3212
    size_t extra;
 
3213
};
 
3214
 
 
3215
ParserError::ErrorType validate__node_enum( ParserString value );
 
3216
ParserError::ErrorType validate__node_enum( const ParserChar* value, size_t length );
 
3217
ParserError::ErrorType validate__node_enum__stream( const ParserChar* value, size_t length );
 
3218
ParserError::ErrorType validate__node_enum__streamEnd( const ParserChar* value, size_t length );
 
3219
 
 
3220
struct node__ValidationData
 
3221
{
 
3222
    size_t validation_current_state;
 
3223
    size_t asset;
 
3224
    size_t lookat;
 
3225
    size_t matrix;
 
3226
    size_t rotate;
 
3227
    size_t scale;
 
3228
    size_t skew;
 
3229
    size_t translate;
 
3230
    size_t instance_camera;
 
3231
    size_t instance_controller;
 
3232
    size_t instance_geometry;
 
3233
    size_t instance_light;
 
3234
    size_t instance_node;
 
3235
    size_t node;
 
3236
    size_t extra;
 
3237
};
 
3238
 
 
3239
struct lookat__ValidationData
 
3240
{
 
3241
    size_t validationWholeSize;
 
3242
};
 
3243
 
 
3244
struct matrix____matrix_type__ValidationData
 
3245
{
 
3246
    size_t validationWholeSize;
 
3247
};
 
3248
 
 
3249
struct rotate__ValidationData
 
3250
{
 
3251
    size_t validationWholeSize;
 
3252
};
 
3253
 
 
3254
ParserError::ErrorType validate__rotate( const float* value, size_t length );
 
3255
ParserError::ErrorType validate__rotate__stream( const float* value, size_t length );
 
3256
ParserError::ErrorType validate__rotate__streamEnd( const float* value, size_t length );
 
3257
 
 
3258
struct scale__ValidationData
 
3259
{
 
3260
    size_t validationWholeSize;
 
3261
};
 
3262
 
 
3263
ParserError::ErrorType validate__scale( const float* value, size_t length );
 
3264
ParserError::ErrorType validate__scale__stream( const float* value, size_t length );
 
3265
ParserError::ErrorType validate__scale__streamEnd( const float* value, size_t length );
 
3266
 
 
3267
struct skew__ValidationData
 
3268
{
 
3269
    size_t validationWholeSize;
 
3270
};
 
3271
 
 
3272
ParserError::ErrorType validate__float7_type( const float* value, size_t length );
 
3273
ParserError::ErrorType validate__float7_type__stream( const float* value, size_t length );
 
3274
ParserError::ErrorType validate__float7_type__streamEnd( const float* value, size_t length );
 
3275
 
 
3276
struct translate__ValidationData
 
3277
{
 
3278
    size_t validationWholeSize;
 
3279
};
 
3280
 
 
3281
ParserError::ErrorType validate__translate( const float* value, size_t length );
 
3282
ParserError::ErrorType validate__translate__stream( const float* value, size_t length );
 
3283
ParserError::ErrorType validate__translate__streamEnd( const float* value, size_t length );
 
3284
 
 
3285
struct instance_camera__ValidationData
 
3286
{
 
3287
    size_t extra;
 
3288
};
 
3289
 
 
3290
struct instance_controller__ValidationData
 
3291
{
 
3292
    size_t skeleton;
 
3293
    size_t bind_material;
 
3294
    size_t extra;
 
3295
};
 
3296
 
 
3297
struct bind_material__ValidationData
 
3298
{
 
3299
    size_t param;
 
3300
    size_t technique_common;
 
3301
    size_t technique;
 
3302
    size_t extra;
 
3303
};
 
3304
 
 
3305
struct bind_material_type____technique_common__ValidationData
 
3306
{
 
3307
    size_t instance_material;
 
3308
};
 
3309
 
 
3310
struct instance_material____instance_material_type__ValidationData
 
3311
{
 
3312
    size_t bind;
 
3313
    size_t bind_vertex_input;
 
3314
    size_t extra;
 
3315
};
 
3316
 
 
3317
struct instance_geometry__ValidationData
 
3318
{
 
3319
    size_t bind_material;
 
3320
    size_t extra;
 
3321
};
 
3322
 
 
3323
struct instance_light__ValidationData
 
3324
{
 
3325
    size_t extra;
 
3326
};
 
3327
 
 
3328
struct instance_node__ValidationData
 
3329
{
 
3330
    size_t extra;
 
3331
};
 
3332
 
 
3333
struct library_physics_materials__ValidationData
 
3334
{
 
3335
    size_t asset;
 
3336
    size_t physics_material;
 
3337
    size_t extra;
 
3338
};
 
3339
 
 
3340
struct physics_material__ValidationData
 
3341
{
 
3342
    size_t asset;
 
3343
    size_t technique_common;
 
3344
    size_t technique;
 
3345
    size_t extra;
 
3346
};
 
3347
 
 
3348
struct physics_material_type____technique_common__ValidationData
 
3349
{
 
3350
    size_t dynamic_friction;
 
3351
    size_t restitution;
 
3352
    size_t static_friction;
 
3353
};
 
3354
 
 
3355
struct library_physics_models__ValidationData
 
3356
{
 
3357
    size_t asset;
 
3358
    size_t physics_model;
 
3359
    size_t extra;
 
3360
};
 
3361
 
 
3362
struct physics_model__ValidationData
 
3363
{
 
3364
    size_t asset;
 
3365
    size_t rigid_body;
 
3366
    size_t rigid_constraint;
 
3367
    size_t instance_physics_model;
 
3368
    size_t extra;
 
3369
};
 
3370
 
 
3371
struct rigid_body__ValidationData
 
3372
{
 
3373
    size_t technique_common;
 
3374
    size_t technique;
 
3375
    size_t extra;
 
3376
};
 
3377
 
 
3378
struct rigid_body_type____technique_common__ValidationData
 
3379
{
 
3380
    size_t validation_current_state;
 
3381
    size_t dynamic;
 
3382
    size_t mass;
 
3383
    size_t mass_frame;
 
3384
    size_t inertia;
 
3385
    size_t instance_physics_material;
 
3386
    size_t physics_material;
 
3387
    size_t shape;
 
3388
};
 
3389
 
 
3390
struct rigid_body__technique_common__mass_frame__ValidationData
 
3391
{
 
3392
    size_t translate;
 
3393
    size_t rotate;
 
3394
};
 
3395
 
 
3396
struct instance_physics_material__ValidationData
 
3397
{
 
3398
    size_t extra;
 
3399
};
 
3400
 
 
3401
struct rigid_body__technique_common__shape__ValidationData
 
3402
{
 
3403
    size_t validation_current_state;
 
3404
    size_t hollow;
 
3405
    size_t mass;
 
3406
    size_t density;
 
3407
    size_t instance_physics_material;
 
3408
    size_t physics_material;
 
3409
    size_t instance_geometry;
 
3410
    size_t plane;
 
3411
    size_t box;
 
3412
    size_t sphere;
 
3413
    size_t cylinder;
 
3414
    size_t capsule;
 
3415
    size_t translate;
 
3416
    size_t rotate;
 
3417
    size_t extra;
 
3418
};
 
3419
 
 
3420
struct box__ValidationData
 
3421
{
 
3422
    size_t half_extents;
 
3423
    size_t extra;
 
3424
};
 
3425
 
 
3426
struct cylinder____cylinder_type__ValidationData
 
3427
{
 
3428
    size_t height;
 
3429
    size_t radius;
 
3430
    size_t extra;
 
3431
};
 
3432
 
 
3433
struct capsule__ValidationData
 
3434
{
 
3435
    size_t height;
 
3436
    size_t radius;
 
3437
    size_t extra;
 
3438
};
 
3439
 
 
3440
struct rigid_constraint__ValidationData
 
3441
{
 
3442
    size_t ref_attachment;
 
3443
    size_t attachment;
 
3444
    size_t technique_common;
 
3445
    size_t technique;
 
3446
    size_t extra;
 
3447
};
 
3448
 
 
3449
struct ref_attachment__ValidationData
 
3450
{
 
3451
    size_t validation_current_state;
 
3452
    size_t translate;
 
3453
    size_t rotate;
 
3454
    size_t extra;
 
3455
};
 
3456
 
 
3457
struct attachment__ValidationData
 
3458
{
 
3459
    size_t validation_current_state;
 
3460
    size_t translate;
 
3461
    size_t rotate;
 
3462
    size_t extra;
 
3463
};
 
3464
 
 
3465
struct rigid_constraint_type____technique_common__ValidationData
 
3466
{
 
3467
    size_t enabled;
 
3468
    size_t interpenetrate;
 
3469
    size_t limits;
 
3470
    size_t spring;
 
3471
};
 
3472
 
 
3473
struct rigid_constraint__technique_common__limits__ValidationData
 
3474
{
 
3475
    size_t swing_cone_and_twist;
 
3476
    size_t linear;
 
3477
};
 
3478
 
 
3479
struct swing_cone_and_twist__ValidationData
 
3480
{
 
3481
    size_t min;
 
3482
    size_t max;
 
3483
};
 
3484
 
 
3485
struct rigid_constraint__technique_common__limits__linear__ValidationData
 
3486
{
 
3487
    size_t min;
 
3488
    size_t max;
 
3489
};
 
3490
 
 
3491
struct spring__ValidationData
 
3492
{
 
3493
    size_t angular;
 
3494
    size_t linear;
 
3495
};
 
3496
 
 
3497
struct angular__ValidationData
 
3498
{
 
3499
    size_t stiffness;
 
3500
    size_t damping;
 
3501
    size_t target_value;
 
3502
};
 
3503
 
 
3504
struct spring__linear__ValidationData
 
3505
{
 
3506
    size_t stiffness;
 
3507
    size_t damping;
 
3508
    size_t target_value;
 
3509
};
 
3510
 
 
3511
struct instance_physics_model__ValidationData
 
3512
{
 
3513
    size_t instance_force_field;
 
3514
    size_t instance_rigid_body;
 
3515
    size_t instance_rigid_constraint;
 
3516
    size_t extra;
 
3517
};
 
3518
 
 
3519
struct instance_force_field__ValidationData
 
3520
{
 
3521
    size_t extra;
 
3522
};
 
3523
 
 
3524
struct instance_rigid_body__ValidationData
 
3525
{
 
3526
    size_t technique_common;
 
3527
    size_t technique;
 
3528
    size_t extra;
 
3529
};
 
3530
 
 
3531
struct instance_rigid_body_type____technique_common__ValidationData
 
3532
{
 
3533
    size_t validation_current_state;
 
3534
    size_t angular_velocity;
 
3535
    size_t velocity;
 
3536
    size_t dynamic;
 
3537
    size_t mass;
 
3538
    size_t mass_frame;
 
3539
    size_t inertia;
 
3540
    size_t instance_physics_material;
 
3541
    size_t physics_material;
 
3542
    size_t shape;
 
3543
};
 
3544
 
 
3545
struct instance_rigid_body__technique_common__mass_frame__ValidationData
 
3546
{
 
3547
    size_t translate;
 
3548
    size_t rotate;
 
3549
};
 
3550
 
 
3551
struct instance_rigid_body__technique_common__shape__ValidationData
 
3552
{
 
3553
    size_t validation_current_state;
 
3554
    size_t hollow;
 
3555
    size_t mass;
 
3556
    size_t density;
 
3557
    size_t instance_physics_material;
 
3558
    size_t physics_material;
 
3559
    size_t instance_geometry;
 
3560
    size_t plane;
 
3561
    size_t box;
 
3562
    size_t sphere;
 
3563
    size_t cylinder;
 
3564
    size_t capsule;
 
3565
    size_t translate;
 
3566
    size_t rotate;
 
3567
    size_t extra;
 
3568
};
 
3569
 
 
3570
struct instance_rigid_constraint__ValidationData
 
3571
{
 
3572
    size_t extra;
 
3573
};
 
3574
 
 
3575
struct library_physics_scenes__ValidationData
 
3576
{
 
3577
    size_t asset;
 
3578
    size_t physics_scene;
 
3579
    size_t extra;
 
3580
};
 
3581
 
 
3582
struct physics_scene__ValidationData
 
3583
{
 
3584
    size_t asset;
 
3585
    size_t instance_force_field;
 
3586
    size_t instance_physics_model;
 
3587
    size_t technique_common;
 
3588
    size_t technique;
 
3589
    size_t extra;
 
3590
};
 
3591
 
 
3592
struct physics_scene_type____technique_common__ValidationData
 
3593
{
 
3594
    size_t gravity;
 
3595
    size_t time_step;
 
3596
};
 
3597
 
 
3598
struct library_visual_scenes__ValidationData
 
3599
{
 
3600
    size_t asset;
 
3601
    size_t visual_scene;
 
3602
    size_t extra;
 
3603
};
 
3604
 
 
3605
struct visual_scene__ValidationData
 
3606
{
 
3607
    size_t asset;
 
3608
    size_t node;
 
3609
    size_t evaluate_scene;
 
3610
    size_t extra;
 
3611
};
 
3612
 
 
3613
struct evaluate_scene__ValidationData
 
3614
{
 
3615
    size_t asset;
 
3616
    size_t render;
 
3617
    size_t extra;
 
3618
};
 
3619
 
 
3620
struct render__ValidationData
 
3621
{
 
3622
    size_t layer;
 
3623
    size_t instance_material;
 
3624
    size_t extra;
 
3625
};
 
3626
 
 
3627
struct render__instance_material__ValidationData
 
3628
{
 
3629
    size_t technique_override;
 
3630
    size_t bind;
 
3631
    size_t extra;
 
3632
};
 
3633
 
 
3634
struct library_joints__ValidationData
 
3635
{
 
3636
    size_t asset;
 
3637
    size_t joint;
 
3638
    size_t extra;
 
3639
};
 
3640
 
 
3641
struct joint__ValidationData
 
3642
{
 
3643
    size_t validation_current_state;
 
3644
    size_t prismatic;
 
3645
    size_t revolute;
 
3646
    size_t extra;
 
3647
};
 
3648
 
 
3649
struct prismatic__ValidationData
 
3650
{
 
3651
    size_t axis;
 
3652
    size_t limits;
 
3653
};
 
3654
 
 
3655
struct axis____axis_type__ValidationData
 
3656
{
 
3657
    size_t validationWholeSize;
 
3658
};
 
3659
 
 
3660
struct limits____joint_limits_type__ValidationData
 
3661
{
 
3662
    size_t min;
 
3663
    size_t max;
 
3664
};
 
3665
 
 
3666
struct library_kinematics_models__ValidationData
 
3667
{
 
3668
    size_t asset;
 
3669
    size_t kinematics_model;
 
3670
    size_t extra;
 
3671
};
 
3672
 
 
3673
struct kinematics_model__ValidationData
 
3674
{
 
3675
    size_t asset;
 
3676
    size_t technique_common;
 
3677
    size_t technique;
 
3678
    size_t extra;
 
3679
};
 
3680
 
 
3681
struct technique_common____kinematics_model_technique_type__ValidationData
 
3682
{
 
3683
    size_t validation_current_state;
 
3684
    size_t newparam;
 
3685
    size_t instance_joint;
 
3686
    size_t joint;
 
3687
    size_t link;
 
3688
    size_t formula;
 
3689
    size_t instance_formula;
 
3690
};
 
3691
 
 
3692
struct newparam____kinematics_newparam_type__ValidationData
 
3693
{
 
3694
    size_t _float;
 
3695
    size_t _int;
 
3696
    size_t SIDREF;
 
3697
    size_t _bool;
 
3698
};
 
3699
 
 
3700
struct instance_joint__ValidationData
 
3701
{
 
3702
    size_t extra;
 
3703
};
 
3704
 
 
3705
struct link__ValidationData
 
3706
{
 
3707
    size_t validation_current_state;
 
3708
    size_t rotate;
 
3709
    size_t translate;
 
3710
    size_t attachment_full;
 
3711
    size_t attachment_start;
 
3712
    size_t attachment_end;
 
3713
};
 
3714
 
 
3715
struct attachment_full__ValidationData
 
3716
{
 
3717
    size_t validation_current_state;
 
3718
    size_t rotate;
 
3719
    size_t translate;
 
3720
    size_t link;
 
3721
};
 
3722
 
 
3723
struct attachment_start__ValidationData
 
3724
{
 
3725
    size_t rotate;
 
3726
    size_t translate;
 
3727
};
 
3728
 
 
3729
struct attachment_end__ValidationData
 
3730
{
 
3731
    size_t rotate;
 
3732
    size_t translate;
 
3733
};
 
3734
 
 
3735
struct formula__ValidationData
 
3736
{
 
3737
    size_t newparam;
 
3738
    size_t target;
 
3739
    size_t technique_common;
 
3740
    size_t technique;
 
3741
};
 
3742
 
 
3743
struct newparam____formula_newparam_type__ValidationData
 
3744
{
 
3745
    size_t _float;
 
3746
    size_t _int;
 
3747
    size_t SIDREF;
 
3748
    size_t _bool;
 
3749
};
 
3750
 
 
3751
struct target__ValidationData
 
3752
{
 
3753
    size_t _float;
 
3754
    size_t param;
 
3755
};
 
3756
 
 
3757
struct technique_common____formula_technique_type__ValidationData
 
3758
{
 
3759
    size_t math;
 
3760
};
 
3761
 
 
3762
ParserError::ErrorType validate__math( ParserString value );
 
3763
ParserError::ErrorType validate__math( const ParserChar* value, size_t length );
 
3764
ParserError::ErrorType validate__math__stream( const ParserChar* value, size_t length );
 
3765
ParserError::ErrorType validate__math__streamEnd( const ParserChar* value, size_t length );
 
3766
 
 
3767
ParserError::ErrorType validate__NMTOKENS( const ParserString*value, size_t length );
 
3768
ParserError::ErrorType validate__NMTOKENS__stream( const ParserString*value, size_t length );
 
3769
ParserError::ErrorType validate__NMTOKENS__streamEnd( const ParserString*value, size_t length );
 
3770
 
 
3771
struct math__ValidationData
 
3772
{
 
3773
    size_t validation_current_state;
 
3774
    size_t cn;
 
3775
    size_t ci;
 
3776
    size_t csymbol;
 
3777
    size_t abs;
 
3778
    size_t conjugate;
 
3779
    size_t factorial;
 
3780
    size_t arg;
 
3781
    size_t real;
 
3782
    size_t imaginary;
 
3783
    size_t floor;
 
3784
    size_t ceiling;
 
3785
    size_t quotient;
 
3786
    size_t divide;
 
3787
    size_t rem;
 
3788
    size_t minus;
 
3789
    size_t plus;
 
3790
    size_t times;
 
3791
    size_t power;
 
3792
    size_t root;
 
3793
    size_t max;
 
3794
    size_t min;
 
3795
    size_t gcd;
 
3796
    size_t lcm;
 
3797
    size_t sum;
 
3798
    size_t product;
 
3799
    size_t compose;
 
3800
    size_t domain;
 
3801
    size_t codomain;
 
3802
    size_t image;
 
3803
    size_t domainofapplication;
 
3804
    size_t ident;
 
3805
    size_t _and;
 
3806
    size_t _or;
 
3807
    size_t _xor;
 
3808
    size_t _not;
 
3809
    size_t exists;
 
3810
    size_t forall;
 
3811
    size_t implies;
 
3812
    size_t naturalnumbers;
 
3813
    size_t primes;
 
3814
    size_t integers;
 
3815
    size_t rationals;
 
3816
    size_t reals;
 
3817
    size_t complexes;
 
3818
    size_t emptyset;
 
3819
    size_t exponentiale;
 
3820
    size_t imaginaryi;
 
3821
    size_t pi;
 
3822
    size_t eulergamma;
 
3823
    size_t _true;
 
3824
    size_t _false;
 
3825
    size_t infinity;
 
3826
    size_t notanumber;
 
3827
    size_t set;
 
3828
    size_t list;
 
3829
    size_t _union;
 
3830
    size_t intersect;
 
3831
    size_t _in;
 
3832
    size_t notin;
 
3833
    size_t subset;
 
3834
    size_t prsubset;
 
3835
    size_t notsubset;
 
3836
    size_t notprsubset;
 
3837
    size_t setdiff;
 
3838
    size_t card;
 
3839
    size_t cartesianproduct;
 
3840
    size_t eq;
 
3841
    size_t neq;
 
3842
    size_t leq;
 
3843
    size_t lt;
 
3844
    size_t geq;
 
3845
    size_t gt;
 
3846
    size_t equivalent;
 
3847
    size_t approx;
 
3848
    size_t factorof;
 
3849
    size_t exp;
 
3850
    size_t ln;
 
3851
    size_t log;
 
3852
    size_t logbase;
 
3853
    size_t sin;
 
3854
    size_t cos;
 
3855
    size_t tan;
 
3856
    size_t sec;
 
3857
    size_t csc;
 
3858
    size_t cot;
 
3859
    size_t arcsin;
 
3860
    size_t arccos;
 
3861
    size_t arctan;
 
3862
    size_t arcsec;
 
3863
    size_t arccsc;
 
3864
    size_t arccot;
 
3865
    size_t sinh;
 
3866
    size_t cosh;
 
3867
    size_t tanh;
 
3868
    size_t sech;
 
3869
    size_t csch;
 
3870
    size_t coth;
 
3871
    size_t arccosh;
 
3872
    size_t arccoth;
 
3873
    size_t arccsch;
 
3874
    size_t arcsech;
 
3875
    size_t arcsinh;
 
3876
    size_t arctanh;
 
3877
    size_t _int;
 
3878
    size_t diff;
 
3879
    size_t partialdiff;
 
3880
    size_t limit;
 
3881
    size_t lowlimit;
 
3882
    size_t uplimit;
 
3883
    size_t tendsto;
 
3884
    size_t vector;
 
3885
    size_t matrix;
 
3886
    size_t determinant;
 
3887
    size_t transpose;
 
3888
    size_t selector;
 
3889
    size_t vectorproduct;
 
3890
    size_t scalarproduct;
 
3891
    size_t outerproduct;
 
3892
    size_t divergence;
 
3893
    size_t grad;
 
3894
    size_t curl;
 
3895
    size_t laplacian;
 
3896
    size_t mean;
 
3897
    size_t sdev;
 
3898
    size_t variance;
 
3899
    size_t median;
 
3900
    size_t mode;
 
3901
    size_t moment;
 
3902
    size_t momentabout;
 
3903
    size_t apply;
 
3904
    size_t interval;
 
3905
    size_t inverse;
 
3906
    size_t condition;
 
3907
    size_t declare;
 
3908
    size_t lambda;
 
3909
    size_t piecewise;
 
3910
    size_t bvar;
 
3911
    size_t degree;
 
3912
    size_t semantics;
 
3913
};
 
3914
 
 
3915
ParserError::ErrorType validate__cn( const uint64 value );
 
3916
 
 
3917
struct cn__ValidationData
 
3918
{
 
3919
    size_t validation_current_state;
 
3920
    size_t cn;
 
3921
    size_t ci;
 
3922
    size_t csymbol;
 
3923
    size_t abs;
 
3924
    size_t conjugate;
 
3925
    size_t factorial;
 
3926
    size_t arg;
 
3927
    size_t real;
 
3928
    size_t imaginary;
 
3929
    size_t floor;
 
3930
    size_t ceiling;
 
3931
    size_t quotient;
 
3932
    size_t divide;
 
3933
    size_t rem;
 
3934
    size_t minus;
 
3935
    size_t plus;
 
3936
    size_t times;
 
3937
    size_t power;
 
3938
    size_t root;
 
3939
    size_t max;
 
3940
    size_t min;
 
3941
    size_t gcd;
 
3942
    size_t lcm;
 
3943
    size_t sum;
 
3944
    size_t product;
 
3945
    size_t compose;
 
3946
    size_t domain;
 
3947
    size_t codomain;
 
3948
    size_t image;
 
3949
    size_t domainofapplication;
 
3950
    size_t ident;
 
3951
    size_t _and;
 
3952
    size_t _or;
 
3953
    size_t _xor;
 
3954
    size_t _not;
 
3955
    size_t exists;
 
3956
    size_t forall;
 
3957
    size_t implies;
 
3958
    size_t naturalnumbers;
 
3959
    size_t primes;
 
3960
    size_t integers;
 
3961
    size_t rationals;
 
3962
    size_t reals;
 
3963
    size_t complexes;
 
3964
    size_t emptyset;
 
3965
    size_t exponentiale;
 
3966
    size_t imaginaryi;
 
3967
    size_t pi;
 
3968
    size_t eulergamma;
 
3969
    size_t _true;
 
3970
    size_t _false;
 
3971
    size_t infinity;
 
3972
    size_t notanumber;
 
3973
    size_t set;
 
3974
    size_t list;
 
3975
    size_t _union;
 
3976
    size_t intersect;
 
3977
    size_t _in;
 
3978
    size_t notin;
 
3979
    size_t subset;
 
3980
    size_t prsubset;
 
3981
    size_t notsubset;
 
3982
    size_t notprsubset;
 
3983
    size_t setdiff;
 
3984
    size_t card;
 
3985
    size_t cartesianproduct;
 
3986
    size_t eq;
 
3987
    size_t neq;
 
3988
    size_t leq;
 
3989
    size_t lt;
 
3990
    size_t geq;
 
3991
    size_t gt;
 
3992
    size_t equivalent;
 
3993
    size_t approx;
 
3994
    size_t factorof;
 
3995
    size_t exp;
 
3996
    size_t ln;
 
3997
    size_t log;
 
3998
    size_t logbase;
 
3999
    size_t sin;
 
4000
    size_t cos;
 
4001
    size_t tan;
 
4002
    size_t sec;
 
4003
    size_t csc;
 
4004
    size_t cot;
 
4005
    size_t arcsin;
 
4006
    size_t arccos;
 
4007
    size_t arctan;
 
4008
    size_t arcsec;
 
4009
    size_t arccsc;
 
4010
    size_t arccot;
 
4011
    size_t sinh;
 
4012
    size_t cosh;
 
4013
    size_t tanh;
 
4014
    size_t sech;
 
4015
    size_t csch;
 
4016
    size_t coth;
 
4017
    size_t arccosh;
 
4018
    size_t arccoth;
 
4019
    size_t arccsch;
 
4020
    size_t arcsech;
 
4021
    size_t arcsinh;
 
4022
    size_t arctanh;
 
4023
    size_t _int;
 
4024
    size_t diff;
 
4025
    size_t partialdiff;
 
4026
    size_t limit;
 
4027
    size_t lowlimit;
 
4028
    size_t uplimit;
 
4029
    size_t tendsto;
 
4030
    size_t vector;
 
4031
    size_t matrix;
 
4032
    size_t determinant;
 
4033
    size_t transpose;
 
4034
    size_t selector;
 
4035
    size_t vectorproduct;
 
4036
    size_t scalarproduct;
 
4037
    size_t outerproduct;
 
4038
    size_t divergence;
 
4039
    size_t grad;
 
4040
    size_t curl;
 
4041
    size_t laplacian;
 
4042
    size_t mean;
 
4043
    size_t sdev;
 
4044
    size_t variance;
 
4045
    size_t median;
 
4046
    size_t mode;
 
4047
    size_t moment;
 
4048
    size_t momentabout;
 
4049
    size_t apply;
 
4050
    size_t interval;
 
4051
    size_t inverse;
 
4052
    size_t condition;
 
4053
    size_t declare;
 
4054
    size_t lambda;
 
4055
    size_t piecewise;
 
4056
    size_t bvar;
 
4057
    size_t degree;
 
4058
    size_t semantics;
 
4059
    size_t sep;
 
4060
    size_t validationWholeSize;
 
4061
};
 
4062
 
 
4063
struct ci__ValidationData
 
4064
{
 
4065
    size_t validation_current_state;
 
4066
    size_t cn;
 
4067
    size_t ci;
 
4068
    size_t csymbol;
 
4069
    size_t abs;
 
4070
    size_t conjugate;
 
4071
    size_t factorial;
 
4072
    size_t arg;
 
4073
    size_t real;
 
4074
    size_t imaginary;
 
4075
    size_t floor;
 
4076
    size_t ceiling;
 
4077
    size_t quotient;
 
4078
    size_t divide;
 
4079
    size_t rem;
 
4080
    size_t minus;
 
4081
    size_t plus;
 
4082
    size_t times;
 
4083
    size_t power;
 
4084
    size_t root;
 
4085
    size_t max;
 
4086
    size_t min;
 
4087
    size_t gcd;
 
4088
    size_t lcm;
 
4089
    size_t sum;
 
4090
    size_t product;
 
4091
    size_t compose;
 
4092
    size_t domain;
 
4093
    size_t codomain;
 
4094
    size_t image;
 
4095
    size_t domainofapplication;
 
4096
    size_t ident;
 
4097
    size_t _and;
 
4098
    size_t _or;
 
4099
    size_t _xor;
 
4100
    size_t _not;
 
4101
    size_t exists;
 
4102
    size_t forall;
 
4103
    size_t implies;
 
4104
    size_t naturalnumbers;
 
4105
    size_t primes;
 
4106
    size_t integers;
 
4107
    size_t rationals;
 
4108
    size_t reals;
 
4109
    size_t complexes;
 
4110
    size_t emptyset;
 
4111
    size_t exponentiale;
 
4112
    size_t imaginaryi;
 
4113
    size_t pi;
 
4114
    size_t eulergamma;
 
4115
    size_t _true;
 
4116
    size_t _false;
 
4117
    size_t infinity;
 
4118
    size_t notanumber;
 
4119
    size_t set;
 
4120
    size_t list;
 
4121
    size_t _union;
 
4122
    size_t intersect;
 
4123
    size_t _in;
 
4124
    size_t notin;
 
4125
    size_t subset;
 
4126
    size_t prsubset;
 
4127
    size_t notsubset;
 
4128
    size_t notprsubset;
 
4129
    size_t setdiff;
 
4130
    size_t card;
 
4131
    size_t cartesianproduct;
 
4132
    size_t eq;
 
4133
    size_t neq;
 
4134
    size_t leq;
 
4135
    size_t lt;
 
4136
    size_t geq;
 
4137
    size_t gt;
 
4138
    size_t equivalent;
 
4139
    size_t approx;
 
4140
    size_t factorof;
 
4141
    size_t exp;
 
4142
    size_t ln;
 
4143
    size_t log;
 
4144
    size_t logbase;
 
4145
    size_t sin;
 
4146
    size_t cos;
 
4147
    size_t tan;
 
4148
    size_t sec;
 
4149
    size_t csc;
 
4150
    size_t cot;
 
4151
    size_t arcsin;
 
4152
    size_t arccos;
 
4153
    size_t arctan;
 
4154
    size_t arcsec;
 
4155
    size_t arccsc;
 
4156
    size_t arccot;
 
4157
    size_t sinh;
 
4158
    size_t cosh;
 
4159
    size_t tanh;
 
4160
    size_t sech;
 
4161
    size_t csch;
 
4162
    size_t coth;
 
4163
    size_t arccosh;
 
4164
    size_t arccoth;
 
4165
    size_t arccsch;
 
4166
    size_t arcsech;
 
4167
    size_t arcsinh;
 
4168
    size_t arctanh;
 
4169
    size_t _int;
 
4170
    size_t diff;
 
4171
    size_t partialdiff;
 
4172
    size_t limit;
 
4173
    size_t lowlimit;
 
4174
    size_t uplimit;
 
4175
    size_t tendsto;
 
4176
    size_t vector;
 
4177
    size_t matrix;
 
4178
    size_t determinant;
 
4179
    size_t transpose;
 
4180
    size_t selector;
 
4181
    size_t vectorproduct;
 
4182
    size_t scalarproduct;
 
4183
    size_t outerproduct;
 
4184
    size_t divergence;
 
4185
    size_t grad;
 
4186
    size_t curl;
 
4187
    size_t laplacian;
 
4188
    size_t mean;
 
4189
    size_t sdev;
 
4190
    size_t variance;
 
4191
    size_t median;
 
4192
    size_t mode;
 
4193
    size_t moment;
 
4194
    size_t momentabout;
 
4195
    size_t apply;
 
4196
    size_t interval;
 
4197
    size_t inverse;
 
4198
    size_t condition;
 
4199
    size_t declare;
 
4200
    size_t lambda;
 
4201
    size_t piecewise;
 
4202
    size_t bvar;
 
4203
    size_t degree;
 
4204
    size_t semantics;
 
4205
    size_t validationWholeSize;
 
4206
};
 
4207
 
 
4208
struct csymbol__ValidationData
 
4209
{
 
4210
    size_t validation_current_state;
 
4211
    size_t cn;
 
4212
    size_t ci;
 
4213
    size_t csymbol;
 
4214
    size_t abs;
 
4215
    size_t conjugate;
 
4216
    size_t factorial;
 
4217
    size_t arg;
 
4218
    size_t real;
 
4219
    size_t imaginary;
 
4220
    size_t floor;
 
4221
    size_t ceiling;
 
4222
    size_t quotient;
 
4223
    size_t divide;
 
4224
    size_t rem;
 
4225
    size_t minus;
 
4226
    size_t plus;
 
4227
    size_t times;
 
4228
    size_t power;
 
4229
    size_t root;
 
4230
    size_t max;
 
4231
    size_t min;
 
4232
    size_t gcd;
 
4233
    size_t lcm;
 
4234
    size_t sum;
 
4235
    size_t product;
 
4236
    size_t compose;
 
4237
    size_t domain;
 
4238
    size_t codomain;
 
4239
    size_t image;
 
4240
    size_t domainofapplication;
 
4241
    size_t ident;
 
4242
    size_t _and;
 
4243
    size_t _or;
 
4244
    size_t _xor;
 
4245
    size_t _not;
 
4246
    size_t exists;
 
4247
    size_t forall;
 
4248
    size_t implies;
 
4249
    size_t naturalnumbers;
 
4250
    size_t primes;
 
4251
    size_t integers;
 
4252
    size_t rationals;
 
4253
    size_t reals;
 
4254
    size_t complexes;
 
4255
    size_t emptyset;
 
4256
    size_t exponentiale;
 
4257
    size_t imaginaryi;
 
4258
    size_t pi;
 
4259
    size_t eulergamma;
 
4260
    size_t _true;
 
4261
    size_t _false;
 
4262
    size_t infinity;
 
4263
    size_t notanumber;
 
4264
    size_t set;
 
4265
    size_t list;
 
4266
    size_t _union;
 
4267
    size_t intersect;
 
4268
    size_t _in;
 
4269
    size_t notin;
 
4270
    size_t subset;
 
4271
    size_t prsubset;
 
4272
    size_t notsubset;
 
4273
    size_t notprsubset;
 
4274
    size_t setdiff;
 
4275
    size_t card;
 
4276
    size_t cartesianproduct;
 
4277
    size_t eq;
 
4278
    size_t neq;
 
4279
    size_t leq;
 
4280
    size_t lt;
 
4281
    size_t geq;
 
4282
    size_t gt;
 
4283
    size_t equivalent;
 
4284
    size_t approx;
 
4285
    size_t factorof;
 
4286
    size_t exp;
 
4287
    size_t ln;
 
4288
    size_t log;
 
4289
    size_t logbase;
 
4290
    size_t sin;
 
4291
    size_t cos;
 
4292
    size_t tan;
 
4293
    size_t sec;
 
4294
    size_t csc;
 
4295
    size_t cot;
 
4296
    size_t arcsin;
 
4297
    size_t arccos;
 
4298
    size_t arctan;
 
4299
    size_t arcsec;
 
4300
    size_t arccsc;
 
4301
    size_t arccot;
 
4302
    size_t sinh;
 
4303
    size_t cosh;
 
4304
    size_t tanh;
 
4305
    size_t sech;
 
4306
    size_t csch;
 
4307
    size_t coth;
 
4308
    size_t arccosh;
 
4309
    size_t arccoth;
 
4310
    size_t arccsch;
 
4311
    size_t arcsech;
 
4312
    size_t arcsinh;
 
4313
    size_t arctanh;
 
4314
    size_t _int;
 
4315
    size_t diff;
 
4316
    size_t partialdiff;
 
4317
    size_t limit;
 
4318
    size_t lowlimit;
 
4319
    size_t uplimit;
 
4320
    size_t tendsto;
 
4321
    size_t vector;
 
4322
    size_t matrix;
 
4323
    size_t determinant;
 
4324
    size_t transpose;
 
4325
    size_t selector;
 
4326
    size_t vectorproduct;
 
4327
    size_t scalarproduct;
 
4328
    size_t outerproduct;
 
4329
    size_t divergence;
 
4330
    size_t grad;
 
4331
    size_t curl;
 
4332
    size_t laplacian;
 
4333
    size_t mean;
 
4334
    size_t sdev;
 
4335
    size_t variance;
 
4336
    size_t median;
 
4337
    size_t mode;
 
4338
    size_t moment;
 
4339
    size_t momentabout;
 
4340
    size_t apply;
 
4341
    size_t interval;
 
4342
    size_t inverse;
 
4343
    size_t condition;
 
4344
    size_t declare;
 
4345
    size_t lambda;
 
4346
    size_t piecewise;
 
4347
    size_t bvar;
 
4348
    size_t degree;
 
4349
    size_t semantics;
 
4350
    size_t validationWholeSize;
 
4351
};
 
4352
 
 
4353
struct domainofapplication__ValidationData
 
4354
{
 
4355
    size_t validation_current_state;
 
4356
    size_t cn;
 
4357
    size_t ci;
 
4358
    size_t csymbol;
 
4359
    size_t abs;
 
4360
    size_t conjugate;
 
4361
    size_t factorial;
 
4362
    size_t arg;
 
4363
    size_t real;
 
4364
    size_t imaginary;
 
4365
    size_t floor;
 
4366
    size_t ceiling;
 
4367
    size_t quotient;
 
4368
    size_t divide;
 
4369
    size_t rem;
 
4370
    size_t minus;
 
4371
    size_t plus;
 
4372
    size_t times;
 
4373
    size_t power;
 
4374
    size_t root;
 
4375
    size_t max;
 
4376
    size_t min;
 
4377
    size_t gcd;
 
4378
    size_t lcm;
 
4379
    size_t sum;
 
4380
    size_t product;
 
4381
    size_t compose;
 
4382
    size_t domain;
 
4383
    size_t codomain;
 
4384
    size_t image;
 
4385
    size_t domainofapplication;
 
4386
    size_t ident;
 
4387
    size_t _and;
 
4388
    size_t _or;
 
4389
    size_t _xor;
 
4390
    size_t _not;
 
4391
    size_t exists;
 
4392
    size_t forall;
 
4393
    size_t implies;
 
4394
    size_t naturalnumbers;
 
4395
    size_t primes;
 
4396
    size_t integers;
 
4397
    size_t rationals;
 
4398
    size_t reals;
 
4399
    size_t complexes;
 
4400
    size_t emptyset;
 
4401
    size_t exponentiale;
 
4402
    size_t imaginaryi;
 
4403
    size_t pi;
 
4404
    size_t eulergamma;
 
4405
    size_t _true;
 
4406
    size_t _false;
 
4407
    size_t infinity;
 
4408
    size_t notanumber;
 
4409
    size_t set;
 
4410
    size_t list;
 
4411
    size_t _union;
 
4412
    size_t intersect;
 
4413
    size_t _in;
 
4414
    size_t notin;
 
4415
    size_t subset;
 
4416
    size_t prsubset;
 
4417
    size_t notsubset;
 
4418
    size_t notprsubset;
 
4419
    size_t setdiff;
 
4420
    size_t card;
 
4421
    size_t cartesianproduct;
 
4422
    size_t eq;
 
4423
    size_t neq;
 
4424
    size_t leq;
 
4425
    size_t lt;
 
4426
    size_t geq;
 
4427
    size_t gt;
 
4428
    size_t equivalent;
 
4429
    size_t approx;
 
4430
    size_t factorof;
 
4431
    size_t exp;
 
4432
    size_t ln;
 
4433
    size_t log;
 
4434
    size_t logbase;
 
4435
    size_t sin;
 
4436
    size_t cos;
 
4437
    size_t tan;
 
4438
    size_t sec;
 
4439
    size_t csc;
 
4440
    size_t cot;
 
4441
    size_t arcsin;
 
4442
    size_t arccos;
 
4443
    size_t arctan;
 
4444
    size_t arcsec;
 
4445
    size_t arccsc;
 
4446
    size_t arccot;
 
4447
    size_t sinh;
 
4448
    size_t cosh;
 
4449
    size_t tanh;
 
4450
    size_t sech;
 
4451
    size_t csch;
 
4452
    size_t coth;
 
4453
    size_t arccosh;
 
4454
    size_t arccoth;
 
4455
    size_t arccsch;
 
4456
    size_t arcsech;
 
4457
    size_t arcsinh;
 
4458
    size_t arctanh;
 
4459
    size_t _int;
 
4460
    size_t diff;
 
4461
    size_t partialdiff;
 
4462
    size_t limit;
 
4463
    size_t lowlimit;
 
4464
    size_t uplimit;
 
4465
    size_t tendsto;
 
4466
    size_t vector;
 
4467
    size_t matrix;
 
4468
    size_t determinant;
 
4469
    size_t transpose;
 
4470
    size_t selector;
 
4471
    size_t vectorproduct;
 
4472
    size_t scalarproduct;
 
4473
    size_t outerproduct;
 
4474
    size_t divergence;
 
4475
    size_t grad;
 
4476
    size_t curl;
 
4477
    size_t laplacian;
 
4478
    size_t mean;
 
4479
    size_t sdev;
 
4480
    size_t variance;
 
4481
    size_t median;
 
4482
    size_t mode;
 
4483
    size_t moment;
 
4484
    size_t momentabout;
 
4485
    size_t apply;
 
4486
    size_t interval;
 
4487
    size_t inverse;
 
4488
    size_t condition;
 
4489
    size_t declare;
 
4490
    size_t lambda;
 
4491
    size_t piecewise;
 
4492
    size_t bvar;
 
4493
    size_t degree;
 
4494
    size_t semantics;
 
4495
};
 
4496
 
 
4497
struct set__ValidationData
 
4498
{
 
4499
    size_t validation_current_state;
 
4500
    size_t cn;
 
4501
    size_t ci;
 
4502
    size_t csymbol;
 
4503
    size_t abs;
 
4504
    size_t conjugate;
 
4505
    size_t factorial;
 
4506
    size_t arg;
 
4507
    size_t real;
 
4508
    size_t imaginary;
 
4509
    size_t floor;
 
4510
    size_t ceiling;
 
4511
    size_t quotient;
 
4512
    size_t divide;
 
4513
    size_t rem;
 
4514
    size_t minus;
 
4515
    size_t plus;
 
4516
    size_t times;
 
4517
    size_t power;
 
4518
    size_t root;
 
4519
    size_t max;
 
4520
    size_t min;
 
4521
    size_t gcd;
 
4522
    size_t lcm;
 
4523
    size_t sum;
 
4524
    size_t product;
 
4525
    size_t compose;
 
4526
    size_t domain;
 
4527
    size_t codomain;
 
4528
    size_t image;
 
4529
    size_t domainofapplication;
 
4530
    size_t ident;
 
4531
    size_t _and;
 
4532
    size_t _or;
 
4533
    size_t _xor;
 
4534
    size_t _not;
 
4535
    size_t exists;
 
4536
    size_t forall;
 
4537
    size_t implies;
 
4538
    size_t naturalnumbers;
 
4539
    size_t primes;
 
4540
    size_t integers;
 
4541
    size_t rationals;
 
4542
    size_t reals;
 
4543
    size_t complexes;
 
4544
    size_t emptyset;
 
4545
    size_t exponentiale;
 
4546
    size_t imaginaryi;
 
4547
    size_t pi;
 
4548
    size_t eulergamma;
 
4549
    size_t _true;
 
4550
    size_t _false;
 
4551
    size_t infinity;
 
4552
    size_t notanumber;
 
4553
    size_t set;
 
4554
    size_t list;
 
4555
    size_t _union;
 
4556
    size_t intersect;
 
4557
    size_t _in;
 
4558
    size_t notin;
 
4559
    size_t subset;
 
4560
    size_t prsubset;
 
4561
    size_t notsubset;
 
4562
    size_t notprsubset;
 
4563
    size_t setdiff;
 
4564
    size_t card;
 
4565
    size_t cartesianproduct;
 
4566
    size_t eq;
 
4567
    size_t neq;
 
4568
    size_t leq;
 
4569
    size_t lt;
 
4570
    size_t geq;
 
4571
    size_t gt;
 
4572
    size_t equivalent;
 
4573
    size_t approx;
 
4574
    size_t factorof;
 
4575
    size_t exp;
 
4576
    size_t ln;
 
4577
    size_t log;
 
4578
    size_t logbase;
 
4579
    size_t sin;
 
4580
    size_t cos;
 
4581
    size_t tan;
 
4582
    size_t sec;
 
4583
    size_t csc;
 
4584
    size_t cot;
 
4585
    size_t arcsin;
 
4586
    size_t arccos;
 
4587
    size_t arctan;
 
4588
    size_t arcsec;
 
4589
    size_t arccsc;
 
4590
    size_t arccot;
 
4591
    size_t sinh;
 
4592
    size_t cosh;
 
4593
    size_t tanh;
 
4594
    size_t sech;
 
4595
    size_t csch;
 
4596
    size_t coth;
 
4597
    size_t arccosh;
 
4598
    size_t arccoth;
 
4599
    size_t arccsch;
 
4600
    size_t arcsech;
 
4601
    size_t arcsinh;
 
4602
    size_t arctanh;
 
4603
    size_t _int;
 
4604
    size_t diff;
 
4605
    size_t partialdiff;
 
4606
    size_t limit;
 
4607
    size_t lowlimit;
 
4608
    size_t uplimit;
 
4609
    size_t tendsto;
 
4610
    size_t vector;
 
4611
    size_t matrix;
 
4612
    size_t determinant;
 
4613
    size_t transpose;
 
4614
    size_t selector;
 
4615
    size_t vectorproduct;
 
4616
    size_t scalarproduct;
 
4617
    size_t outerproduct;
 
4618
    size_t divergence;
 
4619
    size_t grad;
 
4620
    size_t curl;
 
4621
    size_t laplacian;
 
4622
    size_t mean;
 
4623
    size_t sdev;
 
4624
    size_t variance;
 
4625
    size_t median;
 
4626
    size_t mode;
 
4627
    size_t moment;
 
4628
    size_t momentabout;
 
4629
    size_t apply;
 
4630
    size_t interval;
 
4631
    size_t inverse;
 
4632
    size_t condition;
 
4633
    size_t declare;
 
4634
    size_t lambda;
 
4635
    size_t piecewise;
 
4636
    size_t bvar;
 
4637
    size_t degree;
 
4638
    size_t semantics;
 
4639
};
 
4640
 
 
4641
ParserError::ErrorType validate__list( ParserString value );
 
4642
ParserError::ErrorType validate__list( const ParserChar* value, size_t length );
 
4643
ParserError::ErrorType validate__list__stream( const ParserChar* value, size_t length );
 
4644
ParserError::ErrorType validate__list__streamEnd( const ParserChar* value, size_t length );
 
4645
 
 
4646
struct list__ValidationData
 
4647
{
 
4648
    size_t validation_current_state;
 
4649
    size_t cn;
 
4650
    size_t ci;
 
4651
    size_t csymbol;
 
4652
    size_t abs;
 
4653
    size_t conjugate;
 
4654
    size_t factorial;
 
4655
    size_t arg;
 
4656
    size_t real;
 
4657
    size_t imaginary;
 
4658
    size_t floor;
 
4659
    size_t ceiling;
 
4660
    size_t quotient;
 
4661
    size_t divide;
 
4662
    size_t rem;
 
4663
    size_t minus;
 
4664
    size_t plus;
 
4665
    size_t times;
 
4666
    size_t power;
 
4667
    size_t root;
 
4668
    size_t max;
 
4669
    size_t min;
 
4670
    size_t gcd;
 
4671
    size_t lcm;
 
4672
    size_t sum;
 
4673
    size_t product;
 
4674
    size_t compose;
 
4675
    size_t domain;
 
4676
    size_t codomain;
 
4677
    size_t image;
 
4678
    size_t domainofapplication;
 
4679
    size_t ident;
 
4680
    size_t _and;
 
4681
    size_t _or;
 
4682
    size_t _xor;
 
4683
    size_t _not;
 
4684
    size_t exists;
 
4685
    size_t forall;
 
4686
    size_t implies;
 
4687
    size_t naturalnumbers;
 
4688
    size_t primes;
 
4689
    size_t integers;
 
4690
    size_t rationals;
 
4691
    size_t reals;
 
4692
    size_t complexes;
 
4693
    size_t emptyset;
 
4694
    size_t exponentiale;
 
4695
    size_t imaginaryi;
 
4696
    size_t pi;
 
4697
    size_t eulergamma;
 
4698
    size_t _true;
 
4699
    size_t _false;
 
4700
    size_t infinity;
 
4701
    size_t notanumber;
 
4702
    size_t set;
 
4703
    size_t list;
 
4704
    size_t _union;
 
4705
    size_t intersect;
 
4706
    size_t _in;
 
4707
    size_t notin;
 
4708
    size_t subset;
 
4709
    size_t prsubset;
 
4710
    size_t notsubset;
 
4711
    size_t notprsubset;
 
4712
    size_t setdiff;
 
4713
    size_t card;
 
4714
    size_t cartesianproduct;
 
4715
    size_t eq;
 
4716
    size_t neq;
 
4717
    size_t leq;
 
4718
    size_t lt;
 
4719
    size_t geq;
 
4720
    size_t gt;
 
4721
    size_t equivalent;
 
4722
    size_t approx;
 
4723
    size_t factorof;
 
4724
    size_t exp;
 
4725
    size_t ln;
 
4726
    size_t log;
 
4727
    size_t logbase;
 
4728
    size_t sin;
 
4729
    size_t cos;
 
4730
    size_t tan;
 
4731
    size_t sec;
 
4732
    size_t csc;
 
4733
    size_t cot;
 
4734
    size_t arcsin;
 
4735
    size_t arccos;
 
4736
    size_t arctan;
 
4737
    size_t arcsec;
 
4738
    size_t arccsc;
 
4739
    size_t arccot;
 
4740
    size_t sinh;
 
4741
    size_t cosh;
 
4742
    size_t tanh;
 
4743
    size_t sech;
 
4744
    size_t csch;
 
4745
    size_t coth;
 
4746
    size_t arccosh;
 
4747
    size_t arccoth;
 
4748
    size_t arccsch;
 
4749
    size_t arcsech;
 
4750
    size_t arcsinh;
 
4751
    size_t arctanh;
 
4752
    size_t _int;
 
4753
    size_t diff;
 
4754
    size_t partialdiff;
 
4755
    size_t limit;
 
4756
    size_t lowlimit;
 
4757
    size_t uplimit;
 
4758
    size_t tendsto;
 
4759
    size_t vector;
 
4760
    size_t matrix;
 
4761
    size_t determinant;
 
4762
    size_t transpose;
 
4763
    size_t selector;
 
4764
    size_t vectorproduct;
 
4765
    size_t scalarproduct;
 
4766
    size_t outerproduct;
 
4767
    size_t divergence;
 
4768
    size_t grad;
 
4769
    size_t curl;
 
4770
    size_t laplacian;
 
4771
    size_t mean;
 
4772
    size_t sdev;
 
4773
    size_t variance;
 
4774
    size_t median;
 
4775
    size_t mode;
 
4776
    size_t moment;
 
4777
    size_t momentabout;
 
4778
    size_t apply;
 
4779
    size_t interval;
 
4780
    size_t inverse;
 
4781
    size_t condition;
 
4782
    size_t declare;
 
4783
    size_t lambda;
 
4784
    size_t piecewise;
 
4785
    size_t bvar;
 
4786
    size_t degree;
 
4787
    size_t semantics;
 
4788
};
 
4789
 
 
4790
struct logbase__ValidationData
 
4791
{
 
4792
    size_t validation_current_state;
 
4793
    size_t cn;
 
4794
    size_t ci;
 
4795
    size_t csymbol;
 
4796
    size_t abs;
 
4797
    size_t conjugate;
 
4798
    size_t factorial;
 
4799
    size_t arg;
 
4800
    size_t real;
 
4801
    size_t imaginary;
 
4802
    size_t floor;
 
4803
    size_t ceiling;
 
4804
    size_t quotient;
 
4805
    size_t divide;
 
4806
    size_t rem;
 
4807
    size_t minus;
 
4808
    size_t plus;
 
4809
    size_t times;
 
4810
    size_t power;
 
4811
    size_t root;
 
4812
    size_t max;
 
4813
    size_t min;
 
4814
    size_t gcd;
 
4815
    size_t lcm;
 
4816
    size_t sum;
 
4817
    size_t product;
 
4818
    size_t compose;
 
4819
    size_t domain;
 
4820
    size_t codomain;
 
4821
    size_t image;
 
4822
    size_t domainofapplication;
 
4823
    size_t ident;
 
4824
    size_t _and;
 
4825
    size_t _or;
 
4826
    size_t _xor;
 
4827
    size_t _not;
 
4828
    size_t exists;
 
4829
    size_t forall;
 
4830
    size_t implies;
 
4831
    size_t naturalnumbers;
 
4832
    size_t primes;
 
4833
    size_t integers;
 
4834
    size_t rationals;
 
4835
    size_t reals;
 
4836
    size_t complexes;
 
4837
    size_t emptyset;
 
4838
    size_t exponentiale;
 
4839
    size_t imaginaryi;
 
4840
    size_t pi;
 
4841
    size_t eulergamma;
 
4842
    size_t _true;
 
4843
    size_t _false;
 
4844
    size_t infinity;
 
4845
    size_t notanumber;
 
4846
    size_t set;
 
4847
    size_t list;
 
4848
    size_t _union;
 
4849
    size_t intersect;
 
4850
    size_t _in;
 
4851
    size_t notin;
 
4852
    size_t subset;
 
4853
    size_t prsubset;
 
4854
    size_t notsubset;
 
4855
    size_t notprsubset;
 
4856
    size_t setdiff;
 
4857
    size_t card;
 
4858
    size_t cartesianproduct;
 
4859
    size_t eq;
 
4860
    size_t neq;
 
4861
    size_t leq;
 
4862
    size_t lt;
 
4863
    size_t geq;
 
4864
    size_t gt;
 
4865
    size_t equivalent;
 
4866
    size_t approx;
 
4867
    size_t factorof;
 
4868
    size_t exp;
 
4869
    size_t ln;
 
4870
    size_t log;
 
4871
    size_t logbase;
 
4872
    size_t sin;
 
4873
    size_t cos;
 
4874
    size_t tan;
 
4875
    size_t sec;
 
4876
    size_t csc;
 
4877
    size_t cot;
 
4878
    size_t arcsin;
 
4879
    size_t arccos;
 
4880
    size_t arctan;
 
4881
    size_t arcsec;
 
4882
    size_t arccsc;
 
4883
    size_t arccot;
 
4884
    size_t sinh;
 
4885
    size_t cosh;
 
4886
    size_t tanh;
 
4887
    size_t sech;
 
4888
    size_t csch;
 
4889
    size_t coth;
 
4890
    size_t arccosh;
 
4891
    size_t arccoth;
 
4892
    size_t arccsch;
 
4893
    size_t arcsech;
 
4894
    size_t arcsinh;
 
4895
    size_t arctanh;
 
4896
    size_t _int;
 
4897
    size_t diff;
 
4898
    size_t partialdiff;
 
4899
    size_t limit;
 
4900
    size_t lowlimit;
 
4901
    size_t uplimit;
 
4902
    size_t tendsto;
 
4903
    size_t vector;
 
4904
    size_t matrix;
 
4905
    size_t determinant;
 
4906
    size_t transpose;
 
4907
    size_t selector;
 
4908
    size_t vectorproduct;
 
4909
    size_t scalarproduct;
 
4910
    size_t outerproduct;
 
4911
    size_t divergence;
 
4912
    size_t grad;
 
4913
    size_t curl;
 
4914
    size_t laplacian;
 
4915
    size_t mean;
 
4916
    size_t sdev;
 
4917
    size_t variance;
 
4918
    size_t median;
 
4919
    size_t mode;
 
4920
    size_t moment;
 
4921
    size_t momentabout;
 
4922
    size_t apply;
 
4923
    size_t interval;
 
4924
    size_t inverse;
 
4925
    size_t condition;
 
4926
    size_t declare;
 
4927
    size_t lambda;
 
4928
    size_t piecewise;
 
4929
    size_t bvar;
 
4930
    size_t degree;
 
4931
    size_t semantics;
 
4932
};
 
4933
 
 
4934
struct lowlimit__ValidationData
 
4935
{
 
4936
    size_t validation_current_state;
 
4937
    size_t cn;
 
4938
    size_t ci;
 
4939
    size_t csymbol;
 
4940
    size_t abs;
 
4941
    size_t conjugate;
 
4942
    size_t factorial;
 
4943
    size_t arg;
 
4944
    size_t real;
 
4945
    size_t imaginary;
 
4946
    size_t floor;
 
4947
    size_t ceiling;
 
4948
    size_t quotient;
 
4949
    size_t divide;
 
4950
    size_t rem;
 
4951
    size_t minus;
 
4952
    size_t plus;
 
4953
    size_t times;
 
4954
    size_t power;
 
4955
    size_t root;
 
4956
    size_t max;
 
4957
    size_t min;
 
4958
    size_t gcd;
 
4959
    size_t lcm;
 
4960
    size_t sum;
 
4961
    size_t product;
 
4962
    size_t compose;
 
4963
    size_t domain;
 
4964
    size_t codomain;
 
4965
    size_t image;
 
4966
    size_t domainofapplication;
 
4967
    size_t ident;
 
4968
    size_t _and;
 
4969
    size_t _or;
 
4970
    size_t _xor;
 
4971
    size_t _not;
 
4972
    size_t exists;
 
4973
    size_t forall;
 
4974
    size_t implies;
 
4975
    size_t naturalnumbers;
 
4976
    size_t primes;
 
4977
    size_t integers;
 
4978
    size_t rationals;
 
4979
    size_t reals;
 
4980
    size_t complexes;
 
4981
    size_t emptyset;
 
4982
    size_t exponentiale;
 
4983
    size_t imaginaryi;
 
4984
    size_t pi;
 
4985
    size_t eulergamma;
 
4986
    size_t _true;
 
4987
    size_t _false;
 
4988
    size_t infinity;
 
4989
    size_t notanumber;
 
4990
    size_t set;
 
4991
    size_t list;
 
4992
    size_t _union;
 
4993
    size_t intersect;
 
4994
    size_t _in;
 
4995
    size_t notin;
 
4996
    size_t subset;
 
4997
    size_t prsubset;
 
4998
    size_t notsubset;
 
4999
    size_t notprsubset;
 
5000
    size_t setdiff;
 
5001
    size_t card;
 
5002
    size_t cartesianproduct;
 
5003
    size_t eq;
 
5004
    size_t neq;
 
5005
    size_t leq;
 
5006
    size_t lt;
 
5007
    size_t geq;
 
5008
    size_t gt;
 
5009
    size_t equivalent;
 
5010
    size_t approx;
 
5011
    size_t factorof;
 
5012
    size_t exp;
 
5013
    size_t ln;
 
5014
    size_t log;
 
5015
    size_t logbase;
 
5016
    size_t sin;
 
5017
    size_t cos;
 
5018
    size_t tan;
 
5019
    size_t sec;
 
5020
    size_t csc;
 
5021
    size_t cot;
 
5022
    size_t arcsin;
 
5023
    size_t arccos;
 
5024
    size_t arctan;
 
5025
    size_t arcsec;
 
5026
    size_t arccsc;
 
5027
    size_t arccot;
 
5028
    size_t sinh;
 
5029
    size_t cosh;
 
5030
    size_t tanh;
 
5031
    size_t sech;
 
5032
    size_t csch;
 
5033
    size_t coth;
 
5034
    size_t arccosh;
 
5035
    size_t arccoth;
 
5036
    size_t arccsch;
 
5037
    size_t arcsech;
 
5038
    size_t arcsinh;
 
5039
    size_t arctanh;
 
5040
    size_t _int;
 
5041
    size_t diff;
 
5042
    size_t partialdiff;
 
5043
    size_t limit;
 
5044
    size_t lowlimit;
 
5045
    size_t uplimit;
 
5046
    size_t tendsto;
 
5047
    size_t vector;
 
5048
    size_t matrix;
 
5049
    size_t determinant;
 
5050
    size_t transpose;
 
5051
    size_t selector;
 
5052
    size_t vectorproduct;
 
5053
    size_t scalarproduct;
 
5054
    size_t outerproduct;
 
5055
    size_t divergence;
 
5056
    size_t grad;
 
5057
    size_t curl;
 
5058
    size_t laplacian;
 
5059
    size_t mean;
 
5060
    size_t sdev;
 
5061
    size_t variance;
 
5062
    size_t median;
 
5063
    size_t mode;
 
5064
    size_t moment;
 
5065
    size_t momentabout;
 
5066
    size_t apply;
 
5067
    size_t interval;
 
5068
    size_t inverse;
 
5069
    size_t condition;
 
5070
    size_t declare;
 
5071
    size_t lambda;
 
5072
    size_t piecewise;
 
5073
    size_t bvar;
 
5074
    size_t degree;
 
5075
    size_t semantics;
 
5076
};
 
5077
 
 
5078
struct uplimit__ValidationData
 
5079
{
 
5080
    size_t validation_current_state;
 
5081
    size_t cn;
 
5082
    size_t ci;
 
5083
    size_t csymbol;
 
5084
    size_t abs;
 
5085
    size_t conjugate;
 
5086
    size_t factorial;
 
5087
    size_t arg;
 
5088
    size_t real;
 
5089
    size_t imaginary;
 
5090
    size_t floor;
 
5091
    size_t ceiling;
 
5092
    size_t quotient;
 
5093
    size_t divide;
 
5094
    size_t rem;
 
5095
    size_t minus;
 
5096
    size_t plus;
 
5097
    size_t times;
 
5098
    size_t power;
 
5099
    size_t root;
 
5100
    size_t max;
 
5101
    size_t min;
 
5102
    size_t gcd;
 
5103
    size_t lcm;
 
5104
    size_t sum;
 
5105
    size_t product;
 
5106
    size_t compose;
 
5107
    size_t domain;
 
5108
    size_t codomain;
 
5109
    size_t image;
 
5110
    size_t domainofapplication;
 
5111
    size_t ident;
 
5112
    size_t _and;
 
5113
    size_t _or;
 
5114
    size_t _xor;
 
5115
    size_t _not;
 
5116
    size_t exists;
 
5117
    size_t forall;
 
5118
    size_t implies;
 
5119
    size_t naturalnumbers;
 
5120
    size_t primes;
 
5121
    size_t integers;
 
5122
    size_t rationals;
 
5123
    size_t reals;
 
5124
    size_t complexes;
 
5125
    size_t emptyset;
 
5126
    size_t exponentiale;
 
5127
    size_t imaginaryi;
 
5128
    size_t pi;
 
5129
    size_t eulergamma;
 
5130
    size_t _true;
 
5131
    size_t _false;
 
5132
    size_t infinity;
 
5133
    size_t notanumber;
 
5134
    size_t set;
 
5135
    size_t list;
 
5136
    size_t _union;
 
5137
    size_t intersect;
 
5138
    size_t _in;
 
5139
    size_t notin;
 
5140
    size_t subset;
 
5141
    size_t prsubset;
 
5142
    size_t notsubset;
 
5143
    size_t notprsubset;
 
5144
    size_t setdiff;
 
5145
    size_t card;
 
5146
    size_t cartesianproduct;
 
5147
    size_t eq;
 
5148
    size_t neq;
 
5149
    size_t leq;
 
5150
    size_t lt;
 
5151
    size_t geq;
 
5152
    size_t gt;
 
5153
    size_t equivalent;
 
5154
    size_t approx;
 
5155
    size_t factorof;
 
5156
    size_t exp;
 
5157
    size_t ln;
 
5158
    size_t log;
 
5159
    size_t logbase;
 
5160
    size_t sin;
 
5161
    size_t cos;
 
5162
    size_t tan;
 
5163
    size_t sec;
 
5164
    size_t csc;
 
5165
    size_t cot;
 
5166
    size_t arcsin;
 
5167
    size_t arccos;
 
5168
    size_t arctan;
 
5169
    size_t arcsec;
 
5170
    size_t arccsc;
 
5171
    size_t arccot;
 
5172
    size_t sinh;
 
5173
    size_t cosh;
 
5174
    size_t tanh;
 
5175
    size_t sech;
 
5176
    size_t csch;
 
5177
    size_t coth;
 
5178
    size_t arccosh;
 
5179
    size_t arccoth;
 
5180
    size_t arccsch;
 
5181
    size_t arcsech;
 
5182
    size_t arcsinh;
 
5183
    size_t arctanh;
 
5184
    size_t _int;
 
5185
    size_t diff;
 
5186
    size_t partialdiff;
 
5187
    size_t limit;
 
5188
    size_t lowlimit;
 
5189
    size_t uplimit;
 
5190
    size_t tendsto;
 
5191
    size_t vector;
 
5192
    size_t matrix;
 
5193
    size_t determinant;
 
5194
    size_t transpose;
 
5195
    size_t selector;
 
5196
    size_t vectorproduct;
 
5197
    size_t scalarproduct;
 
5198
    size_t outerproduct;
 
5199
    size_t divergence;
 
5200
    size_t grad;
 
5201
    size_t curl;
 
5202
    size_t laplacian;
 
5203
    size_t mean;
 
5204
    size_t sdev;
 
5205
    size_t variance;
 
5206
    size_t median;
 
5207
    size_t mode;
 
5208
    size_t moment;
 
5209
    size_t momentabout;
 
5210
    size_t apply;
 
5211
    size_t interval;
 
5212
    size_t inverse;
 
5213
    size_t condition;
 
5214
    size_t declare;
 
5215
    size_t lambda;
 
5216
    size_t piecewise;
 
5217
    size_t bvar;
 
5218
    size_t degree;
 
5219
    size_t semantics;
 
5220
};
 
5221
 
 
5222
struct vector__ValidationData
 
5223
{
 
5224
    size_t validation_current_state;
 
5225
    size_t cn;
 
5226
    size_t ci;
 
5227
    size_t csymbol;
 
5228
    size_t abs;
 
5229
    size_t conjugate;
 
5230
    size_t factorial;
 
5231
    size_t arg;
 
5232
    size_t real;
 
5233
    size_t imaginary;
 
5234
    size_t floor;
 
5235
    size_t ceiling;
 
5236
    size_t quotient;
 
5237
    size_t divide;
 
5238
    size_t rem;
 
5239
    size_t minus;
 
5240
    size_t plus;
 
5241
    size_t times;
 
5242
    size_t power;
 
5243
    size_t root;
 
5244
    size_t max;
 
5245
    size_t min;
 
5246
    size_t gcd;
 
5247
    size_t lcm;
 
5248
    size_t sum;
 
5249
    size_t product;
 
5250
    size_t compose;
 
5251
    size_t domain;
 
5252
    size_t codomain;
 
5253
    size_t image;
 
5254
    size_t domainofapplication;
 
5255
    size_t ident;
 
5256
    size_t _and;
 
5257
    size_t _or;
 
5258
    size_t _xor;
 
5259
    size_t _not;
 
5260
    size_t exists;
 
5261
    size_t forall;
 
5262
    size_t implies;
 
5263
    size_t naturalnumbers;
 
5264
    size_t primes;
 
5265
    size_t integers;
 
5266
    size_t rationals;
 
5267
    size_t reals;
 
5268
    size_t complexes;
 
5269
    size_t emptyset;
 
5270
    size_t exponentiale;
 
5271
    size_t imaginaryi;
 
5272
    size_t pi;
 
5273
    size_t eulergamma;
 
5274
    size_t _true;
 
5275
    size_t _false;
 
5276
    size_t infinity;
 
5277
    size_t notanumber;
 
5278
    size_t set;
 
5279
    size_t list;
 
5280
    size_t _union;
 
5281
    size_t intersect;
 
5282
    size_t _in;
 
5283
    size_t notin;
 
5284
    size_t subset;
 
5285
    size_t prsubset;
 
5286
    size_t notsubset;
 
5287
    size_t notprsubset;
 
5288
    size_t setdiff;
 
5289
    size_t card;
 
5290
    size_t cartesianproduct;
 
5291
    size_t eq;
 
5292
    size_t neq;
 
5293
    size_t leq;
 
5294
    size_t lt;
 
5295
    size_t geq;
 
5296
    size_t gt;
 
5297
    size_t equivalent;
 
5298
    size_t approx;
 
5299
    size_t factorof;
 
5300
    size_t exp;
 
5301
    size_t ln;
 
5302
    size_t log;
 
5303
    size_t logbase;
 
5304
    size_t sin;
 
5305
    size_t cos;
 
5306
    size_t tan;
 
5307
    size_t sec;
 
5308
    size_t csc;
 
5309
    size_t cot;
 
5310
    size_t arcsin;
 
5311
    size_t arccos;
 
5312
    size_t arctan;
 
5313
    size_t arcsec;
 
5314
    size_t arccsc;
 
5315
    size_t arccot;
 
5316
    size_t sinh;
 
5317
    size_t cosh;
 
5318
    size_t tanh;
 
5319
    size_t sech;
 
5320
    size_t csch;
 
5321
    size_t coth;
 
5322
    size_t arccosh;
 
5323
    size_t arccoth;
 
5324
    size_t arccsch;
 
5325
    size_t arcsech;
 
5326
    size_t arcsinh;
 
5327
    size_t arctanh;
 
5328
    size_t _int;
 
5329
    size_t diff;
 
5330
    size_t partialdiff;
 
5331
    size_t limit;
 
5332
    size_t lowlimit;
 
5333
    size_t uplimit;
 
5334
    size_t tendsto;
 
5335
    size_t vector;
 
5336
    size_t matrix;
 
5337
    size_t determinant;
 
5338
    size_t transpose;
 
5339
    size_t selector;
 
5340
    size_t vectorproduct;
 
5341
    size_t scalarproduct;
 
5342
    size_t outerproduct;
 
5343
    size_t divergence;
 
5344
    size_t grad;
 
5345
    size_t curl;
 
5346
    size_t laplacian;
 
5347
    size_t mean;
 
5348
    size_t sdev;
 
5349
    size_t variance;
 
5350
    size_t median;
 
5351
    size_t mode;
 
5352
    size_t moment;
 
5353
    size_t momentabout;
 
5354
    size_t apply;
 
5355
    size_t interval;
 
5356
    size_t inverse;
 
5357
    size_t condition;
 
5358
    size_t declare;
 
5359
    size_t lambda;
 
5360
    size_t piecewise;
 
5361
    size_t bvar;
 
5362
    size_t degree;
 
5363
    size_t semantics;
 
5364
};
 
5365
 
 
5366
struct matrix____matrix_type____mathml__ValidationData
 
5367
{
 
5368
    size_t matrixrow;
 
5369
};
 
5370
 
 
5371
struct matrixrow__ValidationData
 
5372
{
 
5373
    size_t validation_current_state;
 
5374
    size_t cn;
 
5375
    size_t ci;
 
5376
    size_t csymbol;
 
5377
    size_t abs;
 
5378
    size_t conjugate;
 
5379
    size_t factorial;
 
5380
    size_t arg;
 
5381
    size_t real;
 
5382
    size_t imaginary;
 
5383
    size_t floor;
 
5384
    size_t ceiling;
 
5385
    size_t quotient;
 
5386
    size_t divide;
 
5387
    size_t rem;
 
5388
    size_t minus;
 
5389
    size_t plus;
 
5390
    size_t times;
 
5391
    size_t power;
 
5392
    size_t root;
 
5393
    size_t max;
 
5394
    size_t min;
 
5395
    size_t gcd;
 
5396
    size_t lcm;
 
5397
    size_t sum;
 
5398
    size_t product;
 
5399
    size_t compose;
 
5400
    size_t domain;
 
5401
    size_t codomain;
 
5402
    size_t image;
 
5403
    size_t domainofapplication;
 
5404
    size_t ident;
 
5405
    size_t _and;
 
5406
    size_t _or;
 
5407
    size_t _xor;
 
5408
    size_t _not;
 
5409
    size_t exists;
 
5410
    size_t forall;
 
5411
    size_t implies;
 
5412
    size_t naturalnumbers;
 
5413
    size_t primes;
 
5414
    size_t integers;
 
5415
    size_t rationals;
 
5416
    size_t reals;
 
5417
    size_t complexes;
 
5418
    size_t emptyset;
 
5419
    size_t exponentiale;
 
5420
    size_t imaginaryi;
 
5421
    size_t pi;
 
5422
    size_t eulergamma;
 
5423
    size_t _true;
 
5424
    size_t _false;
 
5425
    size_t infinity;
 
5426
    size_t notanumber;
 
5427
    size_t set;
 
5428
    size_t list;
 
5429
    size_t _union;
 
5430
    size_t intersect;
 
5431
    size_t _in;
 
5432
    size_t notin;
 
5433
    size_t subset;
 
5434
    size_t prsubset;
 
5435
    size_t notsubset;
 
5436
    size_t notprsubset;
 
5437
    size_t setdiff;
 
5438
    size_t card;
 
5439
    size_t cartesianproduct;
 
5440
    size_t eq;
 
5441
    size_t neq;
 
5442
    size_t leq;
 
5443
    size_t lt;
 
5444
    size_t geq;
 
5445
    size_t gt;
 
5446
    size_t equivalent;
 
5447
    size_t approx;
 
5448
    size_t factorof;
 
5449
    size_t exp;
 
5450
    size_t ln;
 
5451
    size_t log;
 
5452
    size_t logbase;
 
5453
    size_t sin;
 
5454
    size_t cos;
 
5455
    size_t tan;
 
5456
    size_t sec;
 
5457
    size_t csc;
 
5458
    size_t cot;
 
5459
    size_t arcsin;
 
5460
    size_t arccos;
 
5461
    size_t arctan;
 
5462
    size_t arcsec;
 
5463
    size_t arccsc;
 
5464
    size_t arccot;
 
5465
    size_t sinh;
 
5466
    size_t cosh;
 
5467
    size_t tanh;
 
5468
    size_t sech;
 
5469
    size_t csch;
 
5470
    size_t coth;
 
5471
    size_t arccosh;
 
5472
    size_t arccoth;
 
5473
    size_t arccsch;
 
5474
    size_t arcsech;
 
5475
    size_t arcsinh;
 
5476
    size_t arctanh;
 
5477
    size_t _int;
 
5478
    size_t diff;
 
5479
    size_t partialdiff;
 
5480
    size_t limit;
 
5481
    size_t lowlimit;
 
5482
    size_t uplimit;
 
5483
    size_t tendsto;
 
5484
    size_t vector;
 
5485
    size_t matrix;
 
5486
    size_t determinant;
 
5487
    size_t transpose;
 
5488
    size_t selector;
 
5489
    size_t vectorproduct;
 
5490
    size_t scalarproduct;
 
5491
    size_t outerproduct;
 
5492
    size_t divergence;
 
5493
    size_t grad;
 
5494
    size_t curl;
 
5495
    size_t laplacian;
 
5496
    size_t mean;
 
5497
    size_t sdev;
 
5498
    size_t variance;
 
5499
    size_t median;
 
5500
    size_t mode;
 
5501
    size_t moment;
 
5502
    size_t momentabout;
 
5503
    size_t apply;
 
5504
    size_t interval;
 
5505
    size_t inverse;
 
5506
    size_t condition;
 
5507
    size_t declare;
 
5508
    size_t lambda;
 
5509
    size_t piecewise;
 
5510
    size_t bvar;
 
5511
    size_t degree;
 
5512
    size_t semantics;
 
5513
};
 
5514
 
 
5515
struct momentabout__ValidationData
 
5516
{
 
5517
    size_t validation_current_state;
 
5518
    size_t cn;
 
5519
    size_t ci;
 
5520
    size_t csymbol;
 
5521
    size_t abs;
 
5522
    size_t conjugate;
 
5523
    size_t factorial;
 
5524
    size_t arg;
 
5525
    size_t real;
 
5526
    size_t imaginary;
 
5527
    size_t floor;
 
5528
    size_t ceiling;
 
5529
    size_t quotient;
 
5530
    size_t divide;
 
5531
    size_t rem;
 
5532
    size_t minus;
 
5533
    size_t plus;
 
5534
    size_t times;
 
5535
    size_t power;
 
5536
    size_t root;
 
5537
    size_t max;
 
5538
    size_t min;
 
5539
    size_t gcd;
 
5540
    size_t lcm;
 
5541
    size_t sum;
 
5542
    size_t product;
 
5543
    size_t compose;
 
5544
    size_t domain;
 
5545
    size_t codomain;
 
5546
    size_t image;
 
5547
    size_t domainofapplication;
 
5548
    size_t ident;
 
5549
    size_t _and;
 
5550
    size_t _or;
 
5551
    size_t _xor;
 
5552
    size_t _not;
 
5553
    size_t exists;
 
5554
    size_t forall;
 
5555
    size_t implies;
 
5556
    size_t naturalnumbers;
 
5557
    size_t primes;
 
5558
    size_t integers;
 
5559
    size_t rationals;
 
5560
    size_t reals;
 
5561
    size_t complexes;
 
5562
    size_t emptyset;
 
5563
    size_t exponentiale;
 
5564
    size_t imaginaryi;
 
5565
    size_t pi;
 
5566
    size_t eulergamma;
 
5567
    size_t _true;
 
5568
    size_t _false;
 
5569
    size_t infinity;
 
5570
    size_t notanumber;
 
5571
    size_t set;
 
5572
    size_t list;
 
5573
    size_t _union;
 
5574
    size_t intersect;
 
5575
    size_t _in;
 
5576
    size_t notin;
 
5577
    size_t subset;
 
5578
    size_t prsubset;
 
5579
    size_t notsubset;
 
5580
    size_t notprsubset;
 
5581
    size_t setdiff;
 
5582
    size_t card;
 
5583
    size_t cartesianproduct;
 
5584
    size_t eq;
 
5585
    size_t neq;
 
5586
    size_t leq;
 
5587
    size_t lt;
 
5588
    size_t geq;
 
5589
    size_t gt;
 
5590
    size_t equivalent;
 
5591
    size_t approx;
 
5592
    size_t factorof;
 
5593
    size_t exp;
 
5594
    size_t ln;
 
5595
    size_t log;
 
5596
    size_t logbase;
 
5597
    size_t sin;
 
5598
    size_t cos;
 
5599
    size_t tan;
 
5600
    size_t sec;
 
5601
    size_t csc;
 
5602
    size_t cot;
 
5603
    size_t arcsin;
 
5604
    size_t arccos;
 
5605
    size_t arctan;
 
5606
    size_t arcsec;
 
5607
    size_t arccsc;
 
5608
    size_t arccot;
 
5609
    size_t sinh;
 
5610
    size_t cosh;
 
5611
    size_t tanh;
 
5612
    size_t sech;
 
5613
    size_t csch;
 
5614
    size_t coth;
 
5615
    size_t arccosh;
 
5616
    size_t arccoth;
 
5617
    size_t arccsch;
 
5618
    size_t arcsech;
 
5619
    size_t arcsinh;
 
5620
    size_t arctanh;
 
5621
    size_t _int;
 
5622
    size_t diff;
 
5623
    size_t partialdiff;
 
5624
    size_t limit;
 
5625
    size_t lowlimit;
 
5626
    size_t uplimit;
 
5627
    size_t tendsto;
 
5628
    size_t vector;
 
5629
    size_t matrix;
 
5630
    size_t determinant;
 
5631
    size_t transpose;
 
5632
    size_t selector;
 
5633
    size_t vectorproduct;
 
5634
    size_t scalarproduct;
 
5635
    size_t outerproduct;
 
5636
    size_t divergence;
 
5637
    size_t grad;
 
5638
    size_t curl;
 
5639
    size_t laplacian;
 
5640
    size_t mean;
 
5641
    size_t sdev;
 
5642
    size_t variance;
 
5643
    size_t median;
 
5644
    size_t mode;
 
5645
    size_t moment;
 
5646
    size_t momentabout;
 
5647
    size_t apply;
 
5648
    size_t interval;
 
5649
    size_t inverse;
 
5650
    size_t condition;
 
5651
    size_t declare;
 
5652
    size_t lambda;
 
5653
    size_t piecewise;
 
5654
    size_t bvar;
 
5655
    size_t degree;
 
5656
    size_t semantics;
 
5657
};
 
5658
 
 
5659
struct apply__ValidationData
 
5660
{
 
5661
    size_t validation_current_state;
 
5662
    size_t cn;
 
5663
    size_t ci;
 
5664
    size_t csymbol;
 
5665
    size_t abs;
 
5666
    size_t conjugate;
 
5667
    size_t factorial;
 
5668
    size_t arg;
 
5669
    size_t real;
 
5670
    size_t imaginary;
 
5671
    size_t floor;
 
5672
    size_t ceiling;
 
5673
    size_t quotient;
 
5674
    size_t divide;
 
5675
    size_t rem;
 
5676
    size_t minus;
 
5677
    size_t plus;
 
5678
    size_t times;
 
5679
    size_t power;
 
5680
    size_t root;
 
5681
    size_t max;
 
5682
    size_t min;
 
5683
    size_t gcd;
 
5684
    size_t lcm;
 
5685
    size_t sum;
 
5686
    size_t product;
 
5687
    size_t compose;
 
5688
    size_t domain;
 
5689
    size_t codomain;
 
5690
    size_t image;
 
5691
    size_t domainofapplication;
 
5692
    size_t ident;
 
5693
    size_t _and;
 
5694
    size_t _or;
 
5695
    size_t _xor;
 
5696
    size_t _not;
 
5697
    size_t exists;
 
5698
    size_t forall;
 
5699
    size_t implies;
 
5700
    size_t naturalnumbers;
 
5701
    size_t primes;
 
5702
    size_t integers;
 
5703
    size_t rationals;
 
5704
    size_t reals;
 
5705
    size_t complexes;
 
5706
    size_t emptyset;
 
5707
    size_t exponentiale;
 
5708
    size_t imaginaryi;
 
5709
    size_t pi;
 
5710
    size_t eulergamma;
 
5711
    size_t _true;
 
5712
    size_t _false;
 
5713
    size_t infinity;
 
5714
    size_t notanumber;
 
5715
    size_t set;
 
5716
    size_t list;
 
5717
    size_t _union;
 
5718
    size_t intersect;
 
5719
    size_t _in;
 
5720
    size_t notin;
 
5721
    size_t subset;
 
5722
    size_t prsubset;
 
5723
    size_t notsubset;
 
5724
    size_t notprsubset;
 
5725
    size_t setdiff;
 
5726
    size_t card;
 
5727
    size_t cartesianproduct;
 
5728
    size_t eq;
 
5729
    size_t neq;
 
5730
    size_t leq;
 
5731
    size_t lt;
 
5732
    size_t geq;
 
5733
    size_t gt;
 
5734
    size_t equivalent;
 
5735
    size_t approx;
 
5736
    size_t factorof;
 
5737
    size_t exp;
 
5738
    size_t ln;
 
5739
    size_t log;
 
5740
    size_t logbase;
 
5741
    size_t sin;
 
5742
    size_t cos;
 
5743
    size_t tan;
 
5744
    size_t sec;
 
5745
    size_t csc;
 
5746
    size_t cot;
 
5747
    size_t arcsin;
 
5748
    size_t arccos;
 
5749
    size_t arctan;
 
5750
    size_t arcsec;
 
5751
    size_t arccsc;
 
5752
    size_t arccot;
 
5753
    size_t sinh;
 
5754
    size_t cosh;
 
5755
    size_t tanh;
 
5756
    size_t sech;
 
5757
    size_t csch;
 
5758
    size_t coth;
 
5759
    size_t arccosh;
 
5760
    size_t arccoth;
 
5761
    size_t arccsch;
 
5762
    size_t arcsech;
 
5763
    size_t arcsinh;
 
5764
    size_t arctanh;
 
5765
    size_t _int;
 
5766
    size_t diff;
 
5767
    size_t partialdiff;
 
5768
    size_t limit;
 
5769
    size_t lowlimit;
 
5770
    size_t uplimit;
 
5771
    size_t tendsto;
 
5772
    size_t vector;
 
5773
    size_t matrix;
 
5774
    size_t determinant;
 
5775
    size_t transpose;
 
5776
    size_t selector;
 
5777
    size_t vectorproduct;
 
5778
    size_t scalarproduct;
 
5779
    size_t outerproduct;
 
5780
    size_t divergence;
 
5781
    size_t grad;
 
5782
    size_t curl;
 
5783
    size_t laplacian;
 
5784
    size_t mean;
 
5785
    size_t sdev;
 
5786
    size_t variance;
 
5787
    size_t median;
 
5788
    size_t mode;
 
5789
    size_t moment;
 
5790
    size_t momentabout;
 
5791
    size_t apply;
 
5792
    size_t interval;
 
5793
    size_t inverse;
 
5794
    size_t condition;
 
5795
    size_t declare;
 
5796
    size_t lambda;
 
5797
    size_t piecewise;
 
5798
    size_t bvar;
 
5799
    size_t degree;
 
5800
    size_t semantics;
 
5801
};
 
5802
 
 
5803
ParserError::ErrorType validate__interval( ParserString value );
 
5804
ParserError::ErrorType validate__interval( const ParserChar* value, size_t length );
 
5805
ParserError::ErrorType validate__interval__stream( const ParserChar* value, size_t length );
 
5806
ParserError::ErrorType validate__interval__streamEnd( const ParserChar* value, size_t length );
 
5807
 
 
5808
struct interval__ValidationData
 
5809
{
 
5810
    size_t validation_current_state;
 
5811
    size_t cn;
 
5812
    size_t ci;
 
5813
    size_t csymbol;
 
5814
    size_t abs;
 
5815
    size_t conjugate;
 
5816
    size_t factorial;
 
5817
    size_t arg;
 
5818
    size_t real;
 
5819
    size_t imaginary;
 
5820
    size_t floor;
 
5821
    size_t ceiling;
 
5822
    size_t quotient;
 
5823
    size_t divide;
 
5824
    size_t rem;
 
5825
    size_t minus;
 
5826
    size_t plus;
 
5827
    size_t times;
 
5828
    size_t power;
 
5829
    size_t root;
 
5830
    size_t max;
 
5831
    size_t min;
 
5832
    size_t gcd;
 
5833
    size_t lcm;
 
5834
    size_t sum;
 
5835
    size_t product;
 
5836
    size_t compose;
 
5837
    size_t domain;
 
5838
    size_t codomain;
 
5839
    size_t image;
 
5840
    size_t domainofapplication;
 
5841
    size_t ident;
 
5842
    size_t _and;
 
5843
    size_t _or;
 
5844
    size_t _xor;
 
5845
    size_t _not;
 
5846
    size_t exists;
 
5847
    size_t forall;
 
5848
    size_t implies;
 
5849
    size_t naturalnumbers;
 
5850
    size_t primes;
 
5851
    size_t integers;
 
5852
    size_t rationals;
 
5853
    size_t reals;
 
5854
    size_t complexes;
 
5855
    size_t emptyset;
 
5856
    size_t exponentiale;
 
5857
    size_t imaginaryi;
 
5858
    size_t pi;
 
5859
    size_t eulergamma;
 
5860
    size_t _true;
 
5861
    size_t _false;
 
5862
    size_t infinity;
 
5863
    size_t notanumber;
 
5864
    size_t set;
 
5865
    size_t list;
 
5866
    size_t _union;
 
5867
    size_t intersect;
 
5868
    size_t _in;
 
5869
    size_t notin;
 
5870
    size_t subset;
 
5871
    size_t prsubset;
 
5872
    size_t notsubset;
 
5873
    size_t notprsubset;
 
5874
    size_t setdiff;
 
5875
    size_t card;
 
5876
    size_t cartesianproduct;
 
5877
    size_t eq;
 
5878
    size_t neq;
 
5879
    size_t leq;
 
5880
    size_t lt;
 
5881
    size_t geq;
 
5882
    size_t gt;
 
5883
    size_t equivalent;
 
5884
    size_t approx;
 
5885
    size_t factorof;
 
5886
    size_t exp;
 
5887
    size_t ln;
 
5888
    size_t log;
 
5889
    size_t logbase;
 
5890
    size_t sin;
 
5891
    size_t cos;
 
5892
    size_t tan;
 
5893
    size_t sec;
 
5894
    size_t csc;
 
5895
    size_t cot;
 
5896
    size_t arcsin;
 
5897
    size_t arccos;
 
5898
    size_t arctan;
 
5899
    size_t arcsec;
 
5900
    size_t arccsc;
 
5901
    size_t arccot;
 
5902
    size_t sinh;
 
5903
    size_t cosh;
 
5904
    size_t tanh;
 
5905
    size_t sech;
 
5906
    size_t csch;
 
5907
    size_t coth;
 
5908
    size_t arccosh;
 
5909
    size_t arccoth;
 
5910
    size_t arccsch;
 
5911
    size_t arcsech;
 
5912
    size_t arcsinh;
 
5913
    size_t arctanh;
 
5914
    size_t _int;
 
5915
    size_t diff;
 
5916
    size_t partialdiff;
 
5917
    size_t limit;
 
5918
    size_t lowlimit;
 
5919
    size_t uplimit;
 
5920
    size_t tendsto;
 
5921
    size_t vector;
 
5922
    size_t matrix;
 
5923
    size_t determinant;
 
5924
    size_t transpose;
 
5925
    size_t selector;
 
5926
    size_t vectorproduct;
 
5927
    size_t scalarproduct;
 
5928
    size_t outerproduct;
 
5929
    size_t divergence;
 
5930
    size_t grad;
 
5931
    size_t curl;
 
5932
    size_t laplacian;
 
5933
    size_t mean;
 
5934
    size_t sdev;
 
5935
    size_t variance;
 
5936
    size_t median;
 
5937
    size_t mode;
 
5938
    size_t moment;
 
5939
    size_t momentabout;
 
5940
    size_t apply;
 
5941
    size_t interval;
 
5942
    size_t inverse;
 
5943
    size_t condition;
 
5944
    size_t declare;
 
5945
    size_t lambda;
 
5946
    size_t piecewise;
 
5947
    size_t bvar;
 
5948
    size_t degree;
 
5949
    size_t semantics;
 
5950
};
 
5951
 
 
5952
struct condition__ValidationData
 
5953
{
 
5954
    size_t validation_current_state;
 
5955
    size_t cn;
 
5956
    size_t ci;
 
5957
    size_t csymbol;
 
5958
    size_t abs;
 
5959
    size_t conjugate;
 
5960
    size_t factorial;
 
5961
    size_t arg;
 
5962
    size_t real;
 
5963
    size_t imaginary;
 
5964
    size_t floor;
 
5965
    size_t ceiling;
 
5966
    size_t quotient;
 
5967
    size_t divide;
 
5968
    size_t rem;
 
5969
    size_t minus;
 
5970
    size_t plus;
 
5971
    size_t times;
 
5972
    size_t power;
 
5973
    size_t root;
 
5974
    size_t max;
 
5975
    size_t min;
 
5976
    size_t gcd;
 
5977
    size_t lcm;
 
5978
    size_t sum;
 
5979
    size_t product;
 
5980
    size_t compose;
 
5981
    size_t domain;
 
5982
    size_t codomain;
 
5983
    size_t image;
 
5984
    size_t domainofapplication;
 
5985
    size_t ident;
 
5986
    size_t _and;
 
5987
    size_t _or;
 
5988
    size_t _xor;
 
5989
    size_t _not;
 
5990
    size_t exists;
 
5991
    size_t forall;
 
5992
    size_t implies;
 
5993
    size_t naturalnumbers;
 
5994
    size_t primes;
 
5995
    size_t integers;
 
5996
    size_t rationals;
 
5997
    size_t reals;
 
5998
    size_t complexes;
 
5999
    size_t emptyset;
 
6000
    size_t exponentiale;
 
6001
    size_t imaginaryi;
 
6002
    size_t pi;
 
6003
    size_t eulergamma;
 
6004
    size_t _true;
 
6005
    size_t _false;
 
6006
    size_t infinity;
 
6007
    size_t notanumber;
 
6008
    size_t set;
 
6009
    size_t list;
 
6010
    size_t _union;
 
6011
    size_t intersect;
 
6012
    size_t _in;
 
6013
    size_t notin;
 
6014
    size_t subset;
 
6015
    size_t prsubset;
 
6016
    size_t notsubset;
 
6017
    size_t notprsubset;
 
6018
    size_t setdiff;
 
6019
    size_t card;
 
6020
    size_t cartesianproduct;
 
6021
    size_t eq;
 
6022
    size_t neq;
 
6023
    size_t leq;
 
6024
    size_t lt;
 
6025
    size_t geq;
 
6026
    size_t gt;
 
6027
    size_t equivalent;
 
6028
    size_t approx;
 
6029
    size_t factorof;
 
6030
    size_t exp;
 
6031
    size_t ln;
 
6032
    size_t log;
 
6033
    size_t logbase;
 
6034
    size_t sin;
 
6035
    size_t cos;
 
6036
    size_t tan;
 
6037
    size_t sec;
 
6038
    size_t csc;
 
6039
    size_t cot;
 
6040
    size_t arcsin;
 
6041
    size_t arccos;
 
6042
    size_t arctan;
 
6043
    size_t arcsec;
 
6044
    size_t arccsc;
 
6045
    size_t arccot;
 
6046
    size_t sinh;
 
6047
    size_t cosh;
 
6048
    size_t tanh;
 
6049
    size_t sech;
 
6050
    size_t csch;
 
6051
    size_t coth;
 
6052
    size_t arccosh;
 
6053
    size_t arccoth;
 
6054
    size_t arccsch;
 
6055
    size_t arcsech;
 
6056
    size_t arcsinh;
 
6057
    size_t arctanh;
 
6058
    size_t _int;
 
6059
    size_t diff;
 
6060
    size_t partialdiff;
 
6061
    size_t limit;
 
6062
    size_t lowlimit;
 
6063
    size_t uplimit;
 
6064
    size_t tendsto;
 
6065
    size_t vector;
 
6066
    size_t matrix;
 
6067
    size_t determinant;
 
6068
    size_t transpose;
 
6069
    size_t selector;
 
6070
    size_t vectorproduct;
 
6071
    size_t scalarproduct;
 
6072
    size_t outerproduct;
 
6073
    size_t divergence;
 
6074
    size_t grad;
 
6075
    size_t curl;
 
6076
    size_t laplacian;
 
6077
    size_t mean;
 
6078
    size_t sdev;
 
6079
    size_t variance;
 
6080
    size_t median;
 
6081
    size_t mode;
 
6082
    size_t moment;
 
6083
    size_t momentabout;
 
6084
    size_t apply;
 
6085
    size_t interval;
 
6086
    size_t inverse;
 
6087
    size_t condition;
 
6088
    size_t declare;
 
6089
    size_t lambda;
 
6090
    size_t piecewise;
 
6091
    size_t bvar;
 
6092
    size_t degree;
 
6093
    size_t semantics;
 
6094
};
 
6095
 
 
6096
ParserError::ErrorType validate__declare( ParserString value );
 
6097
ParserError::ErrorType validate__declare( const ParserChar* value, size_t length );
 
6098
ParserError::ErrorType validate__declare__stream( const ParserChar* value, size_t length );
 
6099
ParserError::ErrorType validate__declare__streamEnd( const ParserChar* value, size_t length );
 
6100
 
 
6101
struct declare__ValidationData
 
6102
{
 
6103
    size_t validation_current_state;
 
6104
    size_t cn;
 
6105
    size_t ci;
 
6106
    size_t csymbol;
 
6107
    size_t abs;
 
6108
    size_t conjugate;
 
6109
    size_t factorial;
 
6110
    size_t arg;
 
6111
    size_t real;
 
6112
    size_t imaginary;
 
6113
    size_t floor;
 
6114
    size_t ceiling;
 
6115
    size_t quotient;
 
6116
    size_t divide;
 
6117
    size_t rem;
 
6118
    size_t minus;
 
6119
    size_t plus;
 
6120
    size_t times;
 
6121
    size_t power;
 
6122
    size_t root;
 
6123
    size_t max;
 
6124
    size_t min;
 
6125
    size_t gcd;
 
6126
    size_t lcm;
 
6127
    size_t sum;
 
6128
    size_t product;
 
6129
    size_t compose;
 
6130
    size_t domain;
 
6131
    size_t codomain;
 
6132
    size_t image;
 
6133
    size_t domainofapplication;
 
6134
    size_t ident;
 
6135
    size_t _and;
 
6136
    size_t _or;
 
6137
    size_t _xor;
 
6138
    size_t _not;
 
6139
    size_t exists;
 
6140
    size_t forall;
 
6141
    size_t implies;
 
6142
    size_t naturalnumbers;
 
6143
    size_t primes;
 
6144
    size_t integers;
 
6145
    size_t rationals;
 
6146
    size_t reals;
 
6147
    size_t complexes;
 
6148
    size_t emptyset;
 
6149
    size_t exponentiale;
 
6150
    size_t imaginaryi;
 
6151
    size_t pi;
 
6152
    size_t eulergamma;
 
6153
    size_t _true;
 
6154
    size_t _false;
 
6155
    size_t infinity;
 
6156
    size_t notanumber;
 
6157
    size_t set;
 
6158
    size_t list;
 
6159
    size_t _union;
 
6160
    size_t intersect;
 
6161
    size_t _in;
 
6162
    size_t notin;
 
6163
    size_t subset;
 
6164
    size_t prsubset;
 
6165
    size_t notsubset;
 
6166
    size_t notprsubset;
 
6167
    size_t setdiff;
 
6168
    size_t card;
 
6169
    size_t cartesianproduct;
 
6170
    size_t eq;
 
6171
    size_t neq;
 
6172
    size_t leq;
 
6173
    size_t lt;
 
6174
    size_t geq;
 
6175
    size_t gt;
 
6176
    size_t equivalent;
 
6177
    size_t approx;
 
6178
    size_t factorof;
 
6179
    size_t exp;
 
6180
    size_t ln;
 
6181
    size_t log;
 
6182
    size_t logbase;
 
6183
    size_t sin;
 
6184
    size_t cos;
 
6185
    size_t tan;
 
6186
    size_t sec;
 
6187
    size_t csc;
 
6188
    size_t cot;
 
6189
    size_t arcsin;
 
6190
    size_t arccos;
 
6191
    size_t arctan;
 
6192
    size_t arcsec;
 
6193
    size_t arccsc;
 
6194
    size_t arccot;
 
6195
    size_t sinh;
 
6196
    size_t cosh;
 
6197
    size_t tanh;
 
6198
    size_t sech;
 
6199
    size_t csch;
 
6200
    size_t coth;
 
6201
    size_t arccosh;
 
6202
    size_t arccoth;
 
6203
    size_t arccsch;
 
6204
    size_t arcsech;
 
6205
    size_t arcsinh;
 
6206
    size_t arctanh;
 
6207
    size_t _int;
 
6208
    size_t diff;
 
6209
    size_t partialdiff;
 
6210
    size_t limit;
 
6211
    size_t lowlimit;
 
6212
    size_t uplimit;
 
6213
    size_t tendsto;
 
6214
    size_t vector;
 
6215
    size_t matrix;
 
6216
    size_t determinant;
 
6217
    size_t transpose;
 
6218
    size_t selector;
 
6219
    size_t vectorproduct;
 
6220
    size_t scalarproduct;
 
6221
    size_t outerproduct;
 
6222
    size_t divergence;
 
6223
    size_t grad;
 
6224
    size_t curl;
 
6225
    size_t laplacian;
 
6226
    size_t mean;
 
6227
    size_t sdev;
 
6228
    size_t variance;
 
6229
    size_t median;
 
6230
    size_t mode;
 
6231
    size_t moment;
 
6232
    size_t momentabout;
 
6233
    size_t apply;
 
6234
    size_t interval;
 
6235
    size_t inverse;
 
6236
    size_t condition;
 
6237
    size_t declare;
 
6238
    size_t lambda;
 
6239
    size_t piecewise;
 
6240
    size_t bvar;
 
6241
    size_t degree;
 
6242
    size_t semantics;
 
6243
};
 
6244
 
 
6245
struct lambda__ValidationData
 
6246
{
 
6247
    size_t validation_current_state;
 
6248
    size_t cn;
 
6249
    size_t ci;
 
6250
    size_t csymbol;
 
6251
    size_t abs;
 
6252
    size_t conjugate;
 
6253
    size_t factorial;
 
6254
    size_t arg;
 
6255
    size_t real;
 
6256
    size_t imaginary;
 
6257
    size_t floor;
 
6258
    size_t ceiling;
 
6259
    size_t quotient;
 
6260
    size_t divide;
 
6261
    size_t rem;
 
6262
    size_t minus;
 
6263
    size_t plus;
 
6264
    size_t times;
 
6265
    size_t power;
 
6266
    size_t root;
 
6267
    size_t max;
 
6268
    size_t min;
 
6269
    size_t gcd;
 
6270
    size_t lcm;
 
6271
    size_t sum;
 
6272
    size_t product;
 
6273
    size_t compose;
 
6274
    size_t domain;
 
6275
    size_t codomain;
 
6276
    size_t image;
 
6277
    size_t domainofapplication;
 
6278
    size_t ident;
 
6279
    size_t _and;
 
6280
    size_t _or;
 
6281
    size_t _xor;
 
6282
    size_t _not;
 
6283
    size_t exists;
 
6284
    size_t forall;
 
6285
    size_t implies;
 
6286
    size_t naturalnumbers;
 
6287
    size_t primes;
 
6288
    size_t integers;
 
6289
    size_t rationals;
 
6290
    size_t reals;
 
6291
    size_t complexes;
 
6292
    size_t emptyset;
 
6293
    size_t exponentiale;
 
6294
    size_t imaginaryi;
 
6295
    size_t pi;
 
6296
    size_t eulergamma;
 
6297
    size_t _true;
 
6298
    size_t _false;
 
6299
    size_t infinity;
 
6300
    size_t notanumber;
 
6301
    size_t set;
 
6302
    size_t list;
 
6303
    size_t _union;
 
6304
    size_t intersect;
 
6305
    size_t _in;
 
6306
    size_t notin;
 
6307
    size_t subset;
 
6308
    size_t prsubset;
 
6309
    size_t notsubset;
 
6310
    size_t notprsubset;
 
6311
    size_t setdiff;
 
6312
    size_t card;
 
6313
    size_t cartesianproduct;
 
6314
    size_t eq;
 
6315
    size_t neq;
 
6316
    size_t leq;
 
6317
    size_t lt;
 
6318
    size_t geq;
 
6319
    size_t gt;
 
6320
    size_t equivalent;
 
6321
    size_t approx;
 
6322
    size_t factorof;
 
6323
    size_t exp;
 
6324
    size_t ln;
 
6325
    size_t log;
 
6326
    size_t logbase;
 
6327
    size_t sin;
 
6328
    size_t cos;
 
6329
    size_t tan;
 
6330
    size_t sec;
 
6331
    size_t csc;
 
6332
    size_t cot;
 
6333
    size_t arcsin;
 
6334
    size_t arccos;
 
6335
    size_t arctan;
 
6336
    size_t arcsec;
 
6337
    size_t arccsc;
 
6338
    size_t arccot;
 
6339
    size_t sinh;
 
6340
    size_t cosh;
 
6341
    size_t tanh;
 
6342
    size_t sech;
 
6343
    size_t csch;
 
6344
    size_t coth;
 
6345
    size_t arccosh;
 
6346
    size_t arccoth;
 
6347
    size_t arccsch;
 
6348
    size_t arcsech;
 
6349
    size_t arcsinh;
 
6350
    size_t arctanh;
 
6351
    size_t _int;
 
6352
    size_t diff;
 
6353
    size_t partialdiff;
 
6354
    size_t limit;
 
6355
    size_t lowlimit;
 
6356
    size_t uplimit;
 
6357
    size_t tendsto;
 
6358
    size_t vector;
 
6359
    size_t matrix;
 
6360
    size_t determinant;
 
6361
    size_t transpose;
 
6362
    size_t selector;
 
6363
    size_t vectorproduct;
 
6364
    size_t scalarproduct;
 
6365
    size_t outerproduct;
 
6366
    size_t divergence;
 
6367
    size_t grad;
 
6368
    size_t curl;
 
6369
    size_t laplacian;
 
6370
    size_t mean;
 
6371
    size_t sdev;
 
6372
    size_t variance;
 
6373
    size_t median;
 
6374
    size_t mode;
 
6375
    size_t moment;
 
6376
    size_t momentabout;
 
6377
    size_t apply;
 
6378
    size_t interval;
 
6379
    size_t inverse;
 
6380
    size_t condition;
 
6381
    size_t declare;
 
6382
    size_t lambda;
 
6383
    size_t piecewise;
 
6384
    size_t bvar;
 
6385
    size_t degree;
 
6386
    size_t semantics;
 
6387
};
 
6388
 
 
6389
struct piecewise__ValidationData
 
6390
{
 
6391
    size_t validation_current_state;
 
6392
    size_t piece;
 
6393
    size_t otherwise;
 
6394
};
 
6395
 
 
6396
struct piece__ValidationData
 
6397
{
 
6398
    size_t validation_current_state;
 
6399
    size_t cn;
 
6400
    size_t ci;
 
6401
    size_t csymbol;
 
6402
    size_t abs;
 
6403
    size_t conjugate;
 
6404
    size_t factorial;
 
6405
    size_t arg;
 
6406
    size_t real;
 
6407
    size_t imaginary;
 
6408
    size_t floor;
 
6409
    size_t ceiling;
 
6410
    size_t quotient;
 
6411
    size_t divide;
 
6412
    size_t rem;
 
6413
    size_t minus;
 
6414
    size_t plus;
 
6415
    size_t times;
 
6416
    size_t power;
 
6417
    size_t root;
 
6418
    size_t max;
 
6419
    size_t min;
 
6420
    size_t gcd;
 
6421
    size_t lcm;
 
6422
    size_t sum;
 
6423
    size_t product;
 
6424
    size_t compose;
 
6425
    size_t domain;
 
6426
    size_t codomain;
 
6427
    size_t image;
 
6428
    size_t domainofapplication;
 
6429
    size_t ident;
 
6430
    size_t _and;
 
6431
    size_t _or;
 
6432
    size_t _xor;
 
6433
    size_t _not;
 
6434
    size_t exists;
 
6435
    size_t forall;
 
6436
    size_t implies;
 
6437
    size_t naturalnumbers;
 
6438
    size_t primes;
 
6439
    size_t integers;
 
6440
    size_t rationals;
 
6441
    size_t reals;
 
6442
    size_t complexes;
 
6443
    size_t emptyset;
 
6444
    size_t exponentiale;
 
6445
    size_t imaginaryi;
 
6446
    size_t pi;
 
6447
    size_t eulergamma;
 
6448
    size_t _true;
 
6449
    size_t _false;
 
6450
    size_t infinity;
 
6451
    size_t notanumber;
 
6452
    size_t set;
 
6453
    size_t list;
 
6454
    size_t _union;
 
6455
    size_t intersect;
 
6456
    size_t _in;
 
6457
    size_t notin;
 
6458
    size_t subset;
 
6459
    size_t prsubset;
 
6460
    size_t notsubset;
 
6461
    size_t notprsubset;
 
6462
    size_t setdiff;
 
6463
    size_t card;
 
6464
    size_t cartesianproduct;
 
6465
    size_t eq;
 
6466
    size_t neq;
 
6467
    size_t leq;
 
6468
    size_t lt;
 
6469
    size_t geq;
 
6470
    size_t gt;
 
6471
    size_t equivalent;
 
6472
    size_t approx;
 
6473
    size_t factorof;
 
6474
    size_t exp;
 
6475
    size_t ln;
 
6476
    size_t log;
 
6477
    size_t logbase;
 
6478
    size_t sin;
 
6479
    size_t cos;
 
6480
    size_t tan;
 
6481
    size_t sec;
 
6482
    size_t csc;
 
6483
    size_t cot;
 
6484
    size_t arcsin;
 
6485
    size_t arccos;
 
6486
    size_t arctan;
 
6487
    size_t arcsec;
 
6488
    size_t arccsc;
 
6489
    size_t arccot;
 
6490
    size_t sinh;
 
6491
    size_t cosh;
 
6492
    size_t tanh;
 
6493
    size_t sech;
 
6494
    size_t csch;
 
6495
    size_t coth;
 
6496
    size_t arccosh;
 
6497
    size_t arccoth;
 
6498
    size_t arccsch;
 
6499
    size_t arcsech;
 
6500
    size_t arcsinh;
 
6501
    size_t arctanh;
 
6502
    size_t _int;
 
6503
    size_t diff;
 
6504
    size_t partialdiff;
 
6505
    size_t limit;
 
6506
    size_t lowlimit;
 
6507
    size_t uplimit;
 
6508
    size_t tendsto;
 
6509
    size_t vector;
 
6510
    size_t matrix;
 
6511
    size_t determinant;
 
6512
    size_t transpose;
 
6513
    size_t selector;
 
6514
    size_t vectorproduct;
 
6515
    size_t scalarproduct;
 
6516
    size_t outerproduct;
 
6517
    size_t divergence;
 
6518
    size_t grad;
 
6519
    size_t curl;
 
6520
    size_t laplacian;
 
6521
    size_t mean;
 
6522
    size_t sdev;
 
6523
    size_t variance;
 
6524
    size_t median;
 
6525
    size_t mode;
 
6526
    size_t moment;
 
6527
    size_t momentabout;
 
6528
    size_t apply;
 
6529
    size_t interval;
 
6530
    size_t inverse;
 
6531
    size_t condition;
 
6532
    size_t declare;
 
6533
    size_t lambda;
 
6534
    size_t piecewise;
 
6535
    size_t bvar;
 
6536
    size_t degree;
 
6537
    size_t semantics;
 
6538
};
 
6539
 
 
6540
struct bvar__ValidationData
 
6541
{
 
6542
    size_t validation_current_state;
 
6543
    size_t cn;
 
6544
    size_t ci;
 
6545
    size_t csymbol;
 
6546
    size_t abs;
 
6547
    size_t conjugate;
 
6548
    size_t factorial;
 
6549
    size_t arg;
 
6550
    size_t real;
 
6551
    size_t imaginary;
 
6552
    size_t floor;
 
6553
    size_t ceiling;
 
6554
    size_t quotient;
 
6555
    size_t divide;
 
6556
    size_t rem;
 
6557
    size_t minus;
 
6558
    size_t plus;
 
6559
    size_t times;
 
6560
    size_t power;
 
6561
    size_t root;
 
6562
    size_t max;
 
6563
    size_t min;
 
6564
    size_t gcd;
 
6565
    size_t lcm;
 
6566
    size_t sum;
 
6567
    size_t product;
 
6568
    size_t compose;
 
6569
    size_t domain;
 
6570
    size_t codomain;
 
6571
    size_t image;
 
6572
    size_t domainofapplication;
 
6573
    size_t ident;
 
6574
    size_t _and;
 
6575
    size_t _or;
 
6576
    size_t _xor;
 
6577
    size_t _not;
 
6578
    size_t exists;
 
6579
    size_t forall;
 
6580
    size_t implies;
 
6581
    size_t naturalnumbers;
 
6582
    size_t primes;
 
6583
    size_t integers;
 
6584
    size_t rationals;
 
6585
    size_t reals;
 
6586
    size_t complexes;
 
6587
    size_t emptyset;
 
6588
    size_t exponentiale;
 
6589
    size_t imaginaryi;
 
6590
    size_t pi;
 
6591
    size_t eulergamma;
 
6592
    size_t _true;
 
6593
    size_t _false;
 
6594
    size_t infinity;
 
6595
    size_t notanumber;
 
6596
    size_t set;
 
6597
    size_t list;
 
6598
    size_t _union;
 
6599
    size_t intersect;
 
6600
    size_t _in;
 
6601
    size_t notin;
 
6602
    size_t subset;
 
6603
    size_t prsubset;
 
6604
    size_t notsubset;
 
6605
    size_t notprsubset;
 
6606
    size_t setdiff;
 
6607
    size_t card;
 
6608
    size_t cartesianproduct;
 
6609
    size_t eq;
 
6610
    size_t neq;
 
6611
    size_t leq;
 
6612
    size_t lt;
 
6613
    size_t geq;
 
6614
    size_t gt;
 
6615
    size_t equivalent;
 
6616
    size_t approx;
 
6617
    size_t factorof;
 
6618
    size_t exp;
 
6619
    size_t ln;
 
6620
    size_t log;
 
6621
    size_t logbase;
 
6622
    size_t sin;
 
6623
    size_t cos;
 
6624
    size_t tan;
 
6625
    size_t sec;
 
6626
    size_t csc;
 
6627
    size_t cot;
 
6628
    size_t arcsin;
 
6629
    size_t arccos;
 
6630
    size_t arctan;
 
6631
    size_t arcsec;
 
6632
    size_t arccsc;
 
6633
    size_t arccot;
 
6634
    size_t sinh;
 
6635
    size_t cosh;
 
6636
    size_t tanh;
 
6637
    size_t sech;
 
6638
    size_t csch;
 
6639
    size_t coth;
 
6640
    size_t arccosh;
 
6641
    size_t arccoth;
 
6642
    size_t arccsch;
 
6643
    size_t arcsech;
 
6644
    size_t arcsinh;
 
6645
    size_t arctanh;
 
6646
    size_t _int;
 
6647
    size_t diff;
 
6648
    size_t partialdiff;
 
6649
    size_t limit;
 
6650
    size_t lowlimit;
 
6651
    size_t uplimit;
 
6652
    size_t tendsto;
 
6653
    size_t vector;
 
6654
    size_t matrix;
 
6655
    size_t determinant;
 
6656
    size_t transpose;
 
6657
    size_t selector;
 
6658
    size_t vectorproduct;
 
6659
    size_t scalarproduct;
 
6660
    size_t outerproduct;
 
6661
    size_t divergence;
 
6662
    size_t grad;
 
6663
    size_t curl;
 
6664
    size_t laplacian;
 
6665
    size_t mean;
 
6666
    size_t sdev;
 
6667
    size_t variance;
 
6668
    size_t median;
 
6669
    size_t mode;
 
6670
    size_t moment;
 
6671
    size_t momentabout;
 
6672
    size_t apply;
 
6673
    size_t interval;
 
6674
    size_t inverse;
 
6675
    size_t condition;
 
6676
    size_t declare;
 
6677
    size_t lambda;
 
6678
    size_t piecewise;
 
6679
    size_t bvar;
 
6680
    size_t degree;
 
6681
    size_t semantics;
 
6682
};
 
6683
 
 
6684
struct degree__ValidationData
 
6685
{
 
6686
    size_t validation_current_state;
 
6687
    size_t cn;
 
6688
    size_t ci;
 
6689
    size_t csymbol;
 
6690
    size_t abs;
 
6691
    size_t conjugate;
 
6692
    size_t factorial;
 
6693
    size_t arg;
 
6694
    size_t real;
 
6695
    size_t imaginary;
 
6696
    size_t floor;
 
6697
    size_t ceiling;
 
6698
    size_t quotient;
 
6699
    size_t divide;
 
6700
    size_t rem;
 
6701
    size_t minus;
 
6702
    size_t plus;
 
6703
    size_t times;
 
6704
    size_t power;
 
6705
    size_t root;
 
6706
    size_t max;
 
6707
    size_t min;
 
6708
    size_t gcd;
 
6709
    size_t lcm;
 
6710
    size_t sum;
 
6711
    size_t product;
 
6712
    size_t compose;
 
6713
    size_t domain;
 
6714
    size_t codomain;
 
6715
    size_t image;
 
6716
    size_t domainofapplication;
 
6717
    size_t ident;
 
6718
    size_t _and;
 
6719
    size_t _or;
 
6720
    size_t _xor;
 
6721
    size_t _not;
 
6722
    size_t exists;
 
6723
    size_t forall;
 
6724
    size_t implies;
 
6725
    size_t naturalnumbers;
 
6726
    size_t primes;
 
6727
    size_t integers;
 
6728
    size_t rationals;
 
6729
    size_t reals;
 
6730
    size_t complexes;
 
6731
    size_t emptyset;
 
6732
    size_t exponentiale;
 
6733
    size_t imaginaryi;
 
6734
    size_t pi;
 
6735
    size_t eulergamma;
 
6736
    size_t _true;
 
6737
    size_t _false;
 
6738
    size_t infinity;
 
6739
    size_t notanumber;
 
6740
    size_t set;
 
6741
    size_t list;
 
6742
    size_t _union;
 
6743
    size_t intersect;
 
6744
    size_t _in;
 
6745
    size_t notin;
 
6746
    size_t subset;
 
6747
    size_t prsubset;
 
6748
    size_t notsubset;
 
6749
    size_t notprsubset;
 
6750
    size_t setdiff;
 
6751
    size_t card;
 
6752
    size_t cartesianproduct;
 
6753
    size_t eq;
 
6754
    size_t neq;
 
6755
    size_t leq;
 
6756
    size_t lt;
 
6757
    size_t geq;
 
6758
    size_t gt;
 
6759
    size_t equivalent;
 
6760
    size_t approx;
 
6761
    size_t factorof;
 
6762
    size_t exp;
 
6763
    size_t ln;
 
6764
    size_t log;
 
6765
    size_t logbase;
 
6766
    size_t sin;
 
6767
    size_t cos;
 
6768
    size_t tan;
 
6769
    size_t sec;
 
6770
    size_t csc;
 
6771
    size_t cot;
 
6772
    size_t arcsin;
 
6773
    size_t arccos;
 
6774
    size_t arctan;
 
6775
    size_t arcsec;
 
6776
    size_t arccsc;
 
6777
    size_t arccot;
 
6778
    size_t sinh;
 
6779
    size_t cosh;
 
6780
    size_t tanh;
 
6781
    size_t sech;
 
6782
    size_t csch;
 
6783
    size_t coth;
 
6784
    size_t arccosh;
 
6785
    size_t arccoth;
 
6786
    size_t arccsch;
 
6787
    size_t arcsech;
 
6788
    size_t arcsinh;
 
6789
    size_t arctanh;
 
6790
    size_t _int;
 
6791
    size_t diff;
 
6792
    size_t partialdiff;
 
6793
    size_t limit;
 
6794
    size_t lowlimit;
 
6795
    size_t uplimit;
 
6796
    size_t tendsto;
 
6797
    size_t vector;
 
6798
    size_t matrix;
 
6799
    size_t determinant;
 
6800
    size_t transpose;
 
6801
    size_t selector;
 
6802
    size_t vectorproduct;
 
6803
    size_t scalarproduct;
 
6804
    size_t outerproduct;
 
6805
    size_t divergence;
 
6806
    size_t grad;
 
6807
    size_t curl;
 
6808
    size_t laplacian;
 
6809
    size_t mean;
 
6810
    size_t sdev;
 
6811
    size_t variance;
 
6812
    size_t median;
 
6813
    size_t mode;
 
6814
    size_t moment;
 
6815
    size_t momentabout;
 
6816
    size_t apply;
 
6817
    size_t interval;
 
6818
    size_t inverse;
 
6819
    size_t condition;
 
6820
    size_t declare;
 
6821
    size_t lambda;
 
6822
    size_t piecewise;
 
6823
    size_t bvar;
 
6824
    size_t degree;
 
6825
    size_t semantics;
 
6826
};
 
6827
 
 
6828
struct semantics__ValidationData
 
6829
{
 
6830
    size_t validation_current_state;
 
6831
    size_t cn;
 
6832
    size_t ci;
 
6833
    size_t csymbol;
 
6834
    size_t abs;
 
6835
    size_t conjugate;
 
6836
    size_t factorial;
 
6837
    size_t arg;
 
6838
    size_t real;
 
6839
    size_t imaginary;
 
6840
    size_t floor;
 
6841
    size_t ceiling;
 
6842
    size_t quotient;
 
6843
    size_t divide;
 
6844
    size_t rem;
 
6845
    size_t minus;
 
6846
    size_t plus;
 
6847
    size_t times;
 
6848
    size_t power;
 
6849
    size_t root;
 
6850
    size_t max;
 
6851
    size_t min;
 
6852
    size_t gcd;
 
6853
    size_t lcm;
 
6854
    size_t sum;
 
6855
    size_t product;
 
6856
    size_t compose;
 
6857
    size_t domain;
 
6858
    size_t codomain;
 
6859
    size_t image;
 
6860
    size_t domainofapplication;
 
6861
    size_t ident;
 
6862
    size_t _and;
 
6863
    size_t _or;
 
6864
    size_t _xor;
 
6865
    size_t _not;
 
6866
    size_t exists;
 
6867
    size_t forall;
 
6868
    size_t implies;
 
6869
    size_t naturalnumbers;
 
6870
    size_t primes;
 
6871
    size_t integers;
 
6872
    size_t rationals;
 
6873
    size_t reals;
 
6874
    size_t complexes;
 
6875
    size_t emptyset;
 
6876
    size_t exponentiale;
 
6877
    size_t imaginaryi;
 
6878
    size_t pi;
 
6879
    size_t eulergamma;
 
6880
    size_t _true;
 
6881
    size_t _false;
 
6882
    size_t infinity;
 
6883
    size_t notanumber;
 
6884
    size_t set;
 
6885
    size_t list;
 
6886
    size_t _union;
 
6887
    size_t intersect;
 
6888
    size_t _in;
 
6889
    size_t notin;
 
6890
    size_t subset;
 
6891
    size_t prsubset;
 
6892
    size_t notsubset;
 
6893
    size_t notprsubset;
 
6894
    size_t setdiff;
 
6895
    size_t card;
 
6896
    size_t cartesianproduct;
 
6897
    size_t eq;
 
6898
    size_t neq;
 
6899
    size_t leq;
 
6900
    size_t lt;
 
6901
    size_t geq;
 
6902
    size_t gt;
 
6903
    size_t equivalent;
 
6904
    size_t approx;
 
6905
    size_t factorof;
 
6906
    size_t exp;
 
6907
    size_t ln;
 
6908
    size_t log;
 
6909
    size_t logbase;
 
6910
    size_t sin;
 
6911
    size_t cos;
 
6912
    size_t tan;
 
6913
    size_t sec;
 
6914
    size_t csc;
 
6915
    size_t cot;
 
6916
    size_t arcsin;
 
6917
    size_t arccos;
 
6918
    size_t arctan;
 
6919
    size_t arcsec;
 
6920
    size_t arccsc;
 
6921
    size_t arccot;
 
6922
    size_t sinh;
 
6923
    size_t cosh;
 
6924
    size_t tanh;
 
6925
    size_t sech;
 
6926
    size_t csch;
 
6927
    size_t coth;
 
6928
    size_t arccosh;
 
6929
    size_t arccoth;
 
6930
    size_t arccsch;
 
6931
    size_t arcsech;
 
6932
    size_t arcsinh;
 
6933
    size_t arctanh;
 
6934
    size_t _int;
 
6935
    size_t diff;
 
6936
    size_t partialdiff;
 
6937
    size_t limit;
 
6938
    size_t lowlimit;
 
6939
    size_t uplimit;
 
6940
    size_t tendsto;
 
6941
    size_t vector;
 
6942
    size_t matrix;
 
6943
    size_t determinant;
 
6944
    size_t transpose;
 
6945
    size_t selector;
 
6946
    size_t vectorproduct;
 
6947
    size_t scalarproduct;
 
6948
    size_t outerproduct;
 
6949
    size_t divergence;
 
6950
    size_t grad;
 
6951
    size_t curl;
 
6952
    size_t laplacian;
 
6953
    size_t mean;
 
6954
    size_t sdev;
 
6955
    size_t variance;
 
6956
    size_t median;
 
6957
    size_t mode;
 
6958
    size_t moment;
 
6959
    size_t momentabout;
 
6960
    size_t apply;
 
6961
    size_t interval;
 
6962
    size_t inverse;
 
6963
    size_t condition;
 
6964
    size_t declare;
 
6965
    size_t lambda;
 
6966
    size_t piecewise;
 
6967
    size_t bvar;
 
6968
    size_t degree;
 
6969
    size_t semantics;
 
6970
    size_t annotation;
 
6971
    size_t annotation_xml;
 
6972
};
 
6973
 
 
6974
struct annotation__ValidationData
 
6975
{
 
6976
    size_t validationWholeSize;
 
6977
};
 
6978
 
 
6979
struct annotation_xml__ValidationData
 
6980
{
 
6981
    size_t _wildcard;
 
6982
};
 
6983
 
 
6984
struct otherwise__ValidationData
 
6985
{
 
6986
    size_t validation_current_state;
 
6987
    size_t cn;
 
6988
    size_t ci;
 
6989
    size_t csymbol;
 
6990
    size_t abs;
 
6991
    size_t conjugate;
 
6992
    size_t factorial;
 
6993
    size_t arg;
 
6994
    size_t real;
 
6995
    size_t imaginary;
 
6996
    size_t floor;
 
6997
    size_t ceiling;
 
6998
    size_t quotient;
 
6999
    size_t divide;
 
7000
    size_t rem;
 
7001
    size_t minus;
 
7002
    size_t plus;
 
7003
    size_t times;
 
7004
    size_t power;
 
7005
    size_t root;
 
7006
    size_t max;
 
7007
    size_t min;
 
7008
    size_t gcd;
 
7009
    size_t lcm;
 
7010
    size_t sum;
 
7011
    size_t product;
 
7012
    size_t compose;
 
7013
    size_t domain;
 
7014
    size_t codomain;
 
7015
    size_t image;
 
7016
    size_t domainofapplication;
 
7017
    size_t ident;
 
7018
    size_t _and;
 
7019
    size_t _or;
 
7020
    size_t _xor;
 
7021
    size_t _not;
 
7022
    size_t exists;
 
7023
    size_t forall;
 
7024
    size_t implies;
 
7025
    size_t naturalnumbers;
 
7026
    size_t primes;
 
7027
    size_t integers;
 
7028
    size_t rationals;
 
7029
    size_t reals;
 
7030
    size_t complexes;
 
7031
    size_t emptyset;
 
7032
    size_t exponentiale;
 
7033
    size_t imaginaryi;
 
7034
    size_t pi;
 
7035
    size_t eulergamma;
 
7036
    size_t _true;
 
7037
    size_t _false;
 
7038
    size_t infinity;
 
7039
    size_t notanumber;
 
7040
    size_t set;
 
7041
    size_t list;
 
7042
    size_t _union;
 
7043
    size_t intersect;
 
7044
    size_t _in;
 
7045
    size_t notin;
 
7046
    size_t subset;
 
7047
    size_t prsubset;
 
7048
    size_t notsubset;
 
7049
    size_t notprsubset;
 
7050
    size_t setdiff;
 
7051
    size_t card;
 
7052
    size_t cartesianproduct;
 
7053
    size_t eq;
 
7054
    size_t neq;
 
7055
    size_t leq;
 
7056
    size_t lt;
 
7057
    size_t geq;
 
7058
    size_t gt;
 
7059
    size_t equivalent;
 
7060
    size_t approx;
 
7061
    size_t factorof;
 
7062
    size_t exp;
 
7063
    size_t ln;
 
7064
    size_t log;
 
7065
    size_t logbase;
 
7066
    size_t sin;
 
7067
    size_t cos;
 
7068
    size_t tan;
 
7069
    size_t sec;
 
7070
    size_t csc;
 
7071
    size_t cot;
 
7072
    size_t arcsin;
 
7073
    size_t arccos;
 
7074
    size_t arctan;
 
7075
    size_t arcsec;
 
7076
    size_t arccsc;
 
7077
    size_t arccot;
 
7078
    size_t sinh;
 
7079
    size_t cosh;
 
7080
    size_t tanh;
 
7081
    size_t sech;
 
7082
    size_t csch;
 
7083
    size_t coth;
 
7084
    size_t arccosh;
 
7085
    size_t arccoth;
 
7086
    size_t arccsch;
 
7087
    size_t arcsech;
 
7088
    size_t arcsinh;
 
7089
    size_t arctanh;
 
7090
    size_t _int;
 
7091
    size_t diff;
 
7092
    size_t partialdiff;
 
7093
    size_t limit;
 
7094
    size_t lowlimit;
 
7095
    size_t uplimit;
 
7096
    size_t tendsto;
 
7097
    size_t vector;
 
7098
    size_t matrix;
 
7099
    size_t determinant;
 
7100
    size_t transpose;
 
7101
    size_t selector;
 
7102
    size_t vectorproduct;
 
7103
    size_t scalarproduct;
 
7104
    size_t outerproduct;
 
7105
    size_t divergence;
 
7106
    size_t grad;
 
7107
    size_t curl;
 
7108
    size_t laplacian;
 
7109
    size_t mean;
 
7110
    size_t sdev;
 
7111
    size_t variance;
 
7112
    size_t median;
 
7113
    size_t mode;
 
7114
    size_t moment;
 
7115
    size_t momentabout;
 
7116
    size_t apply;
 
7117
    size_t interval;
 
7118
    size_t inverse;
 
7119
    size_t condition;
 
7120
    size_t declare;
 
7121
    size_t lambda;
 
7122
    size_t piecewise;
 
7123
    size_t bvar;
 
7124
    size_t degree;
 
7125
    size_t semantics;
 
7126
};
 
7127
 
 
7128
struct library_articulated_systems__ValidationData
 
7129
{
 
7130
    size_t asset;
 
7131
    size_t articulated_system;
 
7132
    size_t extra;
 
7133
};
 
7134
 
 
7135
struct articulated_system__ValidationData
 
7136
{
 
7137
    size_t validation_current_state;
 
7138
    size_t asset;
 
7139
    size_t kinematics;
 
7140
    size_t motion;
 
7141
    size_t extra;
 
7142
};
 
7143
 
 
7144
struct kinematics__ValidationData
 
7145
{
 
7146
    size_t instance_kinematics_model;
 
7147
    size_t technique_common;
 
7148
    size_t technique;
 
7149
    size_t extra;
 
7150
};
 
7151
 
 
7152
struct instance_kinematics_model__ValidationData
 
7153
{
 
7154
    size_t bind;
 
7155
    size_t newparam;
 
7156
    size_t setparam;
 
7157
    size_t extra;
 
7158
};
 
7159
 
 
7160
struct bind____kinematics_bind_type__ValidationData
 
7161
{
 
7162
    size_t param;
 
7163
    size_t _bool;
 
7164
    size_t _float;
 
7165
    size_t _int;
 
7166
    size_t SIDREF;
 
7167
};
 
7168
 
 
7169
struct setparam____kinematics_setparam_type__ValidationData
 
7170
{
 
7171
    size_t _float;
 
7172
    size_t _int;
 
7173
    size_t SIDREF;
 
7174
    size_t _bool;
 
7175
    size_t connect_param;
 
7176
};
 
7177
 
 
7178
struct technique_common____kinematics_technique_type__ValidationData
 
7179
{
 
7180
    size_t axis_info;
 
7181
    size_t frame_origin;
 
7182
    size_t frame_tip;
 
7183
    size_t frame_tcp;
 
7184
    size_t frame_object;
 
7185
};
 
7186
 
 
7187
struct axis_info____kinematics_axis_info_type__ValidationData
 
7188
{
 
7189
    size_t validation_current_state;
 
7190
    size_t newparam;
 
7191
    size_t active;
 
7192
    size_t locked;
 
7193
    size_t index;
 
7194
    size_t limits;
 
7195
    size_t formula;
 
7196
    size_t instance_formula;
 
7197
};
 
7198
 
 
7199
struct active__ValidationData
 
7200
{
 
7201
    size_t _bool;
 
7202
    size_t param;
 
7203
};
 
7204
 
 
7205
struct index__ValidationData
 
7206
{
 
7207
    size_t _int;
 
7208
    size_t param;
 
7209
};
 
7210
 
 
7211
struct limits____kinematics_limits_type__ValidationData
 
7212
{
 
7213
    size_t min;
 
7214
    size_t max;
 
7215
};
 
7216
 
 
7217
struct frame_origin__ValidationData
 
7218
{
 
7219
    size_t translate;
 
7220
    size_t rotate;
 
7221
};
 
7222
 
 
7223
struct motion__ValidationData
 
7224
{
 
7225
    size_t instance_articulated_system;
 
7226
    size_t technique_common;
 
7227
    size_t technique;
 
7228
    size_t extra;
 
7229
};
 
7230
 
 
7231
struct instance_articulated_system__ValidationData
 
7232
{
 
7233
    size_t bind;
 
7234
    size_t setparam;
 
7235
    size_t newparam;
 
7236
    size_t extra;
 
7237
};
 
7238
 
 
7239
struct technique_common____motion_technique_type__ValidationData
 
7240
{
 
7241
    size_t axis_info;
 
7242
    size_t effector_info;
 
7243
};
 
7244
 
 
7245
struct axis_info____motion_axis_info_type__ValidationData
 
7246
{
 
7247
    size_t bind;
 
7248
    size_t newparam;
 
7249
    size_t setparam;
 
7250
    size_t speed;
 
7251
    size_t acceleration;
 
7252
    size_t deceleration;
 
7253
    size_t jerk;
 
7254
};
 
7255
 
 
7256
struct effector_info__ValidationData
 
7257
{
 
7258
    size_t bind;
 
7259
    size_t newparam;
 
7260
    size_t setparam;
 
7261
    size_t speed;
 
7262
    size_t acceleration;
 
7263
    size_t deceleration;
 
7264
    size_t jerk;
 
7265
};
 
7266
 
 
7267
struct speed____common_float2_or_param_type__ValidationData
 
7268
{
 
7269
    size_t float2;
 
7270
    size_t param;
 
7271
};
 
7272
 
 
7273
struct library_kinematics_scenes__ValidationData
 
7274
{
 
7275
    size_t asset;
 
7276
    size_t kinematics_scene;
 
7277
    size_t extra;
 
7278
};
 
7279
 
 
7280
struct kinematics_scene__ValidationData
 
7281
{
 
7282
    size_t asset;
 
7283
    size_t instance_kinematics_model;
 
7284
    size_t instance_articulated_system;
 
7285
    size_t extra;
 
7286
};
 
7287
 
 
7288
struct library_formulas__ValidationData
 
7289
{
 
7290
    size_t asset;
 
7291
    size_t formula;
 
7292
    size_t extra;
 
7293
};
 
7294
 
 
7295
struct scene__ValidationData
 
7296
{
 
7297
    size_t instance_physics_scene;
 
7298
    size_t instance_visual_scene;
 
7299
    size_t instance_kinematics_scene;
 
7300
    size_t extra;
 
7301
};
 
7302
 
 
7303
struct instance_kinematics_scene__ValidationData
 
7304
{
 
7305
    size_t asset;
 
7306
    size_t newparam;
 
7307
    size_t setparam;
 
7308
    size_t bind_kinematics_model;
 
7309
    size_t bind_joint_axis;
 
7310
    size_t extra;
 
7311
};
 
7312
 
 
7313
struct bind_kinematics_model__ValidationData
 
7314
{
 
7315
    size_t SIDREF;
 
7316
    size_t param;
 
7317
};
 
7318
 
 
7319
struct bind_joint_axis__ValidationData
 
7320
{
 
7321
    size_t axis;
 
7322
    size_t value;
 
7323
};
 
7324
 
 
7325
struct axis____common_sidref_or_param_type__ValidationData
 
7326
{
 
7327
    size_t SIDREF;
 
7328
    size_t param;
 
7329
};
 
7330
 
 
7331
 
 
7332
 
 
7333
} // namespace
 
7334
#endif