1 /*
2  Copyright (c) 2010, 2021, Oracle and/or its affiliates.
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, version 2.0,
6  as published by the Free Software Foundation.
7 
8  This program is also distributed with certain software (including
9  but not limited to OpenSSL) that is licensed under separate terms,
10  as designated in a particular file or component or in included license
11  documentation.  The authors of MySQL hereby grant you an additional
12  permission to link the program and your derivative works with the
13  separately licensed software that they have included with MySQL.
14 
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  GNU General Public License, version 2.0, for more details.
19 
20  You should have received a copy of the GNU General Public License
21  along with this program; if not, write to the Free Software
22  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
23 */
24 /*
25  * myapi.cpp
26  */
27 
28 #include <my_config.h>
29 #include <stdio.h> // not using namespaces yet
30 #include <string.h> // not using namespaces yet
31 
32 #include "myapi.hpp"
33 #include "helpers.hpp"
34 
35 // ---------------------------------------------------------------------------
36 // static initializations
37 // ---------------------------------------------------------------------------
38 
39 int32_t B0::d0s = 20;
40 const int32_t B0::d0sc = -20;
41 
42 int32_t B1::d0s = 30;
43 const int32_t B1::d0sc = -30;
44 
45 A * A::a = NULL;
46 int32_t A::d0s = 10;
47 const int32_t A::d0sc = -10;
48 
init()49 void B0::init() {
50 }
51 
finit()52 void B0::finit() {
53 }
54 
init()55 void B1::init() {
56 }
57 
finit()58 void B1::finit() {
59 }
60 
init()61 void A::init() {
62     //printf("    XXX A::a = %p\n", A::a);
63     assert(!A::a);
64     A::a = new A();
65     //printf("    YYY A::a = %p\n", A::a);
66 }
67 
finit()68 void A::finit() {
69     //printf("    ZZZ A::a = %p\n", A::a);
70     assert(A::a);
71     delete A::a;
72     A::a = NULL;
73 }
74 
75 // ----------------------------------------
76 
77 const C0 * C0::cc = NULL;
78 C0 * C0::c = NULL;
79 
80 const C1 * C1::cc = NULL;
81 C1 * C1::c = NULL;
82 
init()83 void C0::init() {
84     //printf("    XXX C0::c = %p, C0::cc = %p\n", C0::c, C0::cc);
85     //printf("    XXX C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
86     assert(!C0::c);
87     assert(!C0::cc);
88     assert(C1::c);
89     assert(C1::cc);
90     C0::c = C1::c;
91     C0::cc = C1::cc;
92     //printf("    YYY C0::c = %p, C0::cc = %p\n", C0::c, C0::cc);
93 }
94 
finit()95 void C0::finit() {
96     //printf("    ZZZ C0::c = %p, C0::cc = %p\n", C0::c, C0::cc);
97     assert(C0::c);
98     assert(C0::cc);
99     C0::c = NULL;
100     C0::cc = NULL;
101 }
102 
init()103 void C1::init() {
104     //printf("    XXX C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
105     assert(!C1::c);
106     assert(!C1::cc);
107     C1::c = new C1();
108     C1::cc = new C1();
109     //printf("    YYY C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
110 }
111 
finit()112 void C1::finit() {
113     //printf("    ZZZ C1::c = %p, C1::cc = %p\n", C1::c, C1::cc);
114     assert(C1::c);
115     assert(C1::cc);
116     delete C1::c;
117     delete C1::cc;
118     C1::c = NULL;
119     C1::cc = NULL;
120 }
121 
122 // ----------------------------------------
123 
124 D0 * D0::d = NULL;
125 D1 * D1::d = NULL;
126 D2 * D2::d = NULL;
127 
init()128 void D0::init() {
129     //printf("    XXX D0::d = %p\n", D0::d);
130     assert(!D0::d);
131     D0::d = new D0();
132     //printf("    YYY D0::d = %p\n", D0::d);
133 }
134 
finit()135 void D0::finit() {
136     //printf("    ZZZ D0::d = %p\n", D0::d);
137     assert(D0::d);
138     delete D0::d;
139     D0::d = NULL;
140 }
141 
init()142 void D1::init() {
143     //printf("    XXX D1::d = %p\n", D1::d);
144     assert(!D1::d);
145     D1::d = new D1();
146     //printf("    YYY D1::d = %p\n", D1::d);
147 }
148 
finit()149 void D1::finit() {
150     //printf("    ZZZ D1::d = %p\n", D1::d);
151     assert(D1::d);
152     delete D1::d;
153     D1::d = NULL;
154 }
155 
init()156 void D2::init() {
157     //printf("    XXX D2::d = %p\n", D2::d);
158     assert(!D2::d);
159     D2::d = new D2();
160     //printf("    YYY D2::d = %p\n", D2::d);
161 }
162 
finit()163 void D2::finit() {
164     //printf("    ZZZ D2::d = %p\n", D2::d);
165     assert(D2::d);
166     delete D2::d;
167     D2::d = NULL;
168 }
169 
170 // ----------------------------------------
171 
myapi_init()172 void myapi_init() {
173     // some order dependencies
174     D2::init();
175     D1::init();
176     D0::init();
177     C1::init();
178     C0::init();
179     B1::init();
180     B0::init();
181     A::init();
182 }
183 
myapi_finit()184 void myapi_finit() {
185     A::finit();
186     B0::finit();
187     B1::finit();
188     C0::finit();
189     C1::finit();
190     D0::finit();
191     D1::finit();
192     D2::finit();
193 }
194 
195 // ---------------------------------------------------------------------------
196 
f0()197 void f0()
198 {
199     TRACE("void f0()");
200 }
201 
202 // ---------------------------------------------------------------------------
203 
204 static const char * XYZ = "XYZ";
205 static char xyz[4] = { 'x', 'y', 'z', '\0' };
206 
s010()207 const void * s010()
208 {
209     TRACE("const void * s010()");
210     return XYZ;
211 }
212 
s012()213 const char * s012()
214 {
215     TRACE("const char * s012()");
216     return XYZ;
217 }
218 
s030()219 void * s030()
220 {
221     TRACE("void * s030()");
222     return xyz;
223 }
224 
s032()225 char * s032()
226 {
227     TRACE("char * s032()");
228     return xyz;
229 }
230 
s110(const void * p0)231 void s110(const void * p0)
232 {
233     TRACE("void s110(const void *)");
234     CHECK((strcmp((const char*)p0, xyz) != 0 && strcmp((const char*)p0, XYZ) != 0),
235           "void s110(const void *)");
236 }
237 
s112(const char * p0)238 void s112(const char * p0)
239 {
240     TRACE("void s112(const char *)");
241     CHECK((strcmp(p0, xyz) != 0 && strcmp(p0, XYZ) != 0),
242           "void s112(const char *)");
243 }
244 
s130(void * p0)245 void s130(void * p0)
246 {
247     TRACE("void s130(void *)");
248     CHECK((strcmp((const char*)p0, xyz) != 0 && strcmp((const char*)p0, XYZ) != 0),
249           "void s130(void *)");
250 }
251 
s132(char * p0)252 void s132(char * p0)
253 {
254     TRACE("void s132(char *)");
255     CHECK((strcmp(p0, xyz) != 0 && strcmp(p0, XYZ) != 0),
256           "void s132(char *)");
257 }
258 
s150(const void * const p0)259 void s150(const void * const p0)
260 {
261     TRACE("void s150(const void * const)");
262     CHECK((strcmp((const char*)p0, xyz) != 0 && strcmp((const char*)p0, XYZ) != 0),
263           "void s150(const void * const)");
264 }
265 
s152(const char * const p0)266 void s152(const char * const p0)
267 {
268     TRACE("void s152(const char * const)");
269     CHECK((strcmp(p0, xyz) != 0 && strcmp(p0, XYZ) != 0),
270           "void s152(const char * const)");
271 }
272 
s170(void * const p0)273 void s170(void * const p0)
274 {
275     TRACE("void s170(void * const)");
276     CHECK((strcmp((const char*)p0, xyz) != 0 && strcmp((const char*)p0, XYZ) != 0),
277           "void s170(void * const)");
278 }
279 
s172(char * const p0)280 void s172(char * const p0)
281 {
282     TRACE("void s172(char * const)");
283     CHECK((strcmp(p0, xyz) != 0 && strcmp(p0, XYZ) != 0),
284           "void s172(char * const)");
285 }
286 
287 // ---------------------------------------------------------------------------
288 
s210()289 const void * s210()
290 {
291     TRACE("const void * s210()");
292     return NULL;
293 }
294 
s212()295 const char * s212()
296 {
297     TRACE("const char * s212()");
298     return NULL;
299 }
300 
s230()301 void * s230()
302 {
303     TRACE("void * s230()");
304     return NULL;
305 }
306 
s232()307 char * s232()
308 {
309     TRACE("char * s232()");
310     return NULL;
311 }
312 
s310(const void * p0)313 void s310(const void * p0)
314 {
315     TRACE("void s310(const void *)");
316     (void)p0;
317 }
318 
s312(const char * p0)319 void s312(const char * p0)
320 {
321     TRACE("void s312(const char *)");
322     (void)p0;
323 }
324 
s330(void * p0)325 void s330(void * p0)
326 {
327     TRACE("void s330(void *)");
328     (void)p0;
329 }
330 
s332(char * p0)331 void s332(char * p0)
332 {
333     TRACE("void s332(char *)");
334     (void)p0;
335 }
336 
s350(const void * const p0)337 void s350(const void * const p0)
338 {
339     TRACE("void s350(const void * const)");
340     (void)p0;
341 }
342 
s352(const char * const p0)343 void s352(const char * const p0)
344 {
345     TRACE("void s352(const char * const)");
346     (void)p0;
347 }
348 
s370(void * const p0)349 void s370(void * const p0)
350 {
351     TRACE("void s370(void * const)");
352     (void)p0;
353 }
354 
s372(char * const p0)355 void s372(char * const p0)
356 {
357     TRACE("void s372(char * const)");
358     (void)p0;
359 }
360 
361 // ---------------------------------------------------------------------------
362 
f31(bool p0)363 bool f31(bool p0)
364 {
365     TRACE("bool f31(bool)");
366     return p0;
367 }
368 
f32(char p0)369 char f32(char p0)
370 {
371     TRACE("char f32(char)");
372     return p0;
373 }
374 
f33(signed char p0)375 signed char f33(signed char p0)
376 {
377     TRACE("signed char f33(signed char)");
378     return p0;
379 }
380 
f34(unsigned char p0)381 unsigned char f34(unsigned char p0)
382 {
383     TRACE("unsigned char f34(unsigned char)");
384     return p0;
385 }
386 
f35(signed short p0)387 signed short f35(signed short p0)
388 {
389     TRACE("signed short f35(signed short)");
390     return p0;
391 }
392 
f36(unsigned short p0)393 unsigned short f36(unsigned short p0)
394 {
395     TRACE("unsigned short f36(unsigned short)");
396     return p0;
397 }
398 
f37(signed int p0)399 signed int f37(signed int p0)
400 {
401     TRACE("signed int f37(signed int)");
402     return p0;
403 }
404 
f38(unsigned int p0)405 unsigned int f38(unsigned int p0)
406 {
407     TRACE("unsigned int f38(unsigned int)");
408     return p0;
409 }
410 
f39(signed long p0)411 signed long f39(signed long p0)
412 {
413     TRACE("signed long f39(signed long)");
414     return p0;
415 }
416 
f40(unsigned long p0)417 unsigned long f40(unsigned long p0)
418 {
419     TRACE("unsigned long f40(unsigned long)");
420     return p0;
421 }
422 
f41(signed long long p0)423 signed long long f41(signed long long p0)
424 {
425     TRACE("signed long long f41(signed long long)");
426     return p0;
427 }
428 
f42(unsigned long long p0)429 unsigned long long f42(unsigned long long p0)
430 {
431     TRACE("unsigned long long f42(unsigned long long)");
432     return p0;
433 }
434 
f43(float p0)435 float f43(float p0)
436 {
437     TRACE("float f43(float)");
438     return p0;
439 }
440 
f44(double p0)441 double f44(double p0)
442 {
443     TRACE("double f44(double)");
444     return p0;
445 }
446 
f45(long double p0)447 long double f45(long double p0)
448 {
449     TRACE("long double f45(long double)");
450     return p0;
451 }
452 
453 // ---------------------------------------------------------------------------
454 
f031()455 bool f031()
456 {
457     TRACE("bool f031()");
458     static bool _f031 = 0;
459     _f031 = !_f031;
460     return _f031;
461 }
462 
f032()463 char f032()
464 {
465     TRACE("char f032()");
466     static char _f032 = 0;
467     _f032++;
468     return _f032;
469 }
470 
f033()471 int8_t f033()
472 {
473     TRACE("int8_t f033()");
474     static int8_t _f033 = 0;
475     _f033++;
476     return _f033;
477 }
478 
f034()479 uint8_t f034()
480 {
481     TRACE("uint8_t f034()");
482     static uint8_t _f034 = 0;
483     _f034++;
484     return _f034;
485 }
486 
f035()487 int16_t f035()
488 {
489     TRACE("int16_t f035()");
490     static int16_t _f035 = 0;
491     _f035++;
492     return _f035;
493 }
494 
f036()495 uint16_t f036()
496 {
497     TRACE("uint16_t f036()");
498     static uint16_t _f036 = 0;
499     _f036++;
500     return _f036;
501 }
502 
f037()503 int32_t f037()
504 {
505     TRACE("int32_t f037()");
506     static int32_t _f037 = 0;
507     _f037++;
508     return _f037;
509 }
510 
f038()511 uint32_t f038()
512 {
513     TRACE("uint32_t f038()");
514     static uint32_t _f038 = 0;
515     _f038++;
516     return _f038;
517 }
518 
f041()519 int64_t f041()
520 {
521     TRACE("int64_t f041()");
522     static int64_t _f041 = 0;
523     _f041++;
524     return _f041;
525 }
526 
f042()527 uint64_t f042()
528 {
529     TRACE("uint64_t f042()");
530     static uint64_t _f042 = 0;
531     _f042++;
532     return _f042;
533 }
534 
f043()535 float f043()
536 {
537     TRACE("float f043()");
538     static float _f043 = 0;
539     _f043++;
540     return _f043;
541 }
542 
f044()543 double f044()
544 {
545     TRACE("double f044()");
546     static double _f044 = 0;
547     _f044++;
548     return _f044;
549 }
550 
551 // ---------------------------------------------------------------------------
552 
f111(const bool p0)553 void f111(const bool p0)
554 {
555     TRACE("void f111(const bool)");
556     static bool _f111 = 0;
557     _f111 = !_f111;
558     CHECK((p0 != _f111),
559           "void f111(const bool)");
560 }
561 
f112(const char p0)562 void f112(const char p0)
563 {
564     TRACE("void f112(const char)");
565     static char _f112 = 0;
566     _f112++;
567     CHECK((p0 != _f112),
568           "void f112(const char)");
569 }
570 
f113(const int8_t p0)571 void f113(const int8_t p0)
572 {
573     TRACE("void f113(const int8_t)");
574     static int8_t _f113 = 0;
575     _f113++;
576     CHECK((p0 != _f113),
577           "void f113(const int8_t)");
578 }
579 
f114(const uint8_t p0)580 void f114(const uint8_t p0)
581 {
582     TRACE("void f114(const uint8_t)");
583     static uint8_t _f114 = 0;
584     _f114++;
585     CHECK((p0 != _f114),
586           "void f114(const uint8_t)");
587 }
588 
f115(const int16_t p0)589 void f115(const int16_t p0)
590 {
591     TRACE("void f115(const int16_t)");
592     static int16_t _f115 = 0;
593     _f115++;
594     CHECK((p0 != _f115),
595           "void f115(const int16_t)");
596 }
597 
f116(const uint16_t p0)598 void f116(const uint16_t p0)
599 {
600     TRACE("void f116(const uint16_t)");
601     static uint16_t _f116 = 0;
602     _f116++;
603     CHECK((p0 != _f116),
604           "void f116(const uint16_t)");
605 }
606 
f117(const int32_t p0)607 void f117(const int32_t p0)
608 {
609     TRACE("void f117(const int32_t)");
610     static int32_t _f117 = 0;
611     _f117++;
612     CHECK((p0 != _f117),
613           "void f117(const int32_t)");
614 }
615 
f118(const uint32_t p0)616 void f118(const uint32_t p0)
617 {
618     TRACE("void f118(const uint32_t)");
619     static uint32_t _f118 = 0;
620     _f118++;
621     CHECK((p0 != _f118),
622           "void f118(const uint32_t)");
623 }
624 
f121(const int64_t p0)625 void f121(const int64_t p0)
626 {
627     TRACE("void f121(const int64_t)");
628     static int64_t _f121 = 0;
629     _f121++;
630     CHECK((p0 != _f121),
631           "void f121(const int64_t)");
632 }
633 
f122(const uint64_t p0)634 void f122(const uint64_t p0)
635 {
636     TRACE("void f122(const uint64_t)");
637     static uint64_t _f122 = 0;
638     _f122++;
639     CHECK((p0 != _f122),
640           "void f122(const uint64_t)");
641 }
642 
f123(const float p0)643 void f123(const float p0)
644 {
645     TRACE("void f123(const float)");
646     static float _f123 = 0;
647     _f123++;
648     CHECK((p0 != _f123),
649           "void f123(const float)");
650 }
651 
f124(const double p0)652 void f124(const double p0)
653 {
654     TRACE("void f124(const double)");
655     static double _f124 = 0;
656     _f124++;
657     CHECK((p0 != _f124),
658           "void f124(const double)");
659 }
660 
f131(bool p0)661 void f131(bool p0)
662 {
663     TRACE("void f131(bool)");
664     static bool _f131 = 0;
665     _f131 = !_f131;
666     CHECK((p0 != _f131),
667           "void f131(bool)");
668 }
669 
f132(char p0)670 void f132(char p0)
671 {
672     TRACE("void f132(char)");
673     static char _f132 = 0;
674     _f132++;
675     CHECK((p0 != _f132),
676           "void f132(char)");
677 }
678 
f133(int8_t p0)679 void f133(int8_t p0)
680 {
681     TRACE("void f133(int8_t)");
682     static int8_t _f133 = 0;
683     _f133++;
684     CHECK((p0 != _f133),
685           "void f133(int8_t)");
686 }
687 
f134(uint8_t p0)688 void f134(uint8_t p0)
689 {
690     TRACE("void f134(uint8_t)");
691     static uint8_t _f134 = 0;
692     _f134++;
693     CHECK((p0 != _f134),
694           "void f134(uint8_t)");
695 }
696 
f135(int16_t p0)697 void f135(int16_t p0)
698 {
699     TRACE("void f135(int16_t)");
700     static int16_t _f135 = 0;
701     _f135++;
702     CHECK((p0 != _f135),
703           "void f135(int16_t)");
704 }
705 
f136(uint16_t p0)706 void f136(uint16_t p0)
707 {
708     TRACE("void f136(uint16_t)");
709     static uint16_t _f136 = 0;
710     _f136++;
711     CHECK((p0 != _f136),
712           "void f136(uint16_t)");
713 }
714 
f137(int32_t p0)715 void f137(int32_t p0)
716 {
717     TRACE("void f137(int32_t)");
718     static int32_t _f137 = 0;
719     _f137++;
720     CHECK((p0 != _f137),
721           "void f137(int32_t)");
722 }
723 
f138(uint32_t p0)724 void f138(uint32_t p0)
725 {
726     TRACE("void f138(uint32_t)");
727     static uint32_t _f138 = 0;
728     _f138++;
729     CHECK((p0 != _f138),
730           "void f138(uint32_t)");
731 }
732 
f141(int64_t p0)733 void f141(int64_t p0)
734 {
735     TRACE("void f141(int64_t)");
736     static int64_t _f141 = 0;
737     _f141++;
738     CHECK((p0 != _f141),
739           "void f141(int64_t)");
740 }
741 
f142(uint64_t p0)742 void f142(uint64_t p0)
743 {
744     TRACE("void f142(uint64_t)");
745     static uint64_t _f142 = 0;
746     _f142++;
747     CHECK((p0 != _f142),
748           "void f142(uint64_t)");
749 }
750 
f143(float p0)751 void f143(float p0)
752 {
753     TRACE("void f143(float)");
754     static float _f143 = 0;
755     _f143++;
756     CHECK((p0 != _f143),
757           "void f143(float)");
758 }
759 
f144(double p0)760 void f144(double p0)
761 {
762     TRACE("void f144(double)");
763     static double _f144 = 0;
764     _f144++;
765     CHECK((p0 != _f144),
766           "void f144(double)");
767 }
768 
769 // ---------------------------------------------------------------------------
770 
f211()771 const bool & f211()
772 {
773     TRACE("const bool & f211()");
774     static bool _f211 = 0;
775     _f211 = !_f211;
776     return _f211;
777 }
778 
f212()779 const char & f212()
780 {
781     TRACE("const char & f212()");
782     static char _f212 = 0;
783     _f212++;
784     return _f212;
785 }
786 
f213()787 const int8_t & f213()
788 {
789     TRACE("const int8_t & f213()");
790     static int8_t _f213 = 0;
791     _f213++;
792     return _f213;
793 }
794 
f214()795 const uint8_t & f214()
796 {
797     TRACE("const uint8_t & f214()");
798     static uint8_t _f214 = 0;
799     _f214++;
800     return _f214;
801 }
802 
f215()803 const int16_t & f215()
804 {
805     TRACE("const int16_t & f215()");
806     static int16_t _f215 = 0;
807     _f215++;
808     return _f215;
809 }
810 
f216()811 const uint16_t & f216()
812 {
813     TRACE("const uint16_t & f216()");
814     static uint16_t _f216 = 0;
815     _f216++;
816     return _f216;
817 }
818 
f217()819 const int32_t & f217()
820 {
821     TRACE("const int32_t & f217()");
822     static int32_t _f217 = 0;
823     _f217++;
824     return _f217;
825 }
826 
f218()827 const uint32_t & f218()
828 {
829     TRACE("const uint32_t & f218()");
830     static uint32_t _f218 = 0;
831     _f218++;
832     return _f218;
833 }
834 
f221()835 const int64_t & f221()
836 {
837     TRACE("const int64_t & f221()");
838     static int64_t _f221 = 0;
839     _f221++;
840     return _f221;
841 }
842 
f222()843 const uint64_t & f222()
844 {
845     TRACE("const uint64_t & f222()");
846     static uint64_t _f222 = 0;
847     _f222++;
848     return _f222;
849 }
850 
f223()851 const float & f223()
852 {
853     TRACE("const & float f223()");
854     static float _f223 = 0;
855     _f223++;
856     return _f223;
857 }
858 
f224()859 const double & f224()
860 {
861     TRACE("const double & f224()");
862     static double _f224 = 0;
863     _f224++;
864     return _f224;
865 }
866 
f231()867 bool & f231()
868 {
869     TRACE("bool & f231()");
870     static bool _f231 = 0;
871     _f231 = !_f231;
872     return _f231;
873 }
874 
f232()875 char & f232()
876 {
877     TRACE("char & f232()");
878     static char _f232 = 0;
879     _f232++;
880     return _f232;
881 }
882 
f233()883 int8_t & f233()
884 {
885     TRACE("int8_t & f233()");
886     static int8_t _f233 = 0;
887     _f233++;
888     return _f233;
889 }
890 
f234()891 uint8_t & f234()
892 {
893     TRACE("uint8_t & f234()");
894     static uint8_t _f234 = 0;
895     _f234++;
896     return _f234;
897 }
898 
f235()899 int16_t & f235()
900 {
901     TRACE("int16_t & f235()");
902     static int16_t _f235 = 0;
903     _f235++;
904     return _f235;
905 }
906 
f236()907 uint16_t & f236()
908 {
909     TRACE("uint16_t & f236()");
910     static uint16_t _f236 = 0;
911     _f236++;
912     return _f236;
913 }
914 
f237()915 int32_t & f237()
916 {
917     TRACE("int32_t & f237()");
918     static int32_t _f237 = 0;
919     _f237++;
920     return _f237;
921 }
922 
f238()923 uint32_t & f238()
924 {
925     TRACE("uint32_t & f238()");
926     static uint32_t _f238 = 0;
927     _f238++;
928     return _f238;
929 }
930 
f241()931 int64_t & f241()
932 {
933     TRACE("int64_t & f241()");
934     static int64_t _f241 = 0;
935     _f241++;
936     return _f241;
937 }
938 
f242()939 uint64_t & f242()
940 {
941     TRACE("uint64_t & f242()");
942     static uint64_t _f242 = 0;
943     _f242++;
944     return _f242;
945 }
946 
f243()947 float & f243()
948 {
949     TRACE("float & f243()");
950     static float _f243 = 0;
951     _f243++;
952     return _f243;
953 }
954 
f244()955 double & f244()
956 {
957     TRACE("double & f244()");
958     static double _f244 = 0;
959     _f244++;
960     return _f244;
961 }
962 
963 // ---------------------------------------------------------------------------
964 
f311(const bool & p0)965 void f311(const bool & p0)
966 {
967     TRACE("void f311(const bool &)");
968     static bool _f311 = 0;
969     _f311 = !_f311;
970     CHECK((p0 != _f311),
971           "void f311(const bool &)");
972 }
973 
f312(const char & p0)974 void f312(const char & p0)
975 {
976     TRACE("void f312(const char &)");
977     static char _f312 = 0;
978     _f312++;
979     CHECK((p0 != _f312),
980           "void f312(const char &)");
981 }
982 
f313(const int8_t & p0)983 void f313(const int8_t & p0)
984 {
985     TRACE("void f313(const int8_t &)");
986     static int8_t _f313 = 0;
987     _f313++;
988     CHECK((p0 != _f313),
989           "void f313(const int8_t &)");
990 }
991 
f314(const uint8_t & p0)992 void f314(const uint8_t & p0)
993 {
994     TRACE("void f314(const uint8_t &)");
995     static uint8_t _f314 = 0;
996     _f314++;
997     CHECK((p0 != _f314),
998           "void f314(const uint8_t &)");
999 }
1000 
f315(const int16_t & p0)1001 void f315(const int16_t & p0)
1002 {
1003     TRACE("void f315(const int16_t &)");
1004     static int16_t _f315 = 0;
1005     _f315++;
1006     CHECK((p0 != _f315),
1007           "void f315(const int16_t &)");
1008 }
1009 
f316(const uint16_t & p0)1010 void f316(const uint16_t & p0)
1011 {
1012     TRACE("void f316(const uint16_t &)");
1013     static uint16_t _f316 = 0;
1014     _f316++;
1015     CHECK((p0 != _f316),
1016           "void f316(const uint16_t &)");
1017 }
1018 
f317(const int32_t & p0)1019 void f317(const int32_t & p0)
1020 {
1021     TRACE("void f317(const int32_t &)");
1022     static int32_t _f317 = 0;
1023     _f317++;
1024     CHECK((p0 != _f317),
1025           "void f317(const int32_t &)");
1026 }
1027 
f318(const uint32_t & p0)1028 void f318(const uint32_t & p0)
1029 {
1030     TRACE("void f318(const uint32_t &)");
1031     static uint32_t _f318 = 0;
1032     _f318++;
1033     CHECK((p0 != _f318),
1034           "void f318(const uint32_t &)");
1035 }
1036 
f321(const int64_t & p0)1037 void f321(const int64_t & p0)
1038 {
1039     TRACE("void f321(const int64_t &)");
1040     static int64_t _f321 = 0;
1041     _f321++;
1042     CHECK((p0 != _f321),
1043           "void f321(const int64_t &)");
1044 }
1045 
f322(const uint64_t & p0)1046 void f322(const uint64_t & p0)
1047 {
1048     TRACE("void f322(const uint64_t &)");
1049     static uint64_t _f322 = 0;
1050     _f322++;
1051     CHECK((p0 != _f322),
1052           "void f322(const uint64_t &)");
1053 }
1054 
f323(const float & p0)1055 void f323(const float & p0)
1056 {
1057     TRACE("void f323(const float &)");
1058     static float _f323 = 0;
1059     _f323++;
1060     CHECK((p0 != _f323),
1061           "void f323(const float &)");
1062 }
1063 
f324(const double & p0)1064 void f324(const double & p0)
1065 {
1066     TRACE("void f324(const double &)");
1067     static double _f324 = 0;
1068     _f324++;
1069     CHECK((p0 != _f324),
1070           "void f324(const double &)");
1071 }
1072 
f331(bool & p0)1073 void f331(bool & p0)
1074 {
1075     TRACE("void f331(bool &)");
1076     static bool _f331 = 0;
1077     _f331 = !_f331;
1078     CHECK((p0 != _f331),
1079           "void f331(bool &)");
1080     p0 = !p0;
1081     _f331 = !_f331;
1082 }
1083 
f332(char & p0)1084 void f332(char & p0)
1085 {
1086     TRACE("void f332(char &)");
1087     static char _f332 = 0;
1088     _f332++;
1089     CHECK((p0 != _f332),
1090           "void f332(char &)");
1091     p0++;
1092     _f332++;
1093 }
1094 
f333(int8_t & p0)1095 void f333(int8_t & p0)
1096 {
1097     TRACE("void f333(int8_t &)");
1098     static int8_t _f333 = 0;
1099     _f333++;
1100     CHECK((p0 != _f333),
1101           "void f333(int8_t &)");
1102     p0++;
1103     _f333++;
1104 }
1105 
f334(uint8_t & p0)1106 void f334(uint8_t & p0)
1107 {
1108     TRACE("void f334(uint8_t &)");
1109     static uint8_t _f334 = 0;
1110     _f334++;
1111     CHECK((p0 != _f334),
1112           "void f334(uint8_t &)");
1113     p0++;
1114     _f334++;
1115 }
1116 
f335(int16_t & p0)1117 void f335(int16_t & p0)
1118 {
1119     TRACE("void f335(int16_t &)");
1120     static int16_t _f335 = 0;
1121     _f335++;
1122     CHECK((p0 != _f335),
1123           "void f335(int16_t &)");
1124     p0++;
1125     _f335++;
1126 }
1127 
f336(uint16_t & p0)1128 void f336(uint16_t & p0)
1129 {
1130     TRACE("void f336(uint16_t &)");
1131     static uint16_t _f336 = 0;
1132     _f336++;
1133     CHECK((p0 != _f336),
1134           "void f336(uint16_t &)");
1135     p0++;
1136     _f336++;
1137 }
1138 
f337(int32_t & p0)1139 void f337(int32_t & p0)
1140 {
1141     TRACE("void f337(int32_t &)");
1142     static int32_t _f337 = 0;
1143     _f337++;
1144     CHECK((p0 != _f337),
1145           "void f337(int32_t &)");
1146     p0++;
1147     _f337++;
1148 }
1149 
f338(uint32_t & p0)1150 void f338(uint32_t & p0)
1151 {
1152     TRACE("void f338(uint32_t &)");
1153     static uint32_t _f338 = 0;
1154     _f338++;
1155     CHECK((p0 != _f338),
1156           "void f338(uint32_t &)");
1157     p0++;
1158     _f338++;
1159 }
1160 
f341(int64_t & p0)1161 void f341(int64_t & p0)
1162 {
1163     TRACE("void f341(int64_t &)");
1164     static int64_t _f341 = 0;
1165     _f341++;
1166     CHECK((p0 != _f341),
1167           "void f341(int64_t &)");
1168     p0++;
1169     _f341++;
1170 }
1171 
f342(uint64_t & p0)1172 void f342(uint64_t & p0)
1173 {
1174     TRACE("void f342(uint64_t &)");
1175     static uint64_t _f342 = 0;
1176     _f342++;
1177     CHECK((p0 != _f342),
1178           "void f342(uint64_t &)");
1179     p0++;
1180     _f342++;
1181 }
1182 
f343(float & p0)1183 void f343(float & p0)
1184 {
1185     TRACE("void f343(float &)");
1186     static float _f343 = 0;
1187     _f343++;
1188     CHECK((p0 != _f343),
1189           "void f343(float &)");
1190     p0++;
1191     _f343++;
1192 }
1193 
f344(double & p0)1194 void f344(double & p0)
1195 {
1196     TRACE("void f344(double &)");
1197     static double _f344 = 0;
1198     _f344++;
1199     CHECK((p0 != _f344),
1200           "void f344(double &)");
1201     p0++;
1202     _f344++;
1203 }
1204 
1205 // ---------------------------------------------------------------------------
1206 
f411()1207 const bool * f411()
1208 {
1209     TRACE("const bool * f411()");
1210     static bool _f411 = 0;
1211     _f411 = !_f411;
1212     return &_f411;
1213 }
1214 
f412()1215 const char * f412()
1216 {
1217     TRACE("const char * f412()");
1218     static char _f412 = 0;
1219     _f412++;
1220     return &_f412;
1221 }
1222 
f413()1223 const int8_t * f413()
1224 {
1225     TRACE("const int8_t * f413()");
1226     static int8_t _f413 = 0;
1227     _f413++;
1228     return &_f413;
1229 }
1230 
f414()1231 const uint8_t * f414()
1232 {
1233     TRACE("const uint8_t * f414()");
1234     static uint8_t _f414 = 0;
1235     _f414++;
1236     return &_f414;
1237 }
1238 
f415()1239 const int16_t * f415()
1240 {
1241     TRACE("const int16_t * f415()");
1242     static int16_t _f415 = 0;
1243     _f415++;
1244     return &_f415;
1245 }
1246 
f416()1247 const uint16_t * f416()
1248 {
1249     TRACE("const uint16_t * f416()");
1250     static uint16_t _f416 = 0;
1251     _f416++;
1252     return &_f416;
1253 }
1254 
f417()1255 const int32_t * f417()
1256 {
1257     TRACE("const int32_t * f417()");
1258     static int32_t _f417 = 0;
1259     _f417++;
1260     return &_f417;
1261 }
1262 
f418()1263 const uint32_t * f418()
1264 {
1265     TRACE("const uint32_t * f418()");
1266     static uint32_t _f418 = 0;
1267     _f418++;
1268     return &_f418;
1269 }
1270 
f421()1271 const int64_t * f421()
1272 {
1273     TRACE("const int64_t * f421()");
1274     static int64_t _f421 = 0;
1275     _f421++;
1276     return &_f421;
1277 }
1278 
f422()1279 const uint64_t * f422()
1280 {
1281     TRACE("const uint64_t * f422()");
1282     static uint64_t _f422 = 0;
1283     _f422++;
1284     return &_f422;
1285 }
1286 
f423()1287 const float * f423()
1288 {
1289     TRACE("const * float f423()");
1290     static float _f423 = 0;
1291     _f423++;
1292     return &_f423;
1293 }
1294 
f424()1295 const double * f424()
1296 {
1297     TRACE("const double * f424()");
1298     static double _f424 = 0;
1299     _f424++;
1300     return &_f424;
1301 }
1302 
f431()1303 bool * f431()
1304 {
1305     TRACE("bool * f431()");
1306     static bool _f431 = 0;
1307     _f431 = !_f431;
1308     return &_f431;
1309 }
1310 
f432()1311 char * f432()
1312 {
1313     TRACE("char * f432()");
1314     static char _f432 = 0;
1315     _f432++;
1316     return &_f432;
1317 }
1318 
f433()1319 int8_t * f433()
1320 {
1321     TRACE("int8_t * f433()");
1322     static int8_t _f433 = 0;
1323     _f433++;
1324     return &_f433;
1325 }
1326 
f434()1327 uint8_t * f434()
1328 {
1329     TRACE("uint8_t * f434()");
1330     static uint8_t _f434 = 0;
1331     _f434++;
1332     return &_f434;
1333 }
1334 
f435()1335 int16_t * f435()
1336 {
1337     TRACE("int16_t * f435()");
1338     static int16_t _f435 = 0;
1339     _f435++;
1340     return &_f435;
1341 }
1342 
f436()1343 uint16_t * f436()
1344 {
1345     TRACE("uint16_t * f436()");
1346     static uint16_t _f436 = 0;
1347     _f436++;
1348     return &_f436;
1349 }
1350 
f437()1351 int32_t * f437()
1352 {
1353     TRACE("int32_t * f437()");
1354     static int32_t _f437 = 0;
1355     _f437++;
1356     return &_f437;
1357 }
1358 
f438()1359 uint32_t * f438()
1360 {
1361     TRACE("uint32_t * f438()");
1362     static uint32_t _f438 = 0;
1363     _f438++;
1364     return &_f438;
1365 }
1366 
f441()1367 int64_t * f441()
1368 {
1369     TRACE("int64_t * f441()");
1370     static int64_t _f441 = 0;
1371     _f441++;
1372     return &_f441;
1373 }
1374 
f442()1375 uint64_t * f442()
1376 {
1377     TRACE("uint64_t * f442()");
1378     static uint64_t _f442 = 0;
1379     _f442++;
1380     return &_f442;
1381 }
1382 
f443()1383 float * f443()
1384 {
1385     TRACE("float * f443()");
1386     static float _f443 = 0;
1387     _f443++;
1388     return &_f443;
1389 }
1390 
f444()1391 double * f444()
1392 {
1393     TRACE("double * f444()");
1394     static double _f444 = 0;
1395     _f444++;
1396     return &_f444;
1397 }
1398 
1399 // ---------------------------------------------------------------------------
1400 
f511(const bool * p0)1401 void f511(const bool * p0)
1402 {
1403     TRACE("void f511(const bool *)");
1404     static bool _f511 = 0;
1405     _f511 = !_f511;
1406     CHECK((*p0 != _f511),
1407           "void f511(const bool *)");
1408 }
1409 
f512(const char * p0)1410 void f512(const char * p0)
1411 {
1412     TRACE("void f512(const char *)");
1413     static char _f512 = 0;
1414     _f512++;
1415     CHECK((*p0 != _f512),
1416           "void f512(const char *)");
1417 }
1418 
f513(const int8_t * p0)1419 void f513(const int8_t * p0)
1420 {
1421     TRACE("void f513(const int8_t *)");
1422     static int8_t _f513 = 0;
1423     _f513++;
1424     CHECK((*p0 != _f513),
1425           "void f513(const int8_t *)");
1426 }
1427 
f514(const uint8_t * p0)1428 void f514(const uint8_t * p0)
1429 {
1430     TRACE("void f514(const uint8_t *)");
1431     static uint8_t _f514 = 0;
1432     _f514++;
1433     CHECK((*p0 != _f514),
1434           "void f514(const uint8_t *)");
1435 }
1436 
f515(const int16_t * p0)1437 void f515(const int16_t * p0)
1438 {
1439     TRACE("void f515(const int16_t *)");
1440     static int16_t _f515 = 0;
1441     _f515++;
1442     CHECK((*p0 != _f515),
1443           "void f515(const int16_t *)");
1444 }
1445 
f516(const uint16_t * p0)1446 void f516(const uint16_t * p0)
1447 {
1448     TRACE("void f516(const uint16_t *)");
1449     static uint16_t _f516 = 0;
1450     _f516++;
1451     CHECK((*p0 != _f516),
1452           "void f516(const uint16_t *)");
1453 }
1454 
f517(const int32_t * p0)1455 void f517(const int32_t * p0)
1456 {
1457     TRACE("void f517(const int32_t *)");
1458     static int32_t _f517 = 0;
1459     _f517++;
1460     CHECK((*p0 != _f517),
1461           "void f517(const int32_t *)");
1462 }
1463 
f518(const uint32_t * p0)1464 void f518(const uint32_t * p0)
1465 {
1466     TRACE("void f518(const uint32_t *)");
1467     static uint32_t _f518 = 0;
1468     _f518++;
1469     CHECK((*p0 != _f518),
1470           "void f518(const uint32_t *)");
1471 }
1472 
f521(const int64_t * p0)1473 void f521(const int64_t * p0)
1474 {
1475     TRACE("void f521(const int64_t *)");
1476     static int64_t _f521 = 0;
1477     _f521++;
1478     CHECK((*p0 != _f521),
1479           "void f521(const int64_t *)");
1480 }
1481 
f522(const uint64_t * p0)1482 void f522(const uint64_t * p0)
1483 {
1484     TRACE("void f522(const uint64_t *)");
1485     static uint64_t _f522 = 0;
1486     _f522++;
1487     CHECK((*p0 != _f522),
1488           "void f522(const uint64_t *)");
1489 }
1490 
f523(const float * p0)1491 void f523(const float * p0)
1492 {
1493     TRACE("void f523(const float *)");
1494     static float _f523 = 0;
1495     _f523++;
1496     CHECK((*p0 != _f523),
1497           "void f523(const float *)");
1498 }
1499 
f524(const double * p0)1500 void f524(const double * p0)
1501 {
1502     TRACE("void f524(const double *)");
1503     static double _f524 = 0;
1504     _f524++;
1505     CHECK((*p0 != _f524),
1506           "void f524(const double *)");
1507 }
1508 
f531(bool * p0)1509 void f531(bool * p0)
1510 {
1511     TRACE("void f531(bool *)");
1512     static bool _f531 = 0;
1513     _f531 = !_f531;
1514     CHECK((*p0 != _f531),
1515           "void f531(bool *)");
1516     *p0 = !*p0;
1517     _f531 = !_f531;
1518 }
1519 
f532(char * p0)1520 void f532(char * p0)
1521 {
1522     TRACE("void f532(char *)");
1523     static char _f532 = 0;
1524     _f532++;
1525     CHECK((*p0 != _f532),
1526           "void f532(char *)");
1527     (*p0)++;
1528     _f532++;
1529 }
1530 
f533(int8_t * p0)1531 void f533(int8_t * p0)
1532 {
1533     TRACE("void f533(int8_t *)");
1534     static int8_t _f533 = 0;
1535     _f533++;
1536     CHECK((*p0 != _f533),
1537           "void f533(int8_t *)");
1538     (*p0)++;
1539     _f533++;
1540 }
1541 
f534(uint8_t * p0)1542 void f534(uint8_t * p0)
1543 {
1544     TRACE("void f534(uint8_t *)");
1545     static uint8_t _f534 = 0;
1546     _f534++;
1547     CHECK((*p0 != _f534),
1548           "void f534(uint8_t *)");
1549     (*p0)++;
1550     _f534++;
1551 }
1552 
f535(int16_t * p0)1553 void f535(int16_t * p0)
1554 {
1555     TRACE("void f535(int16_t *)");
1556     static int16_t _f535 = 0;
1557     _f535++;
1558     CHECK((*p0 != _f535),
1559           "void f535(int16_t *)");
1560     (*p0)++;
1561     _f535++;
1562 }
1563 
f536(uint16_t * p0)1564 void f536(uint16_t * p0)
1565 {
1566     TRACE("void f536(uint16_t *)");
1567     static uint16_t _f536 = 0;
1568     _f536++;
1569     CHECK((*p0 != _f536),
1570           "void f536(uint16_t *)");
1571     (*p0)++;
1572     _f536++;
1573 }
1574 
f537(int32_t * p0)1575 void f537(int32_t * p0)
1576 {
1577     TRACE("void f537(int32_t *)");
1578     static int32_t _f537 = 0;
1579     _f537++;
1580     CHECK((*p0 != _f537),
1581           "void f537(int32_t *)");
1582     (*p0)++;
1583     _f537++;
1584 }
1585 
f538(uint32_t * p0)1586 void f538(uint32_t * p0)
1587 {
1588     TRACE("void f538(uint32_t *)");
1589     static uint32_t _f538 = 0;
1590     _f538++;
1591     CHECK((*p0 != _f538),
1592           "void f538(uint32_t *)");
1593     (*p0)++;
1594     _f538++;
1595 }
1596 
f541(int64_t * p0)1597 void f541(int64_t * p0)
1598 {
1599     TRACE("void f541(int64_t *)");
1600     static int64_t _f541 = 0;
1601     _f541++;
1602     CHECK((*p0 != _f541),
1603           "void f541(int64_t *)");
1604     (*p0)++;
1605     _f541++;
1606 }
1607 
f542(uint64_t * p0)1608 void f542(uint64_t * p0)
1609 {
1610     TRACE("void f542(uint64_t *)");
1611     static uint64_t _f542 = 0;
1612     _f542++;
1613     CHECK((*p0 != _f542),
1614           "void f542(uint64_t *)");
1615     (*p0)++;
1616     _f542++;
1617 }
1618 
f543(float * p0)1619 void f543(float * p0)
1620 {
1621     TRACE("void f543(float *)");
1622     static float _f543 = 0;
1623     _f543++;
1624     CHECK((*p0 != _f543),
1625           "void f543(float *)");
1626     (*p0)++;
1627     _f543++;
1628 }
1629 
f544(double * p0)1630 void f544(double * p0)
1631 {
1632     TRACE("void f544(double *)");
1633     static double _f544 = 0;
1634     _f544++;
1635     CHECK((*p0 != _f544),
1636           "void f544(double *)");
1637     (*p0)++;
1638     _f544++;
1639 }
1640 
f551(const bool * const p0)1641 void f551(const bool * const p0)
1642 {
1643     TRACE("void f551(const bool * const)");
1644     static bool _f551 = 0;
1645     _f551 = !_f551;
1646     CHECK((*p0 != _f551),
1647           "void f551(const bool * const)");
1648 }
1649 
f552(const char * const p0)1650 void f552(const char * const p0)
1651 {
1652     TRACE("void f552(const char * const)");
1653     static char _f552 = 0;
1654     _f552++;
1655     CHECK((*p0 != _f552),
1656           "void f552(const char * const)");
1657 }
1658 
f553(const int8_t * const p0)1659 void f553(const int8_t * const p0)
1660 {
1661     TRACE("void f553(const int8_t * const)");
1662     static int8_t _f553 = 0;
1663     _f553++;
1664     CHECK((*p0 != _f553),
1665           "void f553(const int8_t * const)");
1666 }
1667 
f554(const uint8_t * const p0)1668 void f554(const uint8_t * const p0)
1669 {
1670     TRACE("void f554(const uint8_t * const)");
1671     static uint8_t _f554 = 0;
1672     _f554++;
1673     CHECK((*p0 != _f554),
1674           "void f554(const uint8_t * const)");
1675 }
1676 
f555(const int16_t * const p0)1677 void f555(const int16_t * const p0)
1678 {
1679     TRACE("void f555(const int16_t * const)");
1680     static int16_t _f555 = 0;
1681     _f555++;
1682     CHECK((*p0 != _f555),
1683           "void f555(const int16_t * const)");
1684 }
1685 
f556(const uint16_t * const p0)1686 void f556(const uint16_t * const p0)
1687 {
1688     TRACE("void f556(const uint16_t * const)");
1689     static uint16_t _f556 = 0;
1690     _f556++;
1691     CHECK((*p0 != _f556),
1692           "void f556(const uint16_t * const)");
1693 }
1694 
f557(const int32_t * const p0)1695 void f557(const int32_t * const p0)
1696 {
1697     TRACE("void f557(const int32_t * const)");
1698     static int32_t _f557 = 0;
1699     _f557++;
1700     CHECK((*p0 != _f557),
1701           "void f557(const int32_t * const)");
1702 }
1703 
f558(const uint32_t * const p0)1704 void f558(const uint32_t * const p0)
1705 {
1706     TRACE("void f558(const uint32_t * const)");
1707     static uint32_t _f558 = 0;
1708     _f558++;
1709     CHECK((*p0 != _f558),
1710           "void f558(const uint32_t * const)");
1711 }
1712 
f561(const int64_t * const p0)1713 void f561(const int64_t * const p0)
1714 {
1715     TRACE("void f561(const int64_t * const)");
1716     static int64_t _f561 = 0;
1717     _f561++;
1718     CHECK((*p0 != _f561),
1719           "void f561(const int64_t * const)");
1720 }
1721 
f562(const uint64_t * const p0)1722 void f562(const uint64_t * const p0)
1723 {
1724     TRACE("void f562(const uint64_t * const)");
1725     static uint64_t _f562 = 0;
1726     _f562++;
1727     CHECK((*p0 != _f562),
1728           "void f562(const uint64_t * const)");
1729 }
1730 
f563(const float * const p0)1731 void f563(const float * const p0)
1732 {
1733     TRACE("void f563(const float * const)");
1734     static float _f563 = 0;
1735     _f563++;
1736     CHECK((*p0 != _f563),
1737           "void f563(const float * const)");
1738 }
1739 
f564(const double * const p0)1740 void f564(const double * const p0)
1741 {
1742     TRACE("void f564(const double * const)");
1743     static double _f564 = 0;
1744     _f564++;
1745     CHECK((*p0 != _f564),
1746           "void f564(const double * const)");
1747 }
1748 
f571(bool * const p0)1749 void f571(bool * const p0)
1750 {
1751     TRACE("void f571(bool * const)");
1752     static bool _f571 = 0;
1753     _f571 = !_f571;
1754     CHECK((*p0 != _f571),
1755           "void f571(bool * const)");
1756     *p0 = !*p0;
1757     _f571 = !_f571;
1758 }
1759 
f572(char * const p0)1760 void f572(char * const p0)
1761 {
1762     TRACE("void f572(char * const)");
1763     static char _f572 = 0;
1764     _f572++;
1765     CHECK((*p0 != _f572),
1766           "void f572(char * const)");
1767     (*p0)++;
1768     _f572++;
1769 }
1770 
f573(int8_t * const p0)1771 void f573(int8_t * const p0)
1772 {
1773     TRACE("void f573(int8_t * const)");
1774     static int8_t _f573 = 0;
1775     _f573++;
1776     CHECK((*p0 != _f573),
1777           "void f573(int8_t * const)");
1778     (*p0)++;
1779     _f573++;
1780 }
1781 
f574(uint8_t * const p0)1782 void f574(uint8_t * const p0)
1783 {
1784     TRACE("void f574(uint8_t * const)");
1785     static uint8_t _f574 = 0;
1786     _f574++;
1787     CHECK((*p0 != _f574),
1788           "void f574(uint8_t * const)");
1789     (*p0)++;
1790     _f574++;
1791 }
1792 
f575(int16_t * const p0)1793 void f575(int16_t * const p0)
1794 {
1795     TRACE("void f575(int16_t * const)");
1796     static int16_t _f575 = 0;
1797     _f575++;
1798     CHECK((*p0 != _f575),
1799           "void f575(int16_t * const)");
1800     (*p0)++;
1801     _f575++;
1802 }
1803 
f576(uint16_t * const p0)1804 void f576(uint16_t * const p0)
1805 {
1806     TRACE("void f576(uint16_t * const)");
1807     static uint16_t _f576 = 0;
1808     _f576++;
1809     CHECK((*p0 != _f576),
1810           "void f576(uint16_t * const)");
1811     (*p0)++;
1812     _f576++;
1813 }
1814 
f577(int32_t * const p0)1815 void f577(int32_t * const p0)
1816 {
1817     TRACE("void f577(int32_t * const)");
1818     static int32_t _f577 = 0;
1819     _f577++;
1820     CHECK((*p0 != _f577),
1821           "void f577(int32_t * const)");
1822     (*p0)++;
1823     _f577++;
1824 }
1825 
f578(uint32_t * const p0)1826 void f578(uint32_t * const p0)
1827 {
1828     TRACE("void f578(uint32_t * const)");
1829     static uint32_t _f578 = 0;
1830     _f578++;
1831     CHECK((*p0 != _f578),
1832           "void f578(uint32_t * const)");
1833     (*p0)++;
1834     _f578++;
1835 }
1836 
f581(int64_t * const p0)1837 void f581(int64_t * const p0)
1838 {
1839     TRACE("void f581(int64_t * const)");
1840     static int64_t _f581 = 0;
1841     _f581++;
1842     CHECK((*p0 != _f581),
1843           "void f581(int64_t * const)");
1844     (*p0)++;
1845     _f581++;
1846 }
1847 
f582(uint64_t * const p0)1848 void f582(uint64_t * const p0)
1849 {
1850     TRACE("void f582(uint64_t * const)");
1851     static uint64_t _f582 = 0;
1852     _f582++;
1853     CHECK((*p0 != _f582),
1854           "void f582(uint64_t * const)");
1855     (*p0)++;
1856     _f582++;
1857 }
1858 
f583(float * const p0)1859 void f583(float * const p0)
1860 {
1861     TRACE("void f583(float * const)");
1862     static float _f583 = 0;
1863     _f583++;
1864     CHECK((*p0 != _f583),
1865           "void f583(float * const)");
1866     (*p0)++;
1867     _f583++;
1868 }
1869 
f584(double * const p0)1870 void f584(double * const p0)
1871 {
1872     TRACE("void f584(double * const)");
1873     static double _f584 = 0;
1874     _f584++;
1875     CHECK((*p0 != _f584),
1876           "void f584(double * const)");
1877     (*p0)++;
1878     _f584++;
1879 }
1880 
1881 // ---------------------------------------------------------------------------
1882 
f611()1883 const bool * f611()
1884 {
1885     TRACE("const bool * f611()");
1886     static bool _f611 = 1;
1887     return (((_f611 = !_f611) == 0) ? NULL : &_f611);
1888 }
1889 
f612()1890 const char * f612()
1891 {
1892     TRACE("const char * f612()");
1893     static char _f612 = 1;
1894     return (((_f612 = (char)~_f612) != 1) ? NULL : &_f612);
1895 }
1896 
f613()1897 const int8_t * f613()
1898 {
1899     TRACE("const int8_t * f613()");
1900     static int8_t _f613 = 1;
1901     return (((_f613 = (int8_t)~_f613) != 1) ? NULL : &_f613);
1902 }
1903 
f614()1904 const uint8_t * f614()
1905 {
1906     TRACE("const uint8_t * f614()");
1907     static uint8_t _f614 = 1;
1908     return (((_f614 = (uint8_t)~_f614) != 1) ? NULL : &_f614);
1909 }
1910 
f615()1911 const int16_t * f615()
1912 {
1913     TRACE("const int16_t * f615()");
1914     static int16_t _f615 = 1;
1915     return (((_f615 = (int16_t)~_f615) != 1) ? NULL : &_f615);
1916 }
1917 
f616()1918 const uint16_t * f616()
1919 {
1920     TRACE("const uint16_t * f616()");
1921     static uint16_t _f616 = 1;
1922     return (((_f616 = (uint16_t)~_f616) != 1) ? NULL : &_f616);
1923 }
1924 
f617()1925 const int32_t * f617()
1926 {
1927     TRACE("const int32_t * f617()");
1928     static int32_t _f617 = 1;
1929     return (((_f617 = (int32_t)~_f617) != 1) ? NULL : &_f617);
1930 }
1931 
f618()1932 const uint32_t * f618()
1933 {
1934     TRACE("const uint32_t * f618()");
1935     static uint32_t _f618 = 1;
1936     return (((_f618 = (uint32_t)~_f618) != 1) ? NULL : &_f618);
1937 }
1938 
f621()1939 const int64_t * f621()
1940 {
1941     TRACE("const int64_t * f621()");
1942     static int64_t _f621 = 1;
1943     return (((_f621 = (int64_t)~_f621) != 1) ? NULL : &_f621);
1944 }
1945 
f622()1946 const uint64_t * f622()
1947 {
1948     TRACE("const uint64_t * f622()");
1949     static uint64_t _f622 = 1;
1950     return (((_f622 = (uint64_t)~_f622) != 1) ? NULL : &_f622);
1951 }
1952 
f623()1953 const float * f623()
1954 {
1955     TRACE("const * float f623()");
1956     static float _f623 = 1;
1957     return (((_f623 = (float)-_f623) != 1) ? NULL : &_f623);
1958 }
1959 
f624()1960 const double * f624()
1961 {
1962     TRACE("const double * f624()");
1963     static double _f624 = 1;
1964     return (((_f624 = (double)-_f624) != 1) ? NULL : &_f624);
1965 }
1966 
f631()1967 bool * f631()
1968 {
1969     TRACE("bool * f631()");
1970     static bool _f631 = 1;
1971     return (((_f631 = !_f631) == 0) ? NULL : &_f631);
1972 }
1973 
f632()1974 char * f632()
1975 {
1976     TRACE("char * f632()");
1977     static char _f632 = 1;
1978     return (((_f632 = (char)~_f632) != 1) ? NULL : &_f632);
1979 }
1980 
f633()1981 int8_t * f633()
1982 {
1983     TRACE("int8_t * f633()");
1984     static int8_t _f633 = 1;
1985     return (((_f633 = (int8_t)~_f633) != 1) ? NULL : &_f633);
1986 }
1987 
f634()1988 uint8_t * f634()
1989 {
1990     TRACE("uint8_t * f634()");
1991     static uint8_t _f634 = 1;
1992     return (((_f634 = (uint8_t)~_f634) != 1) ? NULL : &_f634);
1993 }
1994 
f635()1995 int16_t * f635()
1996 {
1997     TRACE("int16_t * f635()");
1998     static int16_t _f635 = 1;
1999     return (((_f635 = (int16_t)~_f635) != 1) ? NULL : &_f635);
2000 }
2001 
f636()2002 uint16_t * f636()
2003 {
2004     TRACE("uint16_t * f636()");
2005     static uint16_t _f636 = 1;
2006     return (((_f636 = (uint16_t)~_f636) != 1) ? NULL : &_f636);
2007 }
2008 
f637()2009 int32_t * f637()
2010 {
2011     TRACE("int32_t * f637()");
2012     static int32_t _f637 = 1;
2013     return (((_f637 = (int32_t)~_f637) != 1) ? NULL : &_f637);
2014 }
2015 
f638()2016 uint32_t * f638()
2017 {
2018     TRACE("uint32_t * f638()");
2019     static uint32_t _f638 = 1;
2020     return (((_f638 = (uint32_t)~_f638) != 1) ? NULL : &_f638);
2021 }
2022 
f641()2023 int64_t * f641()
2024 {
2025     TRACE("int64_t * f641()");
2026     static int64_t _f641 = 1;
2027     return (((_f641 = (int64_t)~_f641) != 1) ? NULL : &_f641);
2028 }
2029 
f642()2030 uint64_t * f642()
2031 {
2032     TRACE("uint64_t * f642()");
2033     static uint64_t _f642 = 1;
2034     return (((_f642 = (uint64_t)~_f642) != 1) ? NULL : &_f642);
2035 }
2036 
f643()2037 float * f643()
2038 {
2039     TRACE("float * f643()");
2040     static float _f643 = 1;
2041     return (((_f643 = (float)-_f643) != 1) ? NULL : &_f643);
2042 }
2043 
f644()2044 double * f644()
2045 {
2046     TRACE("double * f644()");
2047     static double _f644 = 1;
2048     return (((_f644 = (double)-_f644) != 1) ? NULL : &_f644);
2049 }
2050 
2051 // ---------------------------------------------------------------------------
2052 
f711(const bool * p0)2053 void f711(const bool * p0)
2054 {
2055     TRACE("void f711(const bool *)");
2056     static bool _f711 = 1;
2057     CHECK((((_f711 = !_f711) == 0) ^ (p0 == NULL)),
2058           "void f711(const bool *)");
2059 }
2060 
f712(const char * p0)2061 void f712(const char * p0)
2062 {
2063     TRACE("void f712(const char *)");
2064     static char _f712 = 1;
2065     CHECK((((_f712 = (char)~_f712) != 1) ^ (p0 == NULL)),
2066           "void f712(const char *)");
2067 }
2068 
f713(const int8_t * p0)2069 void f713(const int8_t * p0)
2070 {
2071     TRACE("void f713(const int8_t *)");
2072     static int8_t _f713 = 1;
2073     CHECK((((_f713 = (int8_t)~_f713) != 1) ^ (p0 == NULL)),
2074           "void f713(const int8_t *)");
2075 }
2076 
f714(const uint8_t * p0)2077 void f714(const uint8_t * p0)
2078 {
2079     TRACE("void f714(const uint8_t *)");
2080     static uint8_t _f714 = 1;
2081     CHECK((((_f714 = (uint8_t)~_f714) != 1) ^ (p0 == NULL)),
2082           "void f714(const uint8_t *)");
2083 }
2084 
f715(const int16_t * p0)2085 void f715(const int16_t * p0)
2086 {
2087     TRACE("void f715(const int16_t *)");
2088     static int16_t _f715 = 1;
2089     CHECK((((_f715 = (int16_t)~_f715) != 1) ^ (p0 == NULL)),
2090           "void f715(const int16_t *)");
2091 }
2092 
f716(const uint16_t * p0)2093 void f716(const uint16_t * p0)
2094 {
2095     TRACE("void f716(const uint16_t *)");
2096     static uint16_t _f716 = 1;
2097     CHECK((((_f716 = (uint16_t)~_f716) != 1) ^ (p0 == NULL)),
2098           "void f716(const uint16_t *)");
2099 }
2100 
f717(const int32_t * p0)2101 void f717(const int32_t * p0)
2102 {
2103     TRACE("void f717(const int32_t *)");
2104     static int32_t _f717 = 1;
2105     CHECK((((_f717 = (int32_t)~_f717) != 1) ^ (p0 == NULL)),
2106           "void f717(const int32_t *)");
2107 }
2108 
f718(const uint32_t * p0)2109 void f718(const uint32_t * p0)
2110 {
2111     TRACE("void f718(const uint32_t *)");
2112     static uint32_t _f718 = 1;
2113     CHECK((((_f718 = (uint32_t)~_f718) != 1) ^ (p0 == NULL)),
2114           "void f718(const uint32_t *)");
2115 }
2116 
f721(const int64_t * p0)2117 void f721(const int64_t * p0)
2118 {
2119     TRACE("void f721(const int64_t *)");
2120     static int64_t _f721 = 1;
2121     CHECK((((_f721 = (int64_t)~_f721) != 1) ^ (p0 == NULL)),
2122           "void f721(const int64_t *)");
2123 }
2124 
f722(const uint64_t * p0)2125 void f722(const uint64_t * p0)
2126 {
2127     TRACE("void f722(const uint64_t *)");
2128     static uint64_t _f722 = 1;
2129     CHECK((((_f722 = (uint64_t)~_f722) != 1) ^ (p0 == NULL)),
2130           "void f722(const uint64_t *)");
2131 }
2132 
f723(const float * p0)2133 void f723(const float * p0)
2134 {
2135     TRACE("void f723(const float *)");
2136     static float _f723 = 1;
2137     CHECK((((_f723 = (float)-_f723) != 1) ^ (p0 == NULL)),
2138           "void f723(const float *)");
2139 }
2140 
f724(const double * p0)2141 void f724(const double * p0)
2142 {
2143     TRACE("void f724(const double *)");
2144     static double _f724 = 1;
2145     CHECK((((_f724 = (double)-_f724) != 1) ^ (p0 == NULL)),
2146           "void f724(const double *)");
2147 }
2148 
f731(bool * p0)2149 void f731(bool * p0)
2150 {
2151     TRACE("void f731(bool *)");
2152     static bool _f731 = 1;
2153     CHECK((((_f731 = !_f731) == 0) ^ (p0 == NULL)),
2154           "void f731(bool *)");
2155 }
2156 
f732(char * p0)2157 void f732(char * p0)
2158 {
2159     TRACE("void f732(char *)");
2160     static char _f732 = 1;
2161     CHECK((((_f732 = (char)~_f732) != 1) ^ (p0 == NULL)),
2162           "void f732(char *)");
2163 }
2164 
f733(int8_t * p0)2165 void f733(int8_t * p0)
2166 {
2167     TRACE("void f733(int8_t *)");
2168     static int8_t _f733 = 1;
2169     CHECK((((_f733 = (int8_t)~_f733) != 1) ^ (p0 == NULL)),
2170           "void f733(int8_t *)");
2171 }
2172 
f734(uint8_t * p0)2173 void f734(uint8_t * p0)
2174 {
2175     TRACE("void f734(uint8_t *)");
2176     static uint8_t _f734 = 1;
2177     CHECK((((_f734 = (uint8_t)~_f734) != 1) ^ (p0 == NULL)),
2178           "void f734(uint8_t *)");
2179 }
2180 
f735(int16_t * p0)2181 void f735(int16_t * p0)
2182 {
2183     TRACE("void f735(int16_t *)");
2184     static int16_t _f735 = 1;
2185     CHECK((((_f735 = (int16_t)~_f735) != 1) ^ (p0 == NULL)),
2186           "void f735(int16_t *)");
2187 }
2188 
f736(uint16_t * p0)2189 void f736(uint16_t * p0)
2190 {
2191     TRACE("void f736(uint16_t *)");
2192     static uint16_t _f736 = 1;
2193     CHECK((((_f736 = (uint16_t)~_f736) != 1) ^ (p0 == NULL)),
2194           "void f736(uint16_t *)");
2195 }
2196 
f737(int32_t * p0)2197 void f737(int32_t * p0)
2198 {
2199     TRACE("void f737(int32_t *)");
2200     static int32_t _f737 = 1;
2201     CHECK((((_f737 = (int32_t)~_f737) != 1) ^ (p0 == NULL)),
2202           "void f737(int32_t *)");
2203 }
2204 
f738(uint32_t * p0)2205 void f738(uint32_t * p0)
2206 {
2207     TRACE("void f738(uint32_t *)");
2208     static uint32_t _f738 = 1;
2209     CHECK((((_f738 = (uint32_t)~_f738) != 1) ^ (p0 == NULL)),
2210           "void f738(uint32_t *)");
2211 }
2212 
f741(int64_t * p0)2213 void f741(int64_t * p0)
2214 {
2215     TRACE("void f741(int64_t *)");
2216     static int64_t _f741 = 1;
2217     CHECK((((_f741 = (int64_t)~_f741) != 1) ^ (p0 == NULL)),
2218           "void f741(int64_t *)");
2219 }
2220 
f742(uint64_t * p0)2221 void f742(uint64_t * p0)
2222 {
2223     TRACE("void f742(uint64_t *)");
2224     static uint64_t _f742 = 1;
2225     CHECK((((_f742 = (uint64_t)~_f742) != 1) ^ (p0 == NULL)),
2226           "void f742(uint64_t *)");
2227 }
2228 
f743(float * p0)2229 void f743(float * p0)
2230 {
2231     TRACE("void f743(float *)");
2232     static float _f743 = 1;
2233     CHECK((((_f743 = (float)-_f743) != 1) ^ (p0 == NULL)),
2234           "void f743(float *)");
2235 }
2236 
f744(double * p0)2237 void f744(double * p0)
2238 {
2239     TRACE("void f744(double *)");
2240     static double _f744 = 1;
2241     CHECK((((_f744 = (double)-_f744) != 1) ^ (p0 == NULL)),
2242           "void f744(double *)");
2243 }
2244 
f751(const bool * const p0)2245 void f751(const bool * const p0)
2246 {
2247     TRACE("void f751(const bool * const)");
2248     static bool _f751 = 1;
2249     CHECK((((_f751 = !_f751) == 0) ^ (p0 == NULL)),
2250           "void f751(const bool * const)");
2251 }
2252 
f752(const char * const p0)2253 void f752(const char * const p0)
2254 {
2255     TRACE("void f752(const char * const)");
2256     static char _f752 = 1;
2257     CHECK((((_f752 = (char)~_f752) != 1) ^ (p0 == NULL)),
2258           "void f752(const char * const)");
2259 }
2260 
f753(const int8_t * const p0)2261 void f753(const int8_t * const p0)
2262 {
2263     TRACE("void f753(const int8_t * const)");
2264     static int8_t _f753 = 1;
2265     CHECK((((_f753 = (int8_t)~_f753) != 1) ^ (p0 == NULL)),
2266           "void f753(const int8_t * const)");
2267 }
2268 
f754(const uint8_t * const p0)2269 void f754(const uint8_t * const p0)
2270 {
2271     TRACE("void f754(const uint8_t * const)");
2272     static uint8_t _f754 = 1;
2273     CHECK((((_f754 = (uint8_t)~_f754) != 1) ^ (p0 == NULL)),
2274           "void f754(const uint8_t * const)");
2275 }
2276 
f755(const int16_t * const p0)2277 void f755(const int16_t * const p0)
2278 {
2279     TRACE("void f755(const int16_t * const)");
2280     static int16_t _f755 = 1;
2281     CHECK((((_f755 = (int16_t)~_f755) != 1) ^ (p0 == NULL)),
2282           "void f755(const int16_t * const)");
2283 }
2284 
f756(const uint16_t * const p0)2285 void f756(const uint16_t * const p0)
2286 {
2287     TRACE("void f756(const uint16_t * const)");
2288     static uint16_t _f756 = 1;
2289     CHECK((((_f756 = (uint16_t)~_f756) != 1) ^ (p0 == NULL)),
2290           "void f756(const uint16_t * const)");
2291 }
2292 
f757(const int32_t * const p0)2293 void f757(const int32_t * const p0)
2294 {
2295     TRACE("void f757(const int32_t * const)");
2296     static int32_t _f757 = 1;
2297     CHECK((((_f757 = (int32_t)~_f757) != 1) ^ (p0 == NULL)),
2298           "void f757(const int32_t * const)");
2299 }
2300 
f758(const uint32_t * const p0)2301 void f758(const uint32_t * const p0)
2302 {
2303     TRACE("void f758(const uint32_t * const)");
2304     static uint32_t _f758 = 1;
2305     CHECK((((_f758 = (uint32_t)~_f758) != 1) ^ (p0 == NULL)),
2306           "void f758(const uint32_t * const)");
2307 }
2308 
f761(const int64_t * const p0)2309 void f761(const int64_t * const p0)
2310 {
2311     TRACE("void f761(const int64_t * const)");
2312     static int64_t _f761 = 1;
2313     CHECK((((_f761 = (int64_t)~_f761) != 1) ^ (p0 == NULL)),
2314           "void f761(const int64_t * const)");
2315 }
2316 
f762(const uint64_t * const p0)2317 void f762(const uint64_t * const p0)
2318 {
2319     TRACE("void f762(const uint64_t * const)");
2320     static uint64_t _f762 = 1;
2321     CHECK((((_f762 = (uint64_t)~_f762) != 1) ^ (p0 == NULL)),
2322           "void f762(const uint64_t * const)");
2323 }
2324 
f763(const float * const p0)2325 void f763(const float * const p0)
2326 {
2327     TRACE("void f763(const float * const)");
2328     static float _f763 = 1;
2329     CHECK((((_f763 = (float)-_f763) != 1) ^ (p0 == NULL)),
2330           "void f763(const float * const)");
2331 }
2332 
f764(const double * const p0)2333 void f764(const double * const p0)
2334 {
2335     TRACE("void f764(const double * const)");
2336     static double _f764 = 1;
2337     CHECK((((_f764 = (double)-_f764) != 1) ^ (p0 == NULL)),
2338           "void f764(const double * const)");
2339 }
2340 
f771(bool * const p0)2341 void f771(bool * const p0)
2342 {
2343     TRACE("void f771(bool * const)");
2344     static bool _f771 = 1;
2345     CHECK((((_f771 = !_f771) == 0) ^ (p0 == NULL)),
2346           "void f771(bool * const)");
2347 }
2348 
f772(char * const p0)2349 void f772(char * const p0)
2350 {
2351     TRACE("void f772(char * const)");
2352     static char _f772 = 1;
2353     CHECK((((_f772 = (char)~_f772) != 1) ^ (p0 == NULL)),
2354           "void f772(char * const)");
2355 }
2356 
f773(int8_t * const p0)2357 void f773(int8_t * const p0)
2358 {
2359     TRACE("void f773(int8_t * const)");
2360     static int8_t _f773 = 1;
2361     CHECK((((_f773 = (int8_t)~_f773) != 1) ^ (p0 == NULL)),
2362           "void f773(int8_t * const)");
2363 }
2364 
f774(uint8_t * const p0)2365 void f774(uint8_t * const p0)
2366 {
2367     TRACE("void f774(uint8_t * const)");
2368     static uint8_t _f774 = 1;
2369     CHECK((((_f774 = (uint8_t)~_f774) != 1) ^ (p0 == NULL)),
2370           "void f774(uint8_t * const)");
2371 }
2372 
f775(int16_t * const p0)2373 void f775(int16_t * const p0)
2374 {
2375     TRACE("void f775(int16_t * const)");
2376     static int16_t _f775 = 1;
2377     CHECK((((_f775 = (int16_t)~_f775) != 1) ^ (p0 == NULL)),
2378           "void f775(int16_t * const)");
2379 }
2380 
f776(uint16_t * const p0)2381 void f776(uint16_t * const p0)
2382 {
2383     TRACE("void f776(uint16_t * const)");
2384     static uint16_t _f776 = 1;
2385     CHECK((((_f776 = (uint16_t)~_f776) != 1) ^ (p0 == NULL)),
2386           "void f776(uint16_t * const)");
2387 }
2388 
f777(int32_t * const p0)2389 void f777(int32_t * const p0)
2390 {
2391     TRACE("void f777(int32_t * const)");
2392     static int32_t _f777 = 1;
2393     CHECK((((_f777 = (int32_t)~_f777) != 1) ^ (p0 == NULL)),
2394           "void f777(int32_t * const)");
2395 }
2396 
f778(uint32_t * const p0)2397 void f778(uint32_t * const p0)
2398 {
2399     TRACE("void f778(uint32_t * const)");
2400     static uint32_t _f778 = 1;
2401     CHECK((((_f778 = (uint32_t)~_f778) != 1) ^ (p0 == NULL)),
2402           "void f778(uint32_t * const)");
2403 }
2404 
f781(int64_t * const p0)2405 void f781(int64_t * const p0)
2406 {
2407     TRACE("void f781(int64_t * const)");
2408     static int64_t _f781 = 1;
2409     CHECK((((_f781 = (int64_t)~_f781) != 1) ^ (p0 == NULL)),
2410           "void f781(int64_t * const)");
2411 }
2412 
f782(uint64_t * const p0)2413 void f782(uint64_t * const p0)
2414 {
2415     TRACE("void f782(uint64_t * const)");
2416     static uint64_t _f782 = 1;
2417     CHECK((((_f782 = (uint64_t)~_f782) != 1) ^ (p0 == NULL)),
2418           "void f782(uint64_t * const)");
2419 }
2420 
f783(float * const p0)2421 void f783(float * const p0)
2422 {
2423     TRACE("void f783(float * const)");
2424     static float _f783 = 1;
2425     CHECK((((_f783 = (float)-_f783) != 1) ^ (p0 == NULL)),
2426           "void f783(float * const)");
2427 }
2428 
f784(double * const p0)2429 void f784(double * const p0)
2430 {
2431     TRACE("void f784(double * const)");
2432     static double _f784 = 1;
2433     CHECK((((_f784 = (double)-_f784) != 1) ^ (p0 == NULL)),
2434           "void f784(double * const)");
2435 }
2436 
2437 // ---------------------------------------------------------------------------
2438