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