MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
myapi.cpp
1 /*
2  Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
3 
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; version 2 of the License.
7 
8  This program is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  GNU General Public License for more details.
12 
13  You should have received a copy of the GNU General Public License
14  along with this program; if not, write to the Free Software
15  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
16 */
17 /*
18  * myapi.cpp
19  */
20 
21 #include <stdio.h> // not using namespaces yet
22 #include <string.h> // not using namespaces yet
23 
24 #include "myapi.hpp"
25 #include "helpers.hpp"
26 
27 // ---------------------------------------------------------------------------
28 // static initializations
29 // ---------------------------------------------------------------------------
30 
31 int32_t B0::d0s = 20;
32 const int32_t B0::d0sc = -20;
33 
34 int32_t B1::d0s = 30;
35 const int32_t B1::d0sc = -30;
36 
37 A * A::a = NULL;
38 int32_t A::d0s = 10;
39 const int32_t A::d0sc = -10;
40 
41 void B0::init() {
42 }
43 
44 void B0::finit() {
45 }
46 
47 void B1::init() {
48 }
49 
50 void B1::finit() {
51 }
52 
53 void A::init() {
54  //printf(" XXX A::a = %p\n", A::a);
55  assert(!A::a);
56  A::a = new A();
57  //printf(" YYY A::a = %p\n", A::a);
58 }
59 
60 void A::finit() {
61  //printf(" ZZZ A::a = %p\n", A::a);
62  assert(A::a);
63  delete A::a;
64  A::a = NULL;
65 }
66 
67 // ----------------------------------------
68 
69 const C0 * C0::cc = NULL;
70 C0 * C0::c = NULL;
71 
72 const C1 * C1::cc = NULL;
73 C1 * C1::c = NULL;
74 
75 void C0::init() {
76  //printf(" XXX C0::c = %p, C0::cc = %p\n", C0::c, C0::cc);
77  //printf(" XXX C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
78  assert(!C0::c);
79  assert(!C0::cc);
80  assert(C1::c);
81  assert(C1::cc);
82  C0::c = C1::c;
83  C0::cc = C1::cc;
84  //printf(" YYY C0::c = %p, C0::cc = %p\n", C0::c, C0::cc);
85 }
86 
87 void C0::finit() {
88  //printf(" ZZZ C0::c = %p, C0::cc = %p\n", C0::c, C0::cc);
89  assert(C0::c);
90  assert(C0::cc);
91  C0::c = NULL;
92  C0::cc = NULL;
93 }
94 
95 void C1::init() {
96  //printf(" XXX C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
97  assert(!C1::c);
98  assert(!C1::cc);
99  C1::c = new C1();
100  C1::cc = new C1();
101  //printf(" YYY C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
102 }
103 
104 void C1::finit() {
105  //printf(" ZZZ C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
106  assert(C1::c);
107  assert(C1::cc);
108  delete C1::c;
109  delete C1::cc;
110  C1::c = NULL;
111  C1::cc = NULL;
112 }
113 
114 // ----------------------------------------
115 
116 D0 * D0::d = NULL;
117 D1 * D1::d = NULL;
118 D2 * D2::d = NULL;
119 
120 void D0::init() {
121  //printf(" XXX D0::d = %p\n", D0::d);
122  assert(!D0::d);
123  D0::d = new D0();
124  //printf(" YYY D0::d = %p\n", D0::d);
125 }
126 
127 void D0::finit() {
128  //printf(" ZZZ D0::d = %p\n", D0::d);
129  assert(D0::d);
130  delete D0::d;
131  D0::d = NULL;
132 }
133 
134 void D1::init() {
135  //printf(" XXX D1::d = %p\n", D1::d);
136  assert(!D1::d);
137  D1::d = new D1();
138  //printf(" YYY D1::d = %p\n", D1::d);
139 }
140 
141 void D1::finit() {
142  //printf(" ZZZ D1::d = %p\n", D1::d);
143  assert(D1::d);
144  delete D1::d;
145  D1::d = NULL;
146 }
147 
148 void D2::init() {
149  //printf(" XXX D2::d = %p\n", D2::d);
150  assert(!D2::d);
151  D2::d = new D2();
152  //printf(" YYY D2::d = %p\n", D2::d);
153 }
154 
155 void D2::finit() {
156  //printf(" ZZZ D2::d = %p\n", D2::d);
157  assert(D2::d);
158  delete D2::d;
159  D2::d = NULL;
160 }
161 
162 // ----------------------------------------
163 
164 void myapi_init() {
165  // some order dependencies
166  D2::init();
167  D1::init();
168  D0::init();
169  C1::init();
170  C0::init();
171  B1::init();
172  B0::init();
173  A::init();
174 }
175 
176 void myapi_finit() {
177  A::finit();
178  B0::finit();
179  B1::finit();
180  C0::finit();
181  C1::finit();
182  D0::finit();
183  D1::finit();
184  D2::finit();
185 }
186 
187 // ---------------------------------------------------------------------------
188 
189 void f0()
190 {
191  TRACE("void f0()");
192 }
193 
194 // ---------------------------------------------------------------------------
195 
196 static const char * ABC = "ABC";
197 static char abc[4] = { 'a', 'b', 'c', '\0' };
198 
199 const void * s010()
200 {
201  TRACE("const void * s010()");
202  return ABC;
203 }
204 
205 const char * s012()
206 {
207  TRACE("const char * s012()");
208  return ABC;
209 }
210 
211 void * s030()
212 {
213  TRACE("void * s030()");
214  return abc;
215 }
216 
217 char * s032()
218 {
219  TRACE("char * s032()");
220  return abc;
221 }
222 
223 const void * const s050()
224 {
225  TRACE("const void * const s050()");
226  return ABC;
227 }
228 
229 const char * const s052()
230 {
231  TRACE("const char * const s052()");
232  return ABC;
233 }
234 
235 void * const s070()
236 {
237  TRACE("void * const s070()");
238  return abc;
239 }
240 
241 char * const s072()
242 {
243  TRACE("char * const s072()");
244  return abc;
245 }
246 
247 void s110(const void * p0)
248 {
249  TRACE("void s110(const void *)");
250  CHECK((strcmp((const char*)p0, abc) != 0 && strcmp((const char*)p0, ABC) != 0),
251  "void s110(const void *)");
252 }
253 
254 void s112(const char * p0)
255 {
256  TRACE("void s112(const char *)");
257  CHECK((strcmp(p0, abc) != 0 && strcmp(p0, ABC) != 0),
258  "void s112(const char *)");
259 }
260 
261 void s130(void * p0)
262 {
263  TRACE("void s130(void *)");
264  CHECK((strcmp((const char*)p0, abc) != 0 && strcmp((const char*)p0, ABC) != 0),
265  "void s130(void *)");
266 }
267 
268 void s132(char * p0)
269 {
270  TRACE("void s132(char *)");
271  CHECK((strcmp(p0, abc) != 0 && strcmp(p0, ABC) != 0),
272  "void s132(char *)");
273 }
274 
275 void s150(const void * const p0)
276 {
277  TRACE("void s150(const void * const)");
278  CHECK((strcmp((const char*)p0, abc) != 0 && strcmp((const char*)p0, ABC) != 0),
279  "void s150(const void * const)");
280 }
281 
282 void s152(const char * const p0)
283 {
284  TRACE("void s152(const char * const)");
285  CHECK((strcmp(p0, abc) != 0 && strcmp(p0, ABC) != 0),
286  "void s152(const char * const)");
287 }
288 
289 void s170(void * const p0)
290 {
291  TRACE("void s170(void * const)");
292  CHECK((strcmp((const char*)p0, abc) != 0 && strcmp((const char*)p0, ABC) != 0),
293  "void s170(void * const)");
294 }
295 
296 void s172(char * const p0)
297 {
298  TRACE("void s172(char * const)");
299  CHECK((strcmp(p0, abc) != 0 && strcmp(p0, ABC) != 0),
300  "void s172(char * const)");
301 }
302 
303 // ---------------------------------------------------------------------------
304 
305 const void * s210()
306 {
307  TRACE("const void * s210()");
308  return NULL;
309 }
310 
311 const char * s212()
312 {
313  TRACE("const char * s212()");
314  return NULL;
315 }
316 
317 void * s230()
318 {
319  TRACE("void * s230()");
320  return NULL;
321 }
322 
323 char * s232()
324 {
325  TRACE("char * s232()");
326  return NULL;
327 }
328 
329 const void * const s250()
330 {
331  TRACE("const void * const s250()");
332  return NULL;
333 }
334 
335 const char * const s252()
336 {
337  TRACE("const char * const s252()");
338  return NULL;
339 }
340 
341 void * const s270()
342 {
343  TRACE("void * const s270()");
344  return NULL;
345 }
346 
347 char * const s272()
348 {
349  TRACE("char * const s272()");
350  return NULL;
351 }
352 
353 void s310(const void * p0)
354 {
355  TRACE("void s310(const void *)");
356  (void)p0;
357 }
358 
359 void s312(const char * p0)
360 {
361  TRACE("void s312(const char *)");
362  (void)p0;
363 }
364 
365 void s330(void * p0)
366 {
367  TRACE("void s330(void *)");
368  (void)p0;
369 }
370 
371 void s332(char * p0)
372 {
373  TRACE("void s332(char *)");
374  (void)p0;
375 }
376 
377 void s350(const void * const p0)
378 {
379  TRACE("void s350(const void * const)");
380  (void)p0;
381 }
382 
383 void s352(const char * const p0)
384 {
385  TRACE("void s352(const char * const)");
386  (void)p0;
387 }
388 
389 void s370(void * const p0)
390 {
391  TRACE("void s370(void * const)");
392  (void)p0;
393 }
394 
395 void s372(char * const p0)
396 {
397  TRACE("void s372(char * const)");
398  (void)p0;
399 }
400 
401 // ---------------------------------------------------------------------------
402 
403 const bool f11(const bool p0)
404 {
405  TRACE("const bool f11(const bool)");
406  return p0;
407 }
408 
409 const char f12(const char p0)
410 {
411  TRACE("const char f12(const char)");
412  return p0;
413 }
414 
415 const signed char f13(const signed char p0)
416 {
417  TRACE("const signed char f13(const signed char)");
418  return p0;
419 }
420 
421 const unsigned char f14(const unsigned char p0)
422 {
423  TRACE("const unsigned char f14(const unsigned char)");
424  return p0;
425 }
426 
427 const signed short f15(const signed short p0)
428 {
429  TRACE("const signed short f15(const signed short)");
430  return p0;
431 }
432 
433 const unsigned short f16(const unsigned short p0)
434 {
435  TRACE("const unsigned short f16(const unsigned short)");
436  return p0;
437 }
438 
439 const signed int f17(const signed int p0)
440 {
441  TRACE("const signed int f17(const signed int)");
442  return p0;
443 }
444 
445 const unsigned int f18(const unsigned int p0)
446 {
447  TRACE("const unsigned int f18(const unsigned int)");
448  return p0;
449 }
450 
451 const signed long f19(const signed long p0)
452 {
453  TRACE("const signed long f19(const signed long)");
454  return p0;
455 }
456 
457 const unsigned long f20(const unsigned long p0)
458 {
459  TRACE("const unsigned long f20(const unsigned long)");
460  return p0;
461 }
462 
463 const signed long long f21(const signed long long p0)
464 {
465  TRACE("const signed long long f21(const signed long long)");
466  return p0;
467 }
468 
469 const unsigned long long f22(const unsigned long long p0)
470 {
471  TRACE("const unsigned long long f22(const unsigned long long)");
472  return p0;
473 }
474 
475 const float f23(const float p0)
476 {
477  TRACE("const float f23(const float)");
478  return p0;
479 }
480 
481 const double f24(const double p0)
482 {
483  TRACE("const double f24(const double)");
484  return p0;
485 }
486 
487 const long double f25(const long double p0)
488 {
489  TRACE("const long double f25(const long double)");
490  return p0;
491 }
492 
493 bool f31(bool p0)
494 {
495  TRACE("bool f31(bool)");
496  return p0;
497 }
498 
499 char f32(char p0)
500 {
501  TRACE("char f32(char)");
502  return p0;
503 }
504 
505 signed char f33(signed char p0)
506 {
507  TRACE("signed char f33(signed char)");
508  return p0;
509 }
510 
511 unsigned char f34(unsigned char p0)
512 {
513  TRACE("unsigned char f34(unsigned char)");
514  return p0;
515 }
516 
517 signed short f35(signed short p0)
518 {
519  TRACE("signed short f35(signed short)");
520  return p0;
521 }
522 
523 unsigned short f36(unsigned short p0)
524 {
525  TRACE("unsigned short f36(unsigned short)");
526  return p0;
527 }
528 
529 signed int f37(signed int p0)
530 {
531  TRACE("signed int f37(signed int)");
532  return p0;
533 }
534 
535 unsigned int f38(unsigned int p0)
536 {
537  TRACE("unsigned int f38(unsigned int)");
538  return p0;
539 }
540 
541 signed long f39(signed long p0)
542 {
543  TRACE("signed long f39(signed long)");
544  return p0;
545 }
546 
547 unsigned long f40(unsigned long p0)
548 {
549  TRACE("unsigned long f40(unsigned long)");
550  return p0;
551 }
552 
553 signed long long f41(signed long long p0)
554 {
555  TRACE("signed long long f41(signed long long)");
556  return p0;
557 }
558 
559 unsigned long long f42(unsigned long long p0)
560 {
561  TRACE("unsigned long long f42(unsigned long long)");
562  return p0;
563 }
564 
565 float f43(float p0)
566 {
567  TRACE("float f43(float)");
568  return p0;
569 }
570 
571 double f44(double p0)
572 {
573  TRACE("double f44(double)");
574  return p0;
575 }
576 
577 long double f45(long double p0)
578 {
579  TRACE("long double f45(long double)");
580  return p0;
581 }
582 
583 // ---------------------------------------------------------------------------
584 
585 const bool f011()
586 {
587  TRACE("const bool f011()");
588  static bool _f011 = 0;
589  _f011 = !_f011;
590  return _f011;
591 }
592 
593 const char f012()
594 {
595  TRACE("const char f012()");
596  static char _f012 = 0;
597  _f012++;
598  return _f012;
599 }
600 
601 const int8_t f013()
602 {
603  TRACE("const int8_t f013()");
604  static int8_t _f013 = 0;
605  _f013++;
606  return _f013;
607 }
608 
609 const uint8_t f014()
610 {
611  TRACE("const uint8_t f014()");
612  static uint8_t _f014 = 0;
613  _f014++;
614  return _f014;
615 }
616 
617 const int16_t f015()
618 {
619  TRACE("const int16_t f015()");
620  static int16_t _f015 = 0;
621  _f015++;
622  return _f015;
623 }
624 
625 const uint16_t f016()
626 {
627  TRACE("const uint16_t f016()");
628  static uint16_t _f016 = 0;
629  _f016++;
630  return _f016;
631 }
632 
633 const int32_t f017()
634 {
635  TRACE("const int32_t f017()");
636  static int32_t _f017 = 0;
637  _f017++;
638  return _f017;
639 }
640 
641 const uint32_t f018()
642 {
643  TRACE("const uint32_t f018()");
644  static uint32_t _f018 = 0;
645  _f018++;
646  return _f018;
647 }
648 
649 const int64_t f021()
650 {
651  TRACE("const int64_t f021()");
652  static int64_t _f021 = 0;
653  _f021++;
654  return _f021;
655 }
656 
657 const uint64_t f022()
658 {
659  TRACE("const uint64_t f022()");
660  static uint64_t _f022 = 0;
661  _f022++;
662  return _f022;
663 }
664 
665 const float f023()
666 {
667  TRACE("const float f023()");
668  static float _f023 = 0;
669  _f023++;
670  return _f023;
671 }
672 
673 const double f024()
674 {
675  TRACE("const double f024()");
676  static double _f024 = 0;
677  _f024++;
678  return _f024;
679 }
680 
681 bool f031()
682 {
683  TRACE("bool f031()");
684  static bool _f031 = 0;
685  _f031 = !_f031;
686  return _f031;
687 }
688 
689 char f032()
690 {
691  TRACE("char f032()");
692  static char _f032 = 0;
693  _f032++;
694  return _f032;
695 }
696 
697 int8_t f033()
698 {
699  TRACE("int8_t f033()");
700  static int8_t _f033 = 0;
701  _f033++;
702  return _f033;
703 }
704 
705 uint8_t f034()
706 {
707  TRACE("uint8_t f034()");
708  static uint8_t _f034 = 0;
709  _f034++;
710  return _f034;
711 }
712 
713 int16_t f035()
714 {
715  TRACE("int16_t f035()");
716  static int16_t _f035 = 0;
717  _f035++;
718  return _f035;
719 }
720 
721 uint16_t f036()
722 {
723  TRACE("uint16_t f036()");
724  static uint16_t _f036 = 0;
725  _f036++;
726  return _f036;
727 }
728 
729 int32_t f037()
730 {
731  TRACE("int32_t f037()");
732  static int32_t _f037 = 0;
733  _f037++;
734  return _f037;
735 }
736 
737 uint32_t f038()
738 {
739  TRACE("uint32_t f038()");
740  static uint32_t _f038 = 0;
741  _f038++;
742  return _f038;
743 }
744 
745 int64_t f041()
746 {
747  TRACE("int64_t f041()");
748  static int64_t _f041 = 0;
749  _f041++;
750  return _f041;
751 }
752 
753 uint64_t f042()
754 {
755  TRACE("uint64_t f042()");
756  static uint64_t _f042 = 0;
757  _f042++;
758  return _f042;
759 }
760 
761 float f043()
762 {
763  TRACE("float f043()");
764  static float _f043 = 0;
765  _f043++;
766  return _f043;
767 }
768 
769 double f044()
770 {
771  TRACE("double f044()");
772  static double _f044 = 0;
773  _f044++;
774  return _f044;
775 }
776 
777 // ---------------------------------------------------------------------------
778 
779 void f111(const bool p0)
780 {
781  TRACE("void f111(const bool)");
782  static bool _f111 = 0;
783  _f111 = !_f111;
784  CHECK((p0 != _f111),
785  "void f111(const bool)");
786 }
787 
788 void f112(const char p0)
789 {
790  TRACE("void f112(const char)");
791  static char _f112 = 0;
792  _f112++;
793  CHECK((p0 != _f112),
794  "void f112(const char)");
795 }
796 
797 void f113(const int8_t p0)
798 {
799  TRACE("void f113(const int8_t)");
800  static int8_t _f113 = 0;
801  _f113++;
802  CHECK((p0 != _f113),
803  "void f113(const int8_t)");
804 }
805 
806 void f114(const uint8_t p0)
807 {
808  TRACE("void f114(const uint8_t)");
809  static uint8_t _f114 = 0;
810  _f114++;
811  CHECK((p0 != _f114),
812  "void f114(const uint8_t)");
813 }
814 
815 void f115(const int16_t p0)
816 {
817  TRACE("void f115(const int16_t)");
818  static int16_t _f115 = 0;
819  _f115++;
820  CHECK((p0 != _f115),
821  "void f115(const int16_t)");
822 }
823 
824 void f116(const uint16_t p0)
825 {
826  TRACE("void f116(const uint16_t)");
827  static uint16_t _f116 = 0;
828  _f116++;
829  CHECK((p0 != _f116),
830  "void f116(const uint16_t)");
831 }
832 
833 void f117(const int32_t p0)
834 {
835  TRACE("void f117(const int32_t)");
836  static int32_t _f117 = 0;
837  _f117++;
838  CHECK((p0 != _f117),
839  "void f117(const int32_t)");
840 }
841 
842 void f118(const uint32_t p0)
843 {
844  TRACE("void f118(const uint32_t)");
845  static uint32_t _f118 = 0;
846  _f118++;
847  CHECK((p0 != _f118),
848  "void f118(const uint32_t)");
849 }
850 
851 void f121(const int64_t p0)
852 {
853  TRACE("void f121(const int64_t)");
854  static int64_t _f121 = 0;
855  _f121++;
856  CHECK((p0 != _f121),
857  "void f121(const int64_t)");
858 }
859 
860 void f122(const uint64_t p0)
861 {
862  TRACE("void f122(const uint64_t)");
863  static uint64_t _f122 = 0;
864  _f122++;
865  CHECK((p0 != _f122),
866  "void f122(const uint64_t)");
867 }
868 
869 void f123(const float p0)
870 {
871  TRACE("void f123(const float)");
872  static float _f123 = 0;
873  _f123++;
874  CHECK((p0 != _f123),
875  "void f123(const float)");
876 }
877 
878 void f124(const double p0)
879 {
880  TRACE("void f124(const double)");
881  static double _f124 = 0;
882  _f124++;
883  CHECK((p0 != _f124),
884  "void f124(const double)");
885 }
886 
887 void f131(bool p0)
888 {
889  TRACE("void f131(bool)");
890  static bool _f131 = 0;
891  _f131 = !_f131;
892  CHECK((p0 != _f131),
893  "void f131(bool)");
894 }
895 
896 void f132(char p0)
897 {
898  TRACE("void f132(char)");
899  static char _f132 = 0;
900  _f132++;
901  CHECK((p0 != _f132),
902  "void f132(char)");
903 }
904 
905 void f133(int8_t p0)
906 {
907  TRACE("void f133(int8_t)");
908  static int8_t _f133 = 0;
909  _f133++;
910  CHECK((p0 != _f133),
911  "void f133(int8_t)");
912 }
913 
914 void f134(uint8_t p0)
915 {
916  TRACE("void f134(uint8_t)");
917  static uint8_t _f134 = 0;
918  _f134++;
919  CHECK((p0 != _f134),
920  "void f134(uint8_t)");
921 }
922 
923 void f135(int16_t p0)
924 {
925  TRACE("void f135(int16_t)");
926  static int16_t _f135 = 0;
927  _f135++;
928  CHECK((p0 != _f135),
929  "void f135(int16_t)");
930 }
931 
932 void f136(uint16_t p0)
933 {
934  TRACE("void f136(uint16_t)");
935  static uint16_t _f136 = 0;
936  _f136++;
937  CHECK((p0 != _f136),
938  "void f136(uint16_t)");
939 }
940 
941 void f137(int32_t p0)
942 {
943  TRACE("void f137(int32_t)");
944  static int32_t _f137 = 0;
945  _f137++;
946  CHECK((p0 != _f137),
947  "void f137(int32_t)");
948 }
949 
950 void f138(uint32_t p0)
951 {
952  TRACE("void f138(uint32_t)");
953  static uint32_t _f138 = 0;
954  _f138++;
955  CHECK((p0 != _f138),
956  "void f138(uint32_t)");
957 }
958 
959 void f141(int64_t p0)
960 {
961  TRACE("void f141(int64_t)");
962  static int64_t _f141 = 0;
963  _f141++;
964  CHECK((p0 != _f141),
965  "void f141(int64_t)");
966 }
967 
968 void f142(uint64_t p0)
969 {
970  TRACE("void f142(uint64_t)");
971  static uint64_t _f142 = 0;
972  _f142++;
973  CHECK((p0 != _f142),
974  "void f142(uint64_t)");
975 }
976 
977 void f143(float p0)
978 {
979  TRACE("void f143(float)");
980  static float _f143 = 0;
981  _f143++;
982  CHECK((p0 != _f143),
983  "void f143(float)");
984 }
985 
986 void f144(double p0)
987 {
988  TRACE("void f144(double)");
989  static double _f144 = 0;
990  _f144++;
991  CHECK((p0 != _f144),
992  "void f144(double)");
993 }
994 
995 // ---------------------------------------------------------------------------
996 
997 const bool & f211()
998 {
999  TRACE("const bool & f211()");
1000  static bool _f211 = 0;
1001  _f211 = !_f211;
1002  return _f211;
1003 }
1004 
1005 const char & f212()
1006 {
1007  TRACE("const char & f212()");
1008  static char _f212 = 0;
1009  _f212++;
1010  return _f212;
1011 }
1012 
1013 const int8_t & f213()
1014 {
1015  TRACE("const int8_t & f213()");
1016  static int8_t _f213 = 0;
1017  _f213++;
1018  return _f213;
1019 }
1020 
1021 const uint8_t & f214()
1022 {
1023  TRACE("const uint8_t & f214()");
1024  static uint8_t _f214 = 0;
1025  _f214++;
1026  return _f214;
1027 }
1028 
1029 const int16_t & f215()
1030 {
1031  TRACE("const int16_t & f215()");
1032  static int16_t _f215 = 0;
1033  _f215++;
1034  return _f215;
1035 }
1036 
1037 const uint16_t & f216()
1038 {
1039  TRACE("const uint16_t & f216()");
1040  static uint16_t _f216 = 0;
1041  _f216++;
1042  return _f216;
1043 }
1044 
1045 const int32_t & f217()
1046 {
1047  TRACE("const int32_t & f217()");
1048  static int32_t _f217 = 0;
1049  _f217++;
1050  return _f217;
1051 }
1052 
1053 const uint32_t & f218()
1054 {
1055  TRACE("const uint32_t & f218()");
1056  static uint32_t _f218 = 0;
1057  _f218++;
1058  return _f218;
1059 }
1060 
1061 const int64_t & f221()
1062 {
1063  TRACE("const int64_t & f221()");
1064  static int64_t _f221 = 0;
1065  _f221++;
1066  return _f221;
1067 }
1068 
1069 const uint64_t & f222()
1070 {
1071  TRACE("const uint64_t & f222()");
1072  static uint64_t _f222 = 0;
1073  _f222++;
1074  return _f222;
1075 }
1076 
1077 const float & f223()
1078 {
1079  TRACE("const & float f223()");
1080  static float _f223 = 0;
1081  _f223++;
1082  return _f223;
1083 }
1084 
1085 const double & f224()
1086 {
1087  TRACE("const double & f224()");
1088  static double _f224 = 0;
1089  _f224++;
1090  return _f224;
1091 }
1092 
1093 bool & f231()
1094 {
1095  TRACE("bool & f231()");
1096  static bool _f231 = 0;
1097  _f231 = !_f231;
1098  return _f231;
1099 }
1100 
1101 char & f232()
1102 {
1103  TRACE("char & f232()");
1104  static char _f232 = 0;
1105  _f232++;
1106  return _f232;
1107 }
1108 
1109 int8_t & f233()
1110 {
1111  TRACE("int8_t & f233()");
1112  static int8_t _f233 = 0;
1113  _f233++;
1114  return _f233;
1115 }
1116 
1117 uint8_t & f234()
1118 {
1119  TRACE("uint8_t & f234()");
1120  static uint8_t _f234 = 0;
1121  _f234++;
1122  return _f234;
1123 }
1124 
1125 int16_t & f235()
1126 {
1127  TRACE("int16_t & f235()");
1128  static int16_t _f235 = 0;
1129  _f235++;
1130  return _f235;
1131 }
1132 
1133 uint16_t & f236()
1134 {
1135  TRACE("uint16_t & f236()");
1136  static uint16_t _f236 = 0;
1137  _f236++;
1138  return _f236;
1139 }
1140 
1141 int32_t & f237()
1142 {
1143  TRACE("int32_t & f237()");
1144  static int32_t _f237 = 0;
1145  _f237++;
1146  return _f237;
1147 }
1148 
1149 uint32_t & f238()
1150 {
1151  TRACE("uint32_t & f238()");
1152  static uint32_t _f238 = 0;
1153  _f238++;
1154  return _f238;
1155 }
1156 
1157 int64_t & f241()
1158 {
1159  TRACE("int64_t & f241()");
1160  static int64_t _f241 = 0;
1161  _f241++;
1162  return _f241;
1163 }
1164 
1165 uint64_t & f242()
1166 {
1167  TRACE("uint64_t & f242()");
1168  static uint64_t _f242 = 0;
1169  _f242++;
1170  return _f242;
1171 }
1172 
1173 float & f243()
1174 {
1175  TRACE("float & f243()");
1176  static float _f243 = 0;
1177  _f243++;
1178  return _f243;
1179 }
1180 
1181 double & f244()
1182 {
1183  TRACE("double & f244()");
1184  static double _f244 = 0;
1185  _f244++;
1186  return _f244;
1187 }
1188 
1189 // ---------------------------------------------------------------------------
1190 
1191 void f311(const bool & p0)
1192 {
1193  TRACE("void f311(const bool &)");
1194  static bool _f311 = 0;
1195  _f311 = !_f311;
1196  CHECK((p0 != _f311),
1197  "void f311(const bool &)");
1198 }
1199 
1200 void f312(const char & p0)
1201 {
1202  TRACE("void f312(const char &)");
1203  static char _f312 = 0;
1204  _f312++;
1205  CHECK((p0 != _f312),
1206  "void f312(const char &)");
1207 }
1208 
1209 void f313(const int8_t & p0)
1210 {
1211  TRACE("void f313(const int8_t &)");
1212  static int8_t _f313 = 0;
1213  _f313++;
1214  CHECK((p0 != _f313),
1215  "void f313(const int8_t &)");
1216 }
1217 
1218 void f314(const uint8_t & p0)
1219 {
1220  TRACE("void f314(const uint8_t &)");
1221  static uint8_t _f314 = 0;
1222  _f314++;
1223  CHECK((p0 != _f314),
1224  "void f314(const uint8_t &)");
1225 }
1226 
1227 void f315(const int16_t & p0)
1228 {
1229  TRACE("void f315(const int16_t &)");
1230  static int16_t _f315 = 0;
1231  _f315++;
1232  CHECK((p0 != _f315),
1233  "void f315(const int16_t &)");
1234 }
1235 
1236 void f316(const uint16_t & p0)
1237 {
1238  TRACE("void f316(const uint16_t &)");
1239  static uint16_t _f316 = 0;
1240  _f316++;
1241  CHECK((p0 != _f316),
1242  "void f316(const uint16_t &)");
1243 }
1244 
1245 void f317(const int32_t & p0)
1246 {
1247  TRACE("void f317(const int32_t &)");
1248  static int32_t _f317 = 0;
1249  _f317++;
1250  CHECK((p0 != _f317),
1251  "void f317(const int32_t &)");
1252 }
1253 
1254 void f318(const uint32_t & p0)
1255 {
1256  TRACE("void f318(const uint32_t &)");
1257  static uint32_t _f318 = 0;
1258  _f318++;
1259  CHECK((p0 != _f318),
1260  "void f318(const uint32_t &)");
1261 }
1262 
1263 void f321(const int64_t & p0)
1264 {
1265  TRACE("void f321(const int64_t &)");
1266  static int64_t _f321 = 0;
1267  _f321++;
1268  CHECK((p0 != _f321),
1269  "void f321(const int64_t &)");
1270 }
1271 
1272 void f322(const uint64_t & p0)
1273 {
1274  TRACE("void f322(const uint64_t &)");
1275  static uint64_t _f322 = 0;
1276  _f322++;
1277  CHECK((p0 != _f322),
1278  "void f322(const uint64_t &)");
1279 }
1280 
1281 void f323(const float & p0)
1282 {
1283  TRACE("void f323(const float &)");
1284  static float _f323 = 0;
1285  _f323++;
1286  CHECK((p0 != _f323),
1287  "void f323(const float &)");
1288 }
1289 
1290 void f324(const double & p0)
1291 {
1292  TRACE("void f324(const double &)");
1293  static double _f324 = 0;
1294  _f324++;
1295  CHECK((p0 != _f324),
1296  "void f324(const double &)");
1297 }
1298 
1299 void f331(bool & p0)
1300 {
1301  TRACE("void f331(bool &)");
1302  static bool _f331 = 0;
1303  _f331 = !_f331;
1304  CHECK((p0 != _f331),
1305  "void f331(bool &)");
1306  p0 = !p0;
1307  _f331 = !_f331;
1308 }
1309 
1310 void f332(char & p0)
1311 {
1312  TRACE("void f332(char &)");
1313  static char _f332 = 0;
1314  _f332++;
1315  CHECK((p0 != _f332),
1316  "void f332(char &)");
1317  p0++;
1318  _f332++;
1319 }
1320 
1321 void f333(int8_t & p0)
1322 {
1323  TRACE("void f333(int8_t &)");
1324  static int8_t _f333 = 0;
1325  _f333++;
1326  CHECK((p0 != _f333),
1327  "void f333(int8_t &)");
1328  p0++;
1329  _f333++;
1330 }
1331 
1332 void f334(uint8_t & p0)
1333 {
1334  TRACE("void f334(uint8_t &)");
1335  static uint8_t _f334 = 0;
1336  _f334++;
1337  CHECK((p0 != _f334),
1338  "void f334(uint8_t &)");
1339  p0++;
1340  _f334++;
1341 }
1342 
1343 void f335(int16_t & p0)
1344 {
1345  TRACE("void f335(int16_t &)");
1346  static int16_t _f335 = 0;
1347  _f335++;
1348  CHECK((p0 != _f335),
1349  "void f335(int16_t &)");
1350  p0++;
1351  _f335++;
1352 }
1353 
1354 void f336(uint16_t & p0)
1355 {
1356  TRACE("void f336(uint16_t &)");
1357  static uint16_t _f336 = 0;
1358  _f336++;
1359  CHECK((p0 != _f336),
1360  "void f336(uint16_t &)");
1361  p0++;
1362  _f336++;
1363 }
1364 
1365 void f337(int32_t & p0)
1366 {
1367  TRACE("void f337(int32_t &)");
1368  static int32_t _f337 = 0;
1369  _f337++;
1370  CHECK((p0 != _f337),
1371  "void f337(int32_t &)");
1372  p0++;
1373  _f337++;
1374 }
1375 
1376 void f338(uint32_t & p0)
1377 {
1378  TRACE("void f338(uint32_t &)");
1379  static uint32_t _f338 = 0;
1380  _f338++;
1381  CHECK((p0 != _f338),
1382  "void f338(uint32_t &)");
1383  p0++;
1384  _f338++;
1385 }
1386 
1387 void f341(int64_t & p0)
1388 {
1389  TRACE("void f341(int64_t &)");
1390  static int64_t _f341 = 0;
1391  _f341++;
1392  CHECK((p0 != _f341),
1393  "void f341(int64_t &)");
1394  p0++;
1395  _f341++;
1396 }
1397 
1398 void f342(uint64_t & p0)
1399 {
1400  TRACE("void f342(uint64_t &)");
1401  static uint64_t _f342 = 0;
1402  _f342++;
1403  CHECK((p0 != _f342),
1404  "void f342(uint64_t &)");
1405  p0++;
1406  _f342++;
1407 }
1408 
1409 void f343(float & p0)
1410 {
1411  TRACE("void f343(float &)");
1412  static float _f343 = 0;
1413  _f343++;
1414  CHECK((p0 != _f343),
1415  "void f343(float &)");
1416  p0++;
1417  _f343++;
1418 }
1419 
1420 void f344(double & p0)
1421 {
1422  TRACE("void f344(double &)");
1423  static double _f344 = 0;
1424  _f344++;
1425  CHECK((p0 != _f344),
1426  "void f344(double &)");
1427  p0++;
1428  _f344++;
1429 }
1430 
1431 // ---------------------------------------------------------------------------
1432 
1433 const bool * f411()
1434 {
1435  TRACE("const bool * f411()");
1436  static bool _f411 = 0;
1437  _f411 = !_f411;
1438  return &_f411;
1439 }
1440 
1441 const char * f412()
1442 {
1443  TRACE("const char * f412()");
1444  static char _f412 = 0;
1445  _f412++;
1446  return &_f412;
1447 }
1448 
1449 const int8_t * f413()
1450 {
1451  TRACE("const int8_t * f413()");
1452  static int8_t _f413 = 0;
1453  _f413++;
1454  return &_f413;
1455 }
1456 
1457 const uint8_t * f414()
1458 {
1459  TRACE("const uint8_t * f414()");
1460  static uint8_t _f414 = 0;
1461  _f414++;
1462  return &_f414;
1463 }
1464 
1465 const int16_t * f415()
1466 {
1467  TRACE("const int16_t * f415()");
1468  static int16_t _f415 = 0;
1469  _f415++;
1470  return &_f415;
1471 }
1472 
1473 const uint16_t * f416()
1474 {
1475  TRACE("const uint16_t * f416()");
1476  static uint16_t _f416 = 0;
1477  _f416++;
1478  return &_f416;
1479 }
1480 
1481 const int32_t * f417()
1482 {
1483  TRACE("const int32_t * f417()");
1484  static int32_t _f417 = 0;
1485  _f417++;
1486  return &_f417;
1487 }
1488 
1489 const uint32_t * f418()
1490 {
1491  TRACE("const uint32_t * f418()");
1492  static uint32_t _f418 = 0;
1493  _f418++;
1494  return &_f418;
1495 }
1496 
1497 const int64_t * f421()
1498 {
1499  TRACE("const int64_t * f421()");
1500  static int64_t _f421 = 0;
1501  _f421++;
1502  return &_f421;
1503 }
1504 
1505 const uint64_t * f422()
1506 {
1507  TRACE("const uint64_t * f422()");
1508  static uint64_t _f422 = 0;
1509  _f422++;
1510  return &_f422;
1511 }
1512 
1513 const float * f423()
1514 {
1515  TRACE("const * float f423()");
1516  static float _f423 = 0;
1517  _f423++;
1518  return &_f423;
1519 }
1520 
1521 const double * f424()
1522 {
1523  TRACE("const double * f424()");
1524  static double _f424 = 0;
1525  _f424++;
1526  return &_f424;
1527 }
1528 
1529 bool * f431()
1530 {
1531  TRACE("bool * f431()");
1532  static bool _f431 = 0;
1533  _f431 = !_f431;
1534  return &_f431;
1535 }
1536 
1537 char * f432()
1538 {
1539  TRACE("char * f432()");
1540  static char _f432 = 0;
1541  _f432++;
1542  return &_f432;
1543 }
1544 
1545 int8_t * f433()
1546 {
1547  TRACE("int8_t * f433()");
1548  static int8_t _f433 = 0;
1549  _f433++;
1550  return &_f433;
1551 }
1552 
1553 uint8_t * f434()
1554 {
1555  TRACE("uint8_t * f434()");
1556  static uint8_t _f434 = 0;
1557  _f434++;
1558  return &_f434;
1559 }
1560 
1561 int16_t * f435()
1562 {
1563  TRACE("int16_t * f435()");
1564  static int16_t _f435 = 0;
1565  _f435++;
1566  return &_f435;
1567 }
1568 
1569 uint16_t * f436()
1570 {
1571  TRACE("uint16_t * f436()");
1572  static uint16_t _f436 = 0;
1573  _f436++;
1574  return &_f436;
1575 }
1576 
1577 int32_t * f437()
1578 {
1579  TRACE("int32_t * f437()");
1580  static int32_t _f437 = 0;
1581  _f437++;
1582  return &_f437;
1583 }
1584 
1585 uint32_t * f438()
1586 {
1587  TRACE("uint32_t * f438()");
1588  static uint32_t _f438 = 0;
1589  _f438++;
1590  return &_f438;
1591 }
1592 
1593 int64_t * f441()
1594 {
1595  TRACE("int64_t * f441()");
1596  static int64_t _f441 = 0;
1597  _f441++;
1598  return &_f441;
1599 }
1600 
1601 uint64_t * f442()
1602 {
1603  TRACE("uint64_t * f442()");
1604  static uint64_t _f442 = 0;
1605  _f442++;
1606  return &_f442;
1607 }
1608 
1609 float * f443()
1610 {
1611  TRACE("float * f443()");
1612  static float _f443 = 0;
1613  _f443++;
1614  return &_f443;
1615 }
1616 
1617 double * f444()
1618 {
1619  TRACE("double * f444()");
1620  static double _f444 = 0;
1621  _f444++;
1622  return &_f444;
1623 }
1624 
1625 const bool * const f451()
1626 {
1627  TRACE("const bool * const f451()");
1628  static bool _f451 = 0;
1629  _f451 = !_f451;
1630  return &_f451;
1631 }
1632 
1633 const char * const f452()
1634 {
1635  TRACE("const char * const f452()");
1636  static char _f452 = 0;
1637  _f452++;
1638  return &_f452;
1639 }
1640 
1641 const int8_t * const f453()
1642 {
1643  TRACE("const int8_t * const f453()");
1644  static int8_t _f453 = 0;
1645  _f453++;
1646  return &_f453;
1647 }
1648 
1649 const uint8_t * const f454()
1650 {
1651  TRACE("const uint8_t * const f454()");
1652  static uint8_t _f454 = 0;
1653  _f454++;
1654  return &_f454;
1655 }
1656 
1657 const int16_t * const f455()
1658 {
1659  TRACE("const int16_t * const f455()");
1660  static int16_t _f455 = 0;
1661  _f455++;
1662  return &_f455;
1663 }
1664 
1665 const uint16_t * const f456()
1666 {
1667  TRACE("const uint16_t * const f456()");
1668  static uint16_t _f456 = 0;
1669  _f456++;
1670  return &_f456;
1671 }
1672 
1673 const int32_t * const f457()
1674 {
1675  TRACE("const int32_t * const f457()");
1676  static int32_t _f457 = 0;
1677  _f457++;
1678  return &_f457;
1679 }
1680 
1681 const uint32_t * const f458()
1682 {
1683  TRACE("const uint32_t * const f458()");
1684  static uint32_t _f458 = 0;
1685  _f458++;
1686  return &_f458;
1687 }
1688 
1689 const int64_t * const f461()
1690 {
1691  TRACE("const int64_t * const f461()");
1692  static int64_t _f461 = 0;
1693  _f461++;
1694  return &_f461;
1695 }
1696 
1697 const uint64_t * const f462()
1698 {
1699  TRACE("const uint64_t * const f462()");
1700  static uint64_t _f462 = 0;
1701  _f462++;
1702  return &_f462;
1703 }
1704 
1705 const float * const f463()
1706 {
1707  TRACE("const * float const f463()");
1708  static float _f463 = 0;
1709  _f463++;
1710  return &_f463;
1711 }
1712 
1713 const double * const f464()
1714 {
1715  TRACE("const double * const f464()");
1716  static double _f464 = 0;
1717  _f464++;
1718  return &_f464;
1719 }
1720 
1721 bool * const f471()
1722 {
1723  TRACE("bool * const f471()");
1724  static bool _f471 = 0;
1725  _f471 = !_f471;
1726  return &_f471;
1727 }
1728 
1729 char * const f472()
1730 {
1731  TRACE("char * const f472()");
1732  static char _f472 = 0;
1733  _f472++;
1734  return &_f472;
1735 }
1736 
1737 int8_t * const f473()
1738 {
1739  TRACE("int8_t * const f473()");
1740  static int8_t _f473 = 0;
1741  _f473++;
1742  return &_f473;
1743 }
1744 
1745 uint8_t * const f474()
1746 {
1747  TRACE("uint8_t * const f474()");
1748  static uint8_t _f474 = 0;
1749  _f474++;
1750  return &_f474;
1751 }
1752 
1753 int16_t * const f475()
1754 {
1755  TRACE("int16_t * const f475()");
1756  static int16_t _f475 = 0;
1757  _f475++;
1758  return &_f475;
1759 }
1760 
1761 uint16_t * const f476()
1762 {
1763  TRACE("uint16_t * const f476()");
1764  static uint16_t _f476 = 0;
1765  _f476++;
1766  return &_f476;
1767 }
1768 
1769 int32_t * const f477()
1770 {
1771  TRACE("int32_t * const f477()");
1772  static int32_t _f477 = 0;
1773  _f477++;
1774  return &_f477;
1775 }
1776 
1777 uint32_t * const f478()
1778 {
1779  TRACE("uint32_t * const f478()");
1780  static uint32_t _f478 = 0;
1781  _f478++;
1782  return &_f478;
1783 }
1784 
1785 int64_t * const f481()
1786 {
1787  TRACE("int64_t * const f481()");
1788  static int64_t _f481 = 0;
1789  _f481++;
1790  return &_f481;
1791 }
1792 
1793 uint64_t * const f482()
1794 {
1795  TRACE("uint64_t * const f482()");
1796  static uint64_t _f482 = 0;
1797  _f482++;
1798  return &_f482;
1799 }
1800 
1801 float * const f483()
1802 {
1803  TRACE("float * const f483()");
1804  static float _f483 = 0;
1805  _f483++;
1806  return &_f483;
1807 }
1808 
1809 double * const f484()
1810 {
1811  TRACE("double * const f484()");
1812  static double _f484 = 0;
1813  _f484++;
1814  return &_f484;
1815 }
1816 
1817 // ---------------------------------------------------------------------------
1818 
1819 void f511(const bool * p0)
1820 {
1821  TRACE("void f511(const bool *)");
1822  static bool _f511 = 0;
1823  _f511 = !_f511;
1824  CHECK((*p0 != _f511),
1825  "void f511(const bool *)");
1826 }
1827 
1828 void f512(const char * p0)
1829 {
1830  TRACE("void f512(const char *)");
1831  static char _f512 = 0;
1832  _f512++;
1833  CHECK((*p0 != _f512),
1834  "void f512(const char *)");
1835 }
1836 
1837 void f513(const int8_t * p0)
1838 {
1839  TRACE("void f513(const int8_t *)");
1840  static int8_t _f513 = 0;
1841  _f513++;
1842  CHECK((*p0 != _f513),
1843  "void f513(const int8_t *)");
1844 }
1845 
1846 void f514(const uint8_t * p0)
1847 {
1848  TRACE("void f514(const uint8_t *)");
1849  static uint8_t _f514 = 0;
1850  _f514++;
1851  CHECK((*p0 != _f514),
1852  "void f514(const uint8_t *)");
1853 }
1854 
1855 void f515(const int16_t * p0)
1856 {
1857  TRACE("void f515(const int16_t *)");
1858  static int16_t _f515 = 0;
1859  _f515++;
1860  CHECK((*p0 != _f515),
1861  "void f515(const int16_t *)");
1862 }
1863 
1864 void f516(const uint16_t * p0)
1865 {
1866  TRACE("void f516(const uint16_t *)");
1867  static uint16_t _f516 = 0;
1868  _f516++;
1869  CHECK((*p0 != _f516),
1870  "void f516(const uint16_t *)");
1871 }
1872 
1873 void f517(const int32_t * p0)
1874 {
1875  TRACE("void f517(const int32_t *)");
1876  static int32_t _f517 = 0;
1877  _f517++;
1878  CHECK((*p0 != _f517),
1879  "void f517(const int32_t *)");
1880 }
1881 
1882 void f518(const uint32_t * p0)
1883 {
1884  TRACE("void f518(const uint32_t *)");
1885  static uint32_t _f518 = 0;
1886  _f518++;
1887  CHECK((*p0 != _f518),
1888  "void f518(const uint32_t *)");
1889 }
1890 
1891 void f521(const int64_t * p0)
1892 {
1893  TRACE("void f521(const int64_t *)");
1894  static int64_t _f521 = 0;
1895  _f521++;
1896  CHECK((*p0 != _f521),
1897  "void f521(const int64_t *)");
1898 }
1899 
1900 void f522(const uint64_t * p0)
1901 {
1902  TRACE("void f522(const uint64_t *)");
1903  static uint64_t _f522 = 0;
1904  _f522++;
1905  CHECK((*p0 != _f522),
1906  "void f522(const uint64_t *)");
1907 }
1908 
1909 void f523(const float * p0)
1910 {
1911  TRACE("void f523(const float *)");
1912  static float _f523 = 0;
1913  _f523++;
1914  CHECK((*p0 != _f523),
1915  "void f523(const float *)");
1916 }
1917 
1918 void f524(const double * p0)
1919 {
1920  TRACE("void f524(const double *)");
1921  static double _f524 = 0;
1922  _f524++;
1923  CHECK((*p0 != _f524),
1924  "void f524(const double *)");
1925 }
1926 
1927 void f531(bool * p0)
1928 {
1929  TRACE("void f531(bool *)");
1930  static bool _f531 = 0;
1931  _f531 = !_f531;
1932  CHECK((*p0 != _f531),
1933  "void f531(bool *)");
1934  *p0 = !*p0;
1935  _f531 = !_f531;
1936 }
1937 
1938 void f532(char * p0)
1939 {
1940  TRACE("void f532(char *)");
1941  static char _f532 = 0;
1942  _f532++;
1943  CHECK((*p0 != _f532),
1944  "void f532(char *)");
1945  (*p0)++;
1946  _f532++;
1947 }
1948 
1949 void f533(int8_t * p0)
1950 {
1951  TRACE("void f533(int8_t *)");
1952  static int8_t _f533 = 0;
1953  _f533++;
1954  CHECK((*p0 != _f533),
1955  "void f533(int8_t *)");
1956  (*p0)++;
1957  _f533++;
1958 }
1959 
1960 void f534(uint8_t * p0)
1961 {
1962  TRACE("void f534(uint8_t *)");
1963  static uint8_t _f534 = 0;
1964  _f534++;
1965  CHECK((*p0 != _f534),
1966  "void f534(uint8_t *)");
1967  (*p0)++;
1968  _f534++;
1969 }
1970 
1971 void f535(int16_t * p0)
1972 {
1973  TRACE("void f535(int16_t *)");
1974  static int16_t _f535 = 0;
1975  _f535++;
1976  CHECK((*p0 != _f535),
1977  "void f535(int16_t *)");
1978  (*p0)++;
1979  _f535++;
1980 }
1981 
1982 void f536(uint16_t * p0)
1983 {
1984  TRACE("void f536(uint16_t *)");
1985  static uint16_t _f536 = 0;
1986  _f536++;
1987  CHECK((*p0 != _f536),
1988  "void f536(uint16_t *)");
1989  (*p0)++;
1990  _f536++;
1991 }
1992 
1993 void f537(int32_t * p0)
1994 {
1995  TRACE("void f537(int32_t *)");
1996  static int32_t _f537 = 0;
1997  _f537++;
1998  CHECK((*p0 != _f537),
1999  "void f537(int32_t *)");
2000  (*p0)++;
2001  _f537++;
2002 }
2003 
2004 void f538(uint32_t * p0)
2005 {
2006  TRACE("void f538(uint32_t *)");
2007  static uint32_t _f538 = 0;
2008  _f538++;
2009  CHECK((*p0 != _f538),
2010  "void f538(uint32_t *)");
2011  (*p0)++;
2012  _f538++;
2013 }
2014 
2015 void f541(int64_t * p0)
2016 {
2017  TRACE("void f541(int64_t *)");
2018  static int64_t _f541 = 0;
2019  _f541++;
2020  CHECK((*p0 != _f541),
2021  "void f541(int64_t *)");
2022  (*p0)++;
2023  _f541++;
2024 }
2025 
2026 void f542(uint64_t * p0)
2027 {
2028  TRACE("void f542(uint64_t *)");
2029  static uint64_t _f542 = 0;
2030  _f542++;
2031  CHECK((*p0 != _f542),
2032  "void f542(uint64_t *)");
2033  (*p0)++;
2034  _f542++;
2035 }
2036 
2037 void f543(float * p0)
2038 {
2039  TRACE("void f543(float *)");
2040  static float _f543 = 0;
2041  _f543++;
2042  CHECK((*p0 != _f543),
2043  "void f543(float *)");
2044  (*p0)++;
2045  _f543++;
2046 }
2047 
2048 void f544(double * p0)
2049 {
2050  TRACE("void f544(double *)");
2051  static double _f544 = 0;
2052  _f544++;
2053  CHECK((*p0 != _f544),
2054  "void f544(double *)");
2055  (*p0)++;
2056  _f544++;
2057 }
2058 
2059 void f551(const bool * const p0)
2060 {
2061  TRACE("void f551(const bool * const)");
2062  static bool _f551 = 0;
2063  _f551 = !_f551;
2064  CHECK((*p0 != _f551),
2065  "void f551(const bool * const)");
2066 }
2067 
2068 void f552(const char * const p0)
2069 {
2070  TRACE("void f552(const char * const)");
2071  static char _f552 = 0;
2072  _f552++;
2073  CHECK((*p0 != _f552),
2074  "void f552(const char * const)");
2075 }
2076 
2077 void f553(const int8_t * const p0)
2078 {
2079  TRACE("void f553(const int8_t * const)");
2080  static int8_t _f553 = 0;
2081  _f553++;
2082  CHECK((*p0 != _f553),
2083  "void f553(const int8_t * const)");
2084 }
2085 
2086 void f554(const uint8_t * const p0)
2087 {
2088  TRACE("void f554(const uint8_t * const)");
2089  static uint8_t _f554 = 0;
2090  _f554++;
2091  CHECK((*p0 != _f554),
2092  "void f554(const uint8_t * const)");
2093 }
2094 
2095 void f555(const int16_t * const p0)
2096 {
2097  TRACE("void f555(const int16_t * const)");
2098  static int16_t _f555 = 0;
2099  _f555++;
2100  CHECK((*p0 != _f555),
2101  "void f555(const int16_t * const)");
2102 }
2103 
2104 void f556(const uint16_t * const p0)
2105 {
2106  TRACE("void f556(const uint16_t * const)");
2107  static uint16_t _f556 = 0;
2108  _f556++;
2109  CHECK((*p0 != _f556),
2110  "void f556(const uint16_t * const)");
2111 }
2112 
2113 void f557(const int32_t * const p0)
2114 {
2115  TRACE("void f557(const int32_t * const)");
2116  static int32_t _f557 = 0;
2117  _f557++;
2118  CHECK((*p0 != _f557),
2119  "void f557(const int32_t * const)");
2120 }
2121 
2122 void f558(const uint32_t * const p0)
2123 {
2124  TRACE("void f558(const uint32_t * const)");
2125  static uint32_t _f558 = 0;
2126  _f558++;
2127  CHECK((*p0 != _f558),
2128  "void f558(const uint32_t * const)");
2129 }
2130 
2131 void f561(const int64_t * const p0)
2132 {
2133  TRACE("void f561(const int64_t * const)");
2134  static int64_t _f561 = 0;
2135  _f561++;
2136  CHECK((*p0 != _f561),
2137  "void f561(const int64_t * const)");
2138 }
2139 
2140 void f562(const uint64_t * const p0)
2141 {
2142  TRACE("void f562(const uint64_t * const)");
2143  static uint64_t _f562 = 0;
2144  _f562++;
2145  CHECK((*p0 != _f562),
2146  "void f562(const uint64_t * const)");
2147 }
2148 
2149 void f563(const float * const p0)
2150 {
2151  TRACE("void f563(const float * const)");
2152  static float _f563 = 0;
2153  _f563++;
2154  CHECK((*p0 != _f563),
2155  "void f563(const float * const)");
2156 }
2157 
2158 void f564(const double * const p0)
2159 {
2160  TRACE("void f564(const double * const)");
2161  static double _f564 = 0;
2162  _f564++;
2163  CHECK((*p0 != _f564),
2164  "void f564(const double * const)");
2165 }
2166 
2167 void f571(bool * const p0)
2168 {
2169  TRACE("void f571(bool * const)");
2170  static bool _f571 = 0;
2171  _f571 = !_f571;
2172  CHECK((*p0 != _f571),
2173  "void f571(bool * const)");
2174  *p0 = !*p0;
2175  _f571 = !_f571;
2176 }
2177 
2178 void f572(char * const p0)
2179 {
2180  TRACE("void f572(char * const)");
2181  static char _f572 = 0;
2182  _f572++;
2183  CHECK((*p0 != _f572),
2184  "void f572(char * const)");
2185  (*p0)++;
2186  _f572++;
2187 }
2188 
2189 void f573(int8_t * const p0)
2190 {
2191  TRACE("void f573(int8_t * const)");
2192  static int8_t _f573 = 0;
2193  _f573++;
2194  CHECK((*p0 != _f573),
2195  "void f573(int8_t * const)");
2196  (*p0)++;
2197  _f573++;
2198 }
2199 
2200 void f574(uint8_t * const p0)
2201 {
2202  TRACE("void f574(uint8_t * const)");
2203  static uint8_t _f574 = 0;
2204  _f574++;
2205  CHECK((*p0 != _f574),
2206  "void f574(uint8_t * const)");
2207  (*p0)++;
2208  _f574++;
2209 }
2210 
2211 void f575(int16_t * const p0)
2212 {
2213  TRACE("void f575(int16_t * const)");
2214  static int16_t _f575 = 0;
2215  _f575++;
2216  CHECK((*p0 != _f575),
2217  "void f575(int16_t * const)");
2218  (*p0)++;
2219  _f575++;
2220 }
2221 
2222 void f576(uint16_t * const p0)
2223 {
2224  TRACE("void f576(uint16_t * const)");
2225  static uint16_t _f576 = 0;
2226  _f576++;
2227  CHECK((*p0 != _f576),
2228  "void f576(uint16_t * const)");
2229  (*p0)++;
2230  _f576++;
2231 }
2232 
2233 void f577(int32_t * const p0)
2234 {
2235  TRACE("void f577(int32_t * const)");
2236  static int32_t _f577 = 0;
2237  _f577++;
2238  CHECK((*p0 != _f577),
2239  "void f577(int32_t * const)");
2240  (*p0)++;
2241  _f577++;
2242 }
2243 
2244 void f578(uint32_t * const p0)
2245 {
2246  TRACE("void f578(uint32_t * const)");
2247  static uint32_t _f578 = 0;
2248  _f578++;
2249  CHECK((*p0 != _f578),
2250  "void f578(uint32_t * const)");
2251  (*p0)++;
2252  _f578++;
2253 }
2254 
2255 void f581(int64_t * const p0)
2256 {
2257  TRACE("void f581(int64_t * const)");
2258  static int64_t _f581 = 0;
2259  _f581++;
2260  CHECK((*p0 != _f581),
2261  "void f581(int64_t * const)");
2262  (*p0)++;
2263  _f581++;
2264 }
2265 
2266 void f582(uint64_t * const p0)
2267 {
2268  TRACE("void f582(uint64_t * const)");
2269  static uint64_t _f582 = 0;
2270  _f582++;
2271  CHECK((*p0 != _f582),
2272  "void f582(uint64_t * const)");
2273  (*p0)++;
2274  _f582++;
2275 }
2276 
2277 void f583(float * const p0)
2278 {
2279  TRACE("void f583(float * const)");
2280  static float _f583 = 0;
2281  _f583++;
2282  CHECK((*p0 != _f583),
2283  "void f583(float * const)");
2284  (*p0)++;
2285  _f583++;
2286 }
2287 
2288 void f584(double * const p0)
2289 {
2290  TRACE("void f584(double * const)");
2291  static double _f584 = 0;
2292  _f584++;
2293  CHECK((*p0 != _f584),
2294  "void f584(double * const)");
2295  (*p0)++;
2296  _f584++;
2297 }
2298 
2299 // ---------------------------------------------------------------------------
2300 
2301 const bool * f611()
2302 {
2303  TRACE("const bool * f611()");
2304  static bool _f611 = 1;
2305  return (((_f611 = !_f611) == 0) ? NULL : &_f611);
2306 }
2307 
2308 const char * f612()
2309 {
2310  TRACE("const char * f612()");
2311  static char _f612 = 1;
2312  return (((_f612 = (char)-_f612) != 1) ? NULL : &_f612);
2313 }
2314 
2315 const int8_t * f613()
2316 {
2317  TRACE("const int8_t * f613()");
2318  static int8_t _f613 = 1;
2319  return (((_f613 = (int8_t)-_f613) != 1) ? NULL : &_f613);
2320 }
2321 
2322 const uint8_t * f614()
2323 {
2324  TRACE("const uint8_t * f614()");
2325  static uint8_t _f614 = 1;
2326  return (((_f614 = (uint8_t)-_f614) != 1) ? NULL : &_f614);
2327 }
2328 
2329 const int16_t * f615()
2330 {
2331  TRACE("const int16_t * f615()");
2332  static int16_t _f615 = 1;
2333  return (((_f615 = (int16_t)-_f615) != 1) ? NULL : &_f615);
2334 }
2335 
2336 const uint16_t * f616()
2337 {
2338  TRACE("const uint16_t * f616()");
2339  static uint16_t _f616 = 1;
2340  return (((_f616 = (uint16_t)-_f616) != 1) ? NULL : &_f616);
2341 }
2342 
2343 const int32_t * f617()
2344 {
2345  TRACE("const int32_t * f617()");
2346  static int32_t _f617 = 1;
2347  return (((_f617 = (int32_t)-_f617) != 1) ? NULL : &_f617);
2348 }
2349 
2350 const uint32_t * f618()
2351 {
2352  TRACE("const uint32_t * f618()");
2353  static uint32_t _f618 = 1;
2354  return (((_f618 = (uint32_t)-_f618) != 1) ? NULL : &_f618);
2355 }
2356 
2357 const int64_t * f621()
2358 {
2359  TRACE("const int64_t * f621()");
2360  static int64_t _f621 = 1;
2361  return (((_f621 = (int64_t)-_f621) != 1) ? NULL : &_f621);
2362 }
2363 
2364 const uint64_t * f622()
2365 {
2366  TRACE("const uint64_t * f622()");
2367  static uint64_t _f622 = 1;
2368  return (((_f622 = (uint64_t)-_f622) != 1) ? NULL : &_f622);
2369 }
2370 
2371 const float * f623()
2372 {
2373  TRACE("const * float f623()");
2374  static float _f623 = 1;
2375  return (((_f623 = (float)-_f623) != 1) ? NULL : &_f623);
2376 }
2377 
2378 const double * f624()
2379 {
2380  TRACE("const double * f624()");
2381  static double _f624 = 1;
2382  return (((_f624 = (double)-_f624) != 1) ? NULL : &_f624);
2383 }
2384 
2385 bool * f631()
2386 {
2387  TRACE("bool * f631()");
2388  static bool _f631 = 1;
2389  return (((_f631 = !_f631) == 0) ? NULL : &_f631);
2390 }
2391 
2392 char * f632()
2393 {
2394  TRACE("char * f632()");
2395  static char _f632 = 1;
2396  return (((_f632 = (char)-_f632) != 1) ? NULL : &_f632);
2397 }
2398 
2399 int8_t * f633()
2400 {
2401  TRACE("int8_t * f633()");
2402  static int8_t _f633 = 1;
2403  return (((_f633 = (int8_t)-_f633) != 1) ? NULL : &_f633);
2404 }
2405 
2406 uint8_t * f634()
2407 {
2408  TRACE("uint8_t * f634()");
2409  static uint8_t _f634 = 1;
2410  return (((_f634 = (uint8_t)-_f634) != 1) ? NULL : &_f634);
2411 }
2412 
2413 int16_t * f635()
2414 {
2415  TRACE("int16_t * f635()");
2416  static int16_t _f635 = 1;
2417  return (((_f635 = (int16_t)-_f635) != 1) ? NULL : &_f635);
2418 }
2419 
2420 uint16_t * f636()
2421 {
2422  TRACE("uint16_t * f636()");
2423  static uint16_t _f636 = 1;
2424  return (((_f636 = (uint16_t)-_f636) != 1) ? NULL : &_f636);
2425 }
2426 
2427 int32_t * f637()
2428 {
2429  TRACE("int32_t * f637()");
2430  static int32_t _f637 = 1;
2431  return (((_f637 = (int32_t)-_f637) != 1) ? NULL : &_f637);
2432 }
2433 
2434 uint32_t * f638()
2435 {
2436  TRACE("uint32_t * f638()");
2437  static uint32_t _f638 = 1;
2438  return (((_f638 = (uint32_t)-_f638) != 1) ? NULL : &_f638);
2439 }
2440 
2441 int64_t * f641()
2442 {
2443  TRACE("int64_t * f641()");
2444  static int64_t _f641 = 1;
2445  return (((_f641 = (int64_t)-_f641) != 1) ? NULL : &_f641);
2446 }
2447 
2448 uint64_t * f642()
2449 {
2450  TRACE("uint64_t * f642()");
2451  static uint64_t _f642 = 1;
2452  return (((_f642 = (uint64_t)-_f642) != 1) ? NULL : &_f642);
2453 }
2454 
2455 float * f643()
2456 {
2457  TRACE("float * f643()");
2458  static float _f643 = 1;
2459  return (((_f643 = (float)-_f643) != 1) ? NULL : &_f643);
2460 }
2461 
2462 double * f644()
2463 {
2464  TRACE("double * f644()");
2465  static double _f644 = 1;
2466  return (((_f644 = (double)-_f644) != 1) ? NULL : &_f644);
2467 }
2468 
2469 const bool * const f651()
2470 {
2471  TRACE("const bool * const f651()");
2472  static bool _f651 = 1;
2473  return (((_f651 = !_f651) == 0) ? NULL : &_f651);
2474 }
2475 
2476 const char * const f652()
2477 {
2478  TRACE("const char * const f652()");
2479  static char _f652 = 1;
2480  return (((_f652 = (char)-_f652) != 1) ? NULL : &_f652);
2481 }
2482 
2483 const int8_t * const f653()
2484 {
2485  TRACE("const int8_t * const f653()");
2486  static int8_t _f653 = 1;
2487  return (((_f653 = (int8_t)-_f653) != 1) ? NULL : &_f653);
2488 }
2489 
2490 const uint8_t * const f654()
2491 {
2492  TRACE("const uint8_t * const f654()");
2493  static uint8_t _f654 = 1;
2494  return (((_f654 = (uint8_t)-_f654) != 1) ? NULL : &_f654);
2495 }
2496 
2497 const int16_t * const f655()
2498 {
2499  TRACE("const int16_t * const f655()");
2500  static int16_t _f655 = 1;
2501  return (((_f655 = (int16_t)-_f655) != 1) ? NULL : &_f655);
2502 }
2503 
2504 const uint16_t * const f656()
2505 {
2506  TRACE("const uint16_t * const f656()");
2507  static uint16_t _f656 = 1;
2508  return (((_f656 = (uint16_t)-_f656) != 1) ? NULL : &_f656);
2509 }
2510 
2511 const int32_t * const f657()
2512 {
2513  TRACE("const int32_t * const f657()");
2514  static int32_t _f657 = 1;
2515  return (((_f657 = (int32_t)-_f657) != 1) ? NULL : &_f657);
2516 }
2517 
2518 const uint32_t * const f658()
2519 {
2520  TRACE("const uint32_t * const f658()");
2521  static uint32_t _f658 = 1;
2522  return (((_f658 = (uint32_t)-_f658) != 1) ? NULL : &_f658);
2523 }
2524 
2525 const int64_t * const f661()
2526 {
2527  TRACE("const int64_t * const f661()");
2528  static int64_t _f661 = 1;
2529  return (((_f661 = (int64_t)-_f661) != 1) ? NULL : &_f661);
2530 }
2531 
2532 const uint64_t * const f662()
2533 {
2534  TRACE("const uint64_t * const f662()");
2535  static uint64_t _f662 = 1;
2536  return (((_f662 = (uint64_t)-_f662) != 1) ? NULL : &_f662);
2537 }
2538 
2539 const float * const f663()
2540 {
2541  TRACE("const * float const f663()");
2542  static float _f663 = 1;
2543  return (((_f663 = (float)-_f663) != 1) ? NULL : &_f663);
2544 }
2545 
2546 const double * const f664()
2547 {
2548  TRACE("const double * const f664()");
2549  static double _f664 = 1;
2550  return (((_f664 = (double)-_f664) != 1) ? NULL : &_f664);
2551 }
2552 
2553 bool * const f671()
2554 {
2555  TRACE("bool * const f671()");
2556  static bool _f671 = 1;
2557  return (((_f671 = !_f671) == 0) ? NULL : &_f671);
2558 }
2559 
2560 char * const f672()
2561 {
2562  TRACE("char * const f672()");
2563  static char _f672 = 1;
2564  return (((_f672 = (char)-_f672) != 1) ? NULL : &_f672);
2565 }
2566 
2567 int8_t * const f673()
2568 {
2569  TRACE("int8_t * const f673()");
2570  static int8_t _f673 = 1;
2571  return (((_f673 = (int8_t)-_f673) != 1) ? NULL : &_f673);
2572 }
2573 
2574 uint8_t * const f674()
2575 {
2576  TRACE("uint8_t * const f674()");
2577  static uint8_t _f674 = 1;
2578  return (((_f674 = (uint8_t)-_f674) != 1) ? NULL : &_f674);
2579 }
2580 
2581 int16_t * const f675()
2582 {
2583  TRACE("int16_t * const f675()");
2584  static int16_t _f675 = 1;
2585  return (((_f675 = (int16_t)-_f675) != 1) ? NULL : &_f675);
2586 }
2587 
2588 uint16_t * const f676()
2589 {
2590  TRACE("uint16_t * const f676()");
2591  static uint16_t _f676 = 1;
2592  return (((_f676 = (uint16_t)-_f676) != 1) ? NULL : &_f676);
2593 }
2594 
2595 int32_t * const f677()
2596 {
2597  TRACE("int32_t * const f677()");
2598  static int32_t _f677 = 1;
2599  return (((_f677 = (int32_t)-_f677) != 1) ? NULL : &_f677);
2600 }
2601 
2602 uint32_t * const f678()
2603 {
2604  TRACE("uint32_t * const f678()");
2605  static uint32_t _f678 = 1;
2606  return (((_f678 = (uint32_t)-_f678) != 1) ? NULL : &_f678);
2607 }
2608 
2609 int64_t * const f681()
2610 {
2611  TRACE("int64_t * const f681()");
2612  static int64_t _f681 = 1;
2613  return (((_f681 = (int64_t)-_f681) != 1) ? NULL : &_f681);
2614 }
2615 
2616 uint64_t * const f682()
2617 {
2618  TRACE("uint64_t * const f682()");
2619  static uint64_t _f682 = 1;
2620  return (((_f682 = (uint64_t)-_f682) != 1) ? NULL : &_f682);
2621 }
2622 
2623 float * const f683()
2624 {
2625  TRACE("float * const f683()");
2626  static float _f683 = 1;
2627  return (((_f683 = (float)-_f683) != 1) ? NULL : &_f683);
2628 }
2629 
2630 double * const f684()
2631 {
2632  TRACE("double * const f684()");
2633  static double _f684 = 1;
2634  return (((_f684 = (double)-_f684) != 1) ? NULL : &_f684);
2635 }
2636 
2637 // ---------------------------------------------------------------------------
2638 
2639 void f711(const bool * p0)
2640 {
2641  TRACE("void f711(const bool *)");
2642  static bool _f711 = 1;
2643  CHECK((((_f711 = !_f711) == 0) ^ (p0 == NULL)),
2644  "void f711(const bool *)");
2645 }
2646 
2647 void f712(const char * p0)
2648 {
2649  TRACE("void f712(const char *)");
2650  static char _f712 = 1;
2651  CHECK((((_f712 = (char)-_f712) != 1) ^ (p0 == NULL)),
2652  "void f712(const char *)");
2653 }
2654 
2655 void f713(const int8_t * p0)
2656 {
2657  TRACE("void f713(const int8_t *)");
2658  static int8_t _f713 = 1;
2659  CHECK((((_f713 = (int8_t)-_f713) != 1) ^ (p0 == NULL)),
2660  "void f713(const int8_t *)");
2661 }
2662 
2663 void f714(const uint8_t * p0)
2664 {
2665  TRACE("void f714(const uint8_t *)");
2666  static uint8_t _f714 = 1;
2667  CHECK((((_f714 = (uint8_t)-_f714) != 1) ^ (p0 == NULL)),
2668  "void f714(const uint8_t *)");
2669 }
2670 
2671 void f715(const int16_t * p0)
2672 {
2673  TRACE("void f715(const int16_t *)");
2674  static int16_t _f715 = 1;
2675  CHECK((((_f715 = (int16_t)-_f715) != 1) ^ (p0 == NULL)),
2676  "void f715(const int16_t *)");
2677 }
2678 
2679 void f716(const uint16_t * p0)
2680 {
2681  TRACE("void f716(const uint16_t *)");
2682  static uint16_t _f716 = 1;
2683  CHECK((((_f716 = (uint16_t)-_f716) != 1) ^ (p0 == NULL)),
2684  "void f716(const uint16_t *)");
2685 }
2686 
2687 void f717(const int32_t * p0)
2688 {
2689  TRACE("void f717(const int32_t *)");
2690  static int32_t _f717 = 1;
2691  CHECK((((_f717 = (int32_t)-_f717) != 1) ^ (p0 == NULL)),
2692  "void f717(const int32_t *)");
2693 }
2694 
2695 void f718(const uint32_t * p0)
2696 {
2697  TRACE("void f718(const uint32_t *)");
2698  static uint32_t _f718 = 1;
2699  CHECK((((_f718 = (uint32_t)-_f718) != 1) ^ (p0 == NULL)),
2700  "void f718(const uint32_t *)");
2701 }
2702 
2703 void f721(const int64_t * p0)
2704 {
2705  TRACE("void f721(const int64_t *)");
2706  static int64_t _f721 = 1;
2707  CHECK((((_f721 = (int64_t)-_f721) != 1) ^ (p0 == NULL)),
2708  "void f721(const int64_t *)");
2709 }
2710 
2711 void f722(const uint64_t * p0)
2712 {
2713  TRACE("void f722(const uint64_t *)");
2714  static uint64_t _f722 = 1;
2715  CHECK((((_f722 = (uint64_t)-_f722) != 1) ^ (p0 == NULL)),
2716  "void f722(const uint64_t *)");
2717 }
2718 
2719 void f723(const float * p0)
2720 {
2721  TRACE("void f723(const float *)");
2722  static float _f723 = 1;
2723  CHECK((((_f723 = (float)-_f723) != 1) ^ (p0 == NULL)),
2724  "void f723(const float *)");
2725 }
2726 
2727 void f724(const double * p0)
2728 {
2729  TRACE("void f724(const double *)");
2730  static double _f724 = 1;
2731  CHECK((((_f724 = (double)-_f724) != 1) ^ (p0 == NULL)),
2732  "void f724(const double *)");
2733 }
2734 
2735 void f731(bool * p0)
2736 {
2737  TRACE("void f731(bool *)");
2738  static bool _f731 = 1;
2739  CHECK((((_f731 = !_f731) == 0) ^ (p0 == NULL)),
2740  "void f731(bool *)");
2741 }
2742 
2743 void f732(char * p0)
2744 {
2745  TRACE("void f732(char *)");
2746  static char _f732 = 1;
2747  CHECK((((_f732 = (char)-_f732) != 1) ^ (p0 == NULL)),
2748  "void f732(char *)");
2749 }
2750 
2751 void f733(int8_t * p0)
2752 {
2753  TRACE("void f733(int8_t *)");
2754  static int8_t _f733 = 1;
2755  CHECK((((_f733 = (int8_t)-_f733) != 1) ^ (p0 == NULL)),
2756  "void f733(int8_t *)");
2757 }
2758 
2759 void f734(uint8_t * p0)
2760 {
2761  TRACE("void f734(uint8_t *)");
2762  static uint8_t _f734 = 1;
2763  CHECK((((_f734 = (uint8_t)-_f734) != 1) ^ (p0 == NULL)),
2764  "void f734(uint8_t *)");
2765 }
2766 
2767 void f735(int16_t * p0)
2768 {
2769  TRACE("void f735(int16_t *)");
2770  static int16_t _f735 = 1;
2771  CHECK((((_f735 = (int16_t)-_f735) != 1) ^ (p0 == NULL)),
2772  "void f735(int16_t *)");
2773 }
2774 
2775 void f736(uint16_t * p0)
2776 {
2777  TRACE("void f736(uint16_t *)");
2778  static uint16_t _f736 = 1;
2779  CHECK((((_f736 = (uint16_t)-_f736) != 1) ^ (p0 == NULL)),
2780  "void f736(uint16_t *)");
2781 }
2782 
2783 void f737(int32_t * p0)
2784 {
2785  TRACE("void f737(int32_t *)");
2786  static int32_t _f737 = 1;
2787  CHECK((((_f737 = (int32_t)-_f737) != 1) ^ (p0 == NULL)),
2788  "void f737(int32_t *)");
2789 }
2790 
2791 void f738(uint32_t * p0)
2792 {
2793  TRACE("void f738(uint32_t *)");
2794  static uint32_t _f738 = 1;
2795  CHECK((((_f738 = (uint32_t)-_f738) != 1) ^ (p0 == NULL)),
2796  "void f738(uint32_t *)");
2797 }
2798 
2799 void f741(int64_t * p0)
2800 {
2801  TRACE("void f741(int64_t *)");
2802  static int64_t _f741 = 1;
2803  CHECK((((_f741 = (int64_t)-_f741) != 1) ^ (p0 == NULL)),
2804  "void f741(int64_t *)");
2805 }
2806 
2807 void f742(uint64_t * p0)
2808 {
2809  TRACE("void f742(uint64_t *)");
2810  static uint64_t _f742 = 1;
2811  CHECK((((_f742 = (uint64_t)-_f742) != 1) ^ (p0 == NULL)),
2812  "void f742(uint64_t *)");
2813 }
2814 
2815 void f743(float * p0)
2816 {
2817  TRACE("void f743(float *)");
2818  static float _f743 = 1;
2819  CHECK((((_f743 = (float)-_f743) != 1) ^ (p0 == NULL)),
2820  "void f743(float *)");
2821 }
2822 
2823 void f744(double * p0)
2824 {
2825  TRACE("void f744(double *)");
2826  static double _f744 = 1;
2827  CHECK((((_f744 = (double)-_f744) != 1) ^ (p0 == NULL)),
2828  "void f744(double *)");
2829 }
2830 
2831 void f751(const bool * const p0)
2832 {
2833  TRACE("void f751(const bool * const)");
2834  static bool _f751 = 1;
2835  CHECK((((_f751 = !_f751) == 0) ^ (p0 == NULL)),
2836  "void f751(const bool * const)");
2837 }
2838 
2839 void f752(const char * const p0)
2840 {
2841  TRACE("void f752(const char * const)");
2842  static char _f752 = 1;
2843  CHECK((((_f752 = (char)-_f752) != 1) ^ (p0 == NULL)),
2844  "void f752(const char * const)");
2845 }
2846 
2847 void f753(const int8_t * const p0)
2848 {
2849  TRACE("void f753(const int8_t * const)");
2850  static int8_t _f753 = 1;
2851  CHECK((((_f753 = (int8_t)-_f753) != 1) ^ (p0 == NULL)),
2852  "void f753(const int8_t * const)");
2853 }
2854 
2855 void f754(const uint8_t * const p0)
2856 {
2857  TRACE("void f754(const uint8_t * const)");
2858  static uint8_t _f754 = 1;
2859  CHECK((((_f754 = (uint8_t)-_f754) != 1) ^ (p0 == NULL)),
2860  "void f754(const uint8_t * const)");
2861 }
2862 
2863 void f755(const int16_t * const p0)
2864 {
2865  TRACE("void f755(const int16_t * const)");
2866  static int16_t _f755 = 1;
2867  CHECK((((_f755 = (int16_t)-_f755) != 1) ^ (p0 == NULL)),
2868  "void f755(const int16_t * const)");
2869 }
2870 
2871 void f756(const uint16_t * const p0)
2872 {
2873  TRACE("void f756(const uint16_t * const)");
2874  static uint16_t _f756 = 1;
2875  CHECK((((_f756 = (uint16_t)-_f756) != 1) ^ (p0 == NULL)),
2876  "void f756(const uint16_t * const)");
2877 }
2878 
2879 void f757(const int32_t * const p0)
2880 {
2881  TRACE("void f757(const int32_t * const)");
2882  static int32_t _f757 = 1;
2883  CHECK((((_f757 = (int32_t)-_f757) != 1) ^ (p0 == NULL)),
2884  "void f757(const int32_t * const)");
2885 }
2886 
2887 void f758(const uint32_t * const p0)
2888 {
2889  TRACE("void f758(const uint32_t * const)");
2890  static uint32_t _f758 = 1;
2891  CHECK((((_f758 = (uint32_t)-_f758) != 1) ^ (p0 == NULL)),
2892  "void f758(const uint32_t * const)");
2893 }
2894 
2895 void f761(const int64_t * const p0)
2896 {
2897  TRACE("void f761(const int64_t * const)");
2898  static int64_t _f761 = 1;
2899  CHECK((((_f761 = (int64_t)-_f761) != 1) ^ (p0 == NULL)),
2900  "void f761(const int64_t * const)");
2901 }
2902 
2903 void f762(const uint64_t * const p0)
2904 {
2905  TRACE("void f762(const uint64_t * const)");
2906  static uint64_t _f762 = 1;
2907  CHECK((((_f762 = (uint64_t)-_f762) != 1) ^ (p0 == NULL)),
2908  "void f762(const uint64_t * const)");
2909 }
2910 
2911 void f763(const float * const p0)
2912 {
2913  TRACE("void f763(const float * const)");
2914  static float _f763 = 1;
2915  CHECK((((_f763 = (float)-_f763) != 1) ^ (p0 == NULL)),
2916  "void f763(const float * const)");
2917 }
2918 
2919 void f764(const double * const p0)
2920 {
2921  TRACE("void f764(const double * const)");
2922  static double _f764 = 1;
2923  CHECK((((_f764 = (double)-_f764) != 1) ^ (p0 == NULL)),
2924  "void f764(const double * const)");
2925 }
2926 
2927 void f771(bool * const p0)
2928 {
2929  TRACE("void f771(bool * const)");
2930  static bool _f771 = 1;
2931  CHECK((((_f771 = !_f771) == 0) ^ (p0 == NULL)),
2932  "void f771(bool * const)");
2933 }
2934 
2935 void f772(char * const p0)
2936 {
2937  TRACE("void f772(char * const)");
2938  static char _f772 = 1;
2939  CHECK((((_f772 = (char)-_f772) != 1) ^ (p0 == NULL)),
2940  "void f772(char * const)");
2941 }
2942 
2943 void f773(int8_t * const p0)
2944 {
2945  TRACE("void f773(int8_t * const)");
2946  static int8_t _f773 = 1;
2947  CHECK((((_f773 = (int8_t)-_f773) != 1) ^ (p0 == NULL)),
2948  "void f773(int8_t * const)");
2949 }
2950 
2951 void f774(uint8_t * const p0)
2952 {
2953  TRACE("void f774(uint8_t * const)");
2954  static uint8_t _f774 = 1;
2955  CHECK((((_f774 = (uint8_t)-_f774) != 1) ^ (p0 == NULL)),
2956  "void f774(uint8_t * const)");
2957 }
2958 
2959 void f775(int16_t * const p0)
2960 {
2961  TRACE("void f775(int16_t * const)");
2962  static int16_t _f775 = 1;
2963  CHECK((((_f775 = (int16_t)-_f775) != 1) ^ (p0 == NULL)),
2964  "void f775(int16_t * const)");
2965 }
2966 
2967 void f776(uint16_t * const p0)
2968 {
2969  TRACE("void f776(uint16_t * const)");
2970  static uint16_t _f776 = 1;
2971  CHECK((((_f776 = (uint16_t)-_f776) != 1) ^ (p0 == NULL)),
2972  "void f776(uint16_t * const)");
2973 }
2974 
2975 void f777(int32_t * const p0)
2976 {
2977  TRACE("void f777(int32_t * const)");
2978  static int32_t _f777 = 1;
2979  CHECK((((_f777 = (int32_t)-_f777) != 1) ^ (p0 == NULL)),
2980  "void f777(int32_t * const)");
2981 }
2982 
2983 void f778(uint32_t * const p0)
2984 {
2985  TRACE("void f778(uint32_t * const)");
2986  static uint32_t _f778 = 1;
2987  CHECK((((_f778 = (uint32_t)-_f778) != 1) ^ (p0 == NULL)),
2988  "void f778(uint32_t * const)");
2989 }
2990 
2991 void f781(int64_t * const p0)
2992 {
2993  TRACE("void f781(int64_t * const)");
2994  static int64_t _f781 = 1;
2995  CHECK((((_f781 = (int64_t)-_f781) != 1) ^ (p0 == NULL)),
2996  "void f781(int64_t * const)");
2997 }
2998 
2999 void f782(uint64_t * const p0)
3000 {
3001  TRACE("void f782(uint64_t * const)");
3002  static uint64_t _f782 = 1;
3003  CHECK((((_f782 = (uint64_t)-_f782) != 1) ^ (p0 == NULL)),
3004  "void f782(uint64_t * const)");
3005 }
3006 
3007 void f783(float * const p0)
3008 {
3009  TRACE("void f783(float * const)");
3010  static float _f783 = 1;
3011  CHECK((((_f783 = (float)-_f783) != 1) ^ (p0 == NULL)),
3012  "void f783(float * const)");
3013 }
3014 
3015 void f784(double * const p0)
3016 {
3017  TRACE("void f784(double * const)");
3018  static double _f784 = 1;
3019  CHECK((((_f784 = (double)-_f784) != 1) ^ (p0 == NULL)),
3020  "void f784(double * const)");
3021 }
3022 
3023 // ---------------------------------------------------------------------------