Changes in / [6d44da1:341bb80]


Ignore:
Files:
95 added
113 deleted
65 edited

Legend:

Unmodified
Added
Removed

  • .gitignore

    r6d44da1 r341bb80  
    3838libcfa/prelude/gcc-builtins.cf
    3939libcfa/prelude/gcc-builtins.c
    40 libcfa/prelude/prelude.cfa
     40libcfa/prelude/prelude.cf
    4141libcfa/x64-debug/
    4242libcfa/x64-nodebug/
    … …  
    5656src/Parser/parser.h
    5757src/Parser/parser.hh
    58 src/demangler
    5958
    6059tools/prettyprinter/parser.output

  • Jenkinsfile

    r6d44da1 r341bb80  
    128128                        //Run the tests from the tests directory
    129129                        if ( Settings.RunAllTests ) {
    130                                 sh 'make --no-print-directory -C tests timeouts="--timeout=600" all-tests debug=yes'
    131                                 sh 'make --no-print-directory -C tests timeouts="--timeout=600" all-tests debug=no '
     130                                sh 'make --no-print-directory -C tests all-tests debug=yes'
     131                                sh 'make --no-print-directory -C tests all-tests debug=no '
    132132                        }
    133133                        else {

  • automake/cfa.m4

    r6d44da1 r341bb80  
    5757
    5858AC_DEFUN([M4CFA_CANNON_CPU], [
    59         case $1 in
     59        case $arch_name in
    6060                "host") arch_name=${host_cpu};;
    61                 *) arch_name=$1;;
     61                *) ;;
    6262        esac
    6363

  • benchmark/Makefile.am

    r6d44da1 r341bb80  
    3333TIME_FORMAT = "%E"
    3434PRINT_FORMAT = %20s: #Comments needed for spacing
     35
     36LIBFIBRE_DIR ?= /home/tdelisle/software/KOS/src/
    3537
    3638.NOTPARALLEL:
    … …  
    109111
    110112## =========================================================================================================
    111 CTXSWITCH_DEPEND  =                \
     113ctxswitch$(EXEEXT): \
    112114        loop.run                                \
    113115        function.run                    \
    … …  
    119121        ctxswitch-upp_coroutine.run     \
    120122        ctxswitch-upp_thread.run        \
     123        -ctxswitch-kos_fibre.run        \
     124        -ctxswitch-kos_fibre2.run       \
    121125        ctxswitch-goroutine.run         \
    122126        ctxswitch-java_thread.run
    123127
    124 if WITH_LIBFIBRE
    125 CTXSWITCH_DEPEND  +=           \
    126         ctxswitch-kos_fibre.run  \
    127         ctxswitch-kos_fibre2.run
    128 
     128ctxswitch-pthread$(EXEEXT):
     129        @$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
     130
     131ctxswitch-cfa_coroutine$(EXEEXT):
     132        @$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.c
     133
     134ctxswitch-cfa_thread$(EXEEXT):
     135        @$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.c
     136
     137ctxswitch-cfa_thread2$(EXEEXT):
     138        @$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.c
     139
     140ctxswitch-upp_coroutine$(EXEEXT):
     141        @$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
     142
     143ctxswitch-upp_thread$(EXEEXT):
     144        @$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
    129145
    130146ctxswitch-kos_fibre$(EXEEXT):
    … …  
    133149ctxswitch-kos_fibre2$(EXEEXT):
    134150        @$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre2.cpp -I$(LIBFIBRE_DIR) -lfibre
    135 endif
    136 
    137 ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
    138 
    139 ctxswitch-pthread$(EXEEXT):
    140         @$(COMPILE)    -DBENCH_N=50000000 $(srcdir)/ctxswitch/pthreads.c
    141 
    142 ctxswitch-cfa_coroutine$(EXEEXT):
    143         @$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_cor.c
    144 
    145 ctxswitch-cfa_thread$(EXEEXT):
    146         @$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd.c
    147 
    148 ctxswitch-cfa_thread2$(EXEEXT):
    149         @$(CFACOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/cfa_thrd2.c
    150 
    151 ctxswitch-upp_coroutine$(EXEEXT):
    152         @$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_cor.cc
    153 
    154 ctxswitch-upp_thread$(EXEEXT):
    155         @$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
    156151
    157152ctxswitch-goroutine$(EXEEXT):

  • benchmark/Makefile.in

    r6d44da1 r341bb80  
    9393host_triplet = @host@
    9494noinst_PROGRAMS =
    95 @WITH_LIBFIBRE_TRUE@am__append_1 = \
    96 @WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre.run  \
    97 @WITH_LIBFIBRE_TRUE@    ctxswitch-kos_fibre2.run
    98 
    9995subdir = benchmark
    10096ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    … …  
    282278TIME_FORMAT = "%E"
    283279PRINT_FORMAT = %20s: #Comments needed for spacing
    284 CTXSWITCH_DEPEND = loop.run function.run fetch_add.run \
    285         ctxswitch-pthread.run ctxswitch-cfa_coroutine.run \
    286         ctxswitch-cfa_thread.run ctxswitch-cfa_thread2.run \
    287         ctxswitch-upp_coroutine.run ctxswitch-upp_thread.run \
    288         ctxswitch-goroutine.run ctxswitch-java_thread.run \
    289         $(am__append_1)
    290280testdir = $(top_srcdir)/tests
    291281all: all-am
    … …  
    480470
    481471
    482 .cfa.o:
     472.cfa.o: $(CFACC) $(CFACPP)
    483473        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
    484474        $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
    485475        $(am__mv) $$depbase.Tpo $$depbase.Po
    486476
    487 <<<<<<< HEAD
    488477.cfa.lo:
    489478        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
    … …  
    493482LIBFIBRE_DIR ?= /home/tdelisle/software/KOS/src/
    494483
    495 =======
    496 >>>>>>> master
    497484.NOTPARALLEL:
    498485
    … …  
    564551        $(COMPILE) -DBENCH_N=500000000  fetch_add.c
    565552
    566 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre$(EXEEXT):
    567 @WITH_LIBFIBRE_TRUE@    @$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp  -I$(LIBFIBRE_DIR) -lfibre
    568 
    569 @WITH_LIBFIBRE_TRUE@ctxswitch-kos_fibre2$(EXEEXT):
    570 @WITH_LIBFIBRE_TRUE@    @$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre2.cpp -I$(LIBFIBRE_DIR) -lfibre
    571 
    572 ctxswitch$(EXEEXT): $(CTXSWITCH_DEPEND)
     553ctxswitch$(EXEEXT): \
     554        loop.run                                \
     555        function.run                    \
     556        fetch_add.run                   \
     557        ctxswitch-pthread.run           \
     558        ctxswitch-cfa_coroutine.run     \
     559        ctxswitch-cfa_thread.run        \
     560        ctxswitch-cfa_thread2.run       \
     561        ctxswitch-upp_coroutine.run     \
     562        ctxswitch-upp_thread.run        \
     563        -ctxswitch-kos_fibre.run        \
     564        -ctxswitch-kos_fibre2.run       \
     565        ctxswitch-goroutine.run         \
     566        ctxswitch-java_thread.run
    573567
    574568ctxswitch-pthread$(EXEEXT):
    … …  
    589583ctxswitch-upp_thread$(EXEEXT):
    590584        @$(UPPCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/upp_thrd.cc
     585
     586ctxswitch-kos_fibre$(EXEEXT):
     587        @$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre.cpp  -I$(LIBFIBRE_DIR) -lfibre
     588
     589ctxswitch-kos_fibre2$(EXEEXT):
     590        @$(CXXCOMPILE) -DBENCH_N=50000000 $(srcdir)/ctxswitch/kos_fibre2.cpp -I$(LIBFIBRE_DIR) -lfibre
    591591
    592592ctxswitch-goroutine$(EXEEXT):

  • configure

    r6d44da1 r341bb80  
    630630GREP
    631631CPP
    632 WITH_LIBFIBRE_FALSE
    633 WITH_LIBFIBRE_TRUE
    634632RANLIB
    635633LEXLIB
    … …  
    25302528
    25312529
    2532 
    25332530# don't use the default CFLAGS as they unconditonnaly add -O2
    25342531: ${CFLAGS=""}
    … …  
    34623459
    34633460
    3464         case ${arch_name} in
     3461        case $arch_name in
    34653462                "host") arch_name=${host_cpu};;
    3466                 *) arch_name=${arch_name};;
     3463                *) ;;
    34673464        esac
    34683465
    … …  
    35013498
    35023499
    3503         case ${host_cpu} in
     3500        case $arch_name in
    35043501                "host") arch_name=${host_cpu};;
    3505                 *) arch_name=${host_cpu};;
     3502                *) ;;
    35063503        esac
    35073504
    … …  
    54415438
    54425439# Checks for libraries.
    5443 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fibre::yield in -lfibre" >&5
    5444 $as_echo_n "checking for Fibre::yield in -lfibre... " >&6; }
    5445 if ${ac_cv_lib_fibre_Fibre__yield+:} false; then :
    5446   $as_echo_n "(cached) " >&6
    5447 else
    5448   ac_check_lib_save_LIBS=$LIBS
    5449 LIBS="-lfibre  $LIBS"
    5450 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    5451 /* end confdefs.h.  */
    5452 
    5453 /* Override any GCC internal prototype to avoid an error.
    5454    Use char because int might match the return type of a GCC
    5455    builtin and then its argument prototype would still apply.  */
    5456 #ifdef __cplusplus
    5457 extern "C"
    5458 #endif
    5459 char Fibre::yield ();
    5460 int
    5461 main ()
    5462 {
    5463 return Fibre::yield ();
    5464   ;
    5465   return 0;
    5466 }
    5467 _ACEOF
    5468 if ac_fn_c_try_link "$LINENO"; then :
    5469   ac_cv_lib_fibre_Fibre__yield=yes
    5470 else
    5471   ac_cv_lib_fibre_Fibre__yield=no
    5472 fi
    5473 rm -f core conftest.err conftest.$ac_objext \
    5474     conftest$ac_exeext conftest.$ac_ext
    5475 LIBS=$ac_check_lib_save_LIBS
    5476 fi
    5477 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fibre_Fibre__yield" >&5
    5478 $as_echo "$ac_cv_lib_fibre_Fibre__yield" >&6; }
    5479 if test "x$ac_cv_lib_fibre_Fibre__yield" = xyes; then :
    5480   HAVE_LIBFIBRE=1
    5481 else
    5482   HAVE_LIBFIBRE=0
    5483 fi
    5484 
    5485  if test "$HAVE_LIBFIBRE" -eq 1; then
    5486   WITH_LIBFIBRE_TRUE=
    5487   WITH_LIBFIBRE_FALSE='#'
    5488 else
    5489   WITH_LIBFIBRE_TRUE='#'
    5490   WITH_LIBFIBRE_FALSE=
    5491 fi
    5492 
    54935440
    54945441# Checks for header files.
    … …  
    65306477if test -z "${am__fastdepCCAS_TRUE}" && test -z "${am__fastdepCCAS_FALSE}"; then
    65316478  as_fn_error $? "conditional \"am__fastdepCCAS\" was never defined.
    6532 Usually this means the macro was only invoked conditionally." "$LINENO" 5
    6533 fi
    6534 if test -z "${WITH_LIBFIBRE_TRUE}" && test -z "${WITH_LIBFIBRE_FALSE}"; then
    6535   as_fn_error $? "conditional \"WITH_LIBFIBRE\" was never defined.
    65366479Usually this means the macro was only invoked conditionally." "$LINENO" 5
    65376480fi

  • configure.ac

    r6d44da1 r341bb80  
    204204
    205205# Checks for libraries.
    206 AC_CHECK_LIB([fibre], [Fibre::yield], [HAVE_LIBFIBRE=1], [HAVE_LIBFIBRE=0])
    207 AM_CONDITIONAL([WITH_LIBFIBRE], [test "$HAVE_LIBFIBRE" -eq 1])
    208206
    209207# Checks for header files.

  • doc/bibliography/pl.bib

    r6d44da1 r341bb80  
    701701% B
    702702
    703 @article{Michael13,
    704     contributer = {pabuhr@plg},
    705     author      = {Maged M. Michael},
    706     title       = {The Balancing Act of Choosing Nonblocking Features},
    707     journal     = cacm,
    708     volume      = 56,
    709     number      = 9,
    710     month       = sep,
    711     year        = 2013,
    712     pages       = {46--53},
    713     publisher   = {ACM},
    714     address     = {New York, NY, USA},
    715 }
    716 
    717703@incollection{beta:old,
    718704    keywords    = {beta, patterns, virtual types},
    … …  
    922908
    923909@misc{Cforall,
    924     contributer = {pabuhr@plg},
    925910    key         = {Cforall},
    926     author      = {{\textsf{C}{$\mathbf{\forall}$} Features}},
    927     howpublished= {\href{https://plg.uwaterloo.ca/~cforall/features}{https://\-plg.uwaterloo.ca/\-~cforall/\-features}},
     911    title       = {\textsf{C}{$\mathbf{\forall}$} Features},
     912    howpublished= {\url{https://plg.uwaterloo.ca/~cforall/features}},
    928913    optnote     = {Accessed: 2018-01-01},
    929914}
    … …  
    941926
    942927@misc{CFAStackEvaluation,
    943     contributer = {a3moss@plg},
    944928    author      = {Aaron Moss},
    945929    title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
    946930    year        = 2018,
    947     howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
     931    howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{\textcolor{blue}{Q4: https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}}},
    948932    optnote     = {[Accessed May 2018]},
    949933}
    950934
    951935@article{Moss18,
    952     keywords    = {type systems, tuples, Cforall},
     936    keywords    = {concurrency, C++},
    953937    contributer = {pabuhr@plg},
    954938    author      = {Aaron Moss and Robert Schluntz and Peter A. Buhr},
    955939    title       = {\textsf{C}$\mathbf{\forall}$ : Adding Modern Programming Language Features to C},
    956940    year        = 2018,
    957     month       = aug,
    958941    journal     = spe,
    959     note        = {\href{http://dx.doi.org/10.1002/spe.2624}{http://\-dx.doi.org/\-10.1002/\-spe.2624}},
     942    note        = {Accepted, to appear},
    960943}
    961944
    … …  
    979962    comment     = {
    980963        The evidence given is thin.
    981     },
     964        }
    982965}
    983966
    … …  
    14331416}
    14341417
    1435 @misc{NThreadCode13,
    1436     keywords    = {N-thread software-solution mutual exclusion},
    1437     contributer = {pabuhr@plg},
    1438     key         = {concurrent locking},
    1439     author      = {Peter A. Buhr and David Dice and Wim H. Hesselink},
    1440     title       = {concurrent-locking},
    1441     howpublished= {\href{https://github.com/pabuhr/concurrent-locking}{https://\-github.com/\-pabuhr/\-concurrent-locking}},
    1442     optnote     = {[Accessed April 2017]},
    1443 }
    1444 
    14451418@incollection{Reppy93,
    14461419    keywords    = {ML, concurrency, continuation passing},
    … …  
    15161489    month       = dec,
    15171490    year        = 2017,
    1518     note        = {\href{https://plg.uwaterloo.ca/~usystem/pub/uSystem/uC++.pdf}{https://\-plg.uwaterloo.ca/\-~usystem/\-pub/\-uSystem/uC++.pdf}},
     1491    note        = {\href{http://plg.uwaterloo.ca/~usystem/pub/uSystem/u++-7.0.0.sh}{http://\-plg.\-uwaterloo.\-ca/\-$\sim$usystem/\-pub/\-uSystem/\-u++-7.0.0.sh}},
    15191492}
    15201493
    … …  
    15831556}
    15841557
    1585 @mastersthesis{Sun15,
    1586     author      = {Sun, Xianda},
    1587     title       = {Concurrent High-performance Persistent Hash Table In {J}ava},
    1588     school      = {School of Computer Science, University of Waterloo},
    1589     year        = 2015,
    1590     optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
    1591     note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/10013}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-10013}},
    1592 }
    1593 
    15941558@book{Andrews91:book,
    15951559    keywords    = {concurrency},
    … …  
    16161580
    16171581@mastersthesis{Delisle18,
    1618     keywords    = {concurrency, Cforall},
    1619     contributer = {pabuhr@plg},
    1620     author      = {Thierry Delisle},
     1582    author      = {Thierry Delisle },
    16211583    title       = {Concurrency in \textsf{C}$\mathbf{\forall}$},
    16221584    school      = {School of Computer Science, University of Waterloo},
    16231585    year        = 2018,
    1624     optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
     1586    address     = {Waterloo, Ontario, Canada, N2L 3G1},
    16251587    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/12888}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-12888}},
    1626 }
    1627 
    1628 @article{Delisle18b,
    1629     keywords    = {concurrency, Cforall},
    1630     contributer = {pabuhr@plg},
    1631     author      = {Thierry Delisle and Peter A. Buhr},
    1632     title       = {Concurrency in \textsf{C}$\mathbf{\forall}$},
    1633     year        = 2018,
    1634     journal     = spe,
    1635     pages       = {1-32},
    1636     note        = {submitted},
    16371588}
    16381589
    … …  
    18761827    key         = {Peter Buhr},
    18771828    title       = {CS343},
    1878     year        = 2018,
     1829    year        = 2017,
    18791830    howpublished= {\href{https://www.student.cs.uwaterloo.ca/~cs343}{https://\-www.student.cs.uwaterloo.ca/\-~cs343}},
    18801831}
    … …  
    29132864    keywords    = {concurrency, mutual exclusion, performance experiment, software solutions},
    29142865    title       = {Fast mutual exclusion by the {T}riangle algorithm},
    2915     author      = {Wim H. Hesselink and Peter A. Buhr and David Dice},
     2866    author      = {Wim H. Hesselink and Peter Buhr and David Dice},
    29162867    journal     = ccpe,
    29172868    volume      = 30,
    … …  
    29202871    month       = feb,
    29212872    publisher   = {John Wiley \& Sons},
    2922     note        = {\href{https://doi.org/10.1002/cpe.4183}{https://\-doi.org/\-10.1002/\-cpe.4183}}
     2873    note        = {\url{https://doi.org/10.1002/cpe.4183}}
    29232874}
    29242875
    … …  
    33323283    edition     = {{S}imon {M}arlow},
    33333284    year        = 2010,
    3334     note        = {\href{https://haskell.org/definition/haskell2010.pdf}{https://\-haskell.org/\-definition/\-haskell2010.pdf}},
     3285    note        = {\href{https://haskell.org/definition/haskell2010.pdf}{https://haskell.org/\-definition/\-haskell2010.pdf}},
    33353286}
    33363287
    … …  
    34063357}
    34073358
    3408 @article{Hesselink17b,
     3359@article{Hesselink17,
    34093360    keywords    = {concurrency, mutual exclusion, performance experiment, software solutions},
    34103361    title       = {High-Contention Mutual Exclusion by Elevator Algorithms},
    3411     author      = {Peter A. Buhr and David Dice and Wim H. Hesselink},
     3362    author      = {Peter Buhr and David Dice and Wim H. Hesselink},
    34123363    journal     = ccpe,
    3413     volume      = 30,
    3414     number      = 18,
     3364    volumeopt   = 30,
     3365    numberopt   = 4,
    34153366    year        = 2018,
    3416     month       = sep,
     3367    month       = may,
    34173368    publisher   = {John Wiley \& Sons},
    3418     note        = {\href{https://doi-org.proxy.lib.uwaterloo.ca/10.1002/cpe.4475}{https://\-doi-org.proxy.lib.uwaterloo.ca/\-10.1002/\-cpe.4475}},
     3369    note        = {\url{https://doi-org.proxy.lib.uwaterloo.ca/10.1002/cpe.4475}}
    34193370}
    34203371
    … …  
    38953846% K
    38963847
    3897 @inproceedings{Buhr96b,
    3898     author      = {Peter A. Buhr and Martin Karsten and Jun Shih},
    3899     title       = {{\small\textsf{KDB}}: A Multi-threaded Debugger for Multi-threaded Applications},
    3900     booktitle   = {Proceedings of SPDT'96: SIGMETRICS Symposium on Parallel and Distributed Tools},
    3901     publisher   = {ACM Press},
    3902     address     = {Philadelphia, Pennsylvania, U.S.A.},
    3903     month       = may,
    3904     year        = 1996,
    3905     pages       = {80-87},
    3906 }
    3907 
    39083848@article{Duggan96,
    39093849    keywords    = {concurrency, critical section},
    39103850    contributer = {pabuhr@plg},
    3911     author      = {Dominic Duggan and Gordon V. Cormack and John Ophel},
     3851    author      = {Dominic Duggan and G. V. Cormack and John Ophel},
    39123852    title       = {Kinded Type Inference for Parametric Overloading},
    39133853    journal     = acta,
    … …  
    45934533% N
    45944534
    4595 @techreport{Drepper03,
    4596     keywords    = {NPTL, threading, 1:1 model},
    4597     contributer = {pabuhr@plg},
    4598     author      = {Ulrich Drepper and Ingo Molnar},
    4599     title       = {The Native POSIX Thread Library for Linux},
    4600     institution = {Red Hat},
    4601     year        = 2003,
    4602     note        = {\href{http://www.cs.utexas.edu/~witchel/372/lectures/POSIX_Linux_Threading.pdf}{http://www.cs.utexas.edu/\-$\sim$witchel/\-372/\-lectures/\-POSIX\_Linux\_Threading.pdf}},
    4603 }
    4604 
    46054535@article{Haddon77,
    46064536    keywords    = {monitors, nested monitor calls},
    … …  
    47264656    volume      = 9,
    47274657    pages       = {157-164},
    4728 }
    4729 
    4730 @misc{nginx,
    4731     key         = {nginx},
    4732     author      = {{NGINX}},
    4733     howpublished= {\href{https://www.nginx.com}{https://\-www.nginx.com}},
    47344658}
    47354659
    … …  
    48444768@misc{obj-c-book,
    48454769    keywords    = {objective-c},
    4846     contributor = {pabuhr@plg},
     4770    contributor = {a3moss@uwaterloo.ca},
    48474771    key         = {Objective-C},
    4848     author      = {Objective-C},
     4772    title       = {Objective-C},
    48494773    publisher   = {Apple Inc.},
    4850     year        = 2014,
    4851     howpublished= {\href{https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC}{https://\-developer.apple.com/\-library/archive/\-documentation/\-Cocoa/\-Conceptual/\-ProgrammingWithObjectiveC}},
     4774    year        = 2015,
     4775    howpublished= {\href{https://developer.apple.com/library/content/documentation/General/Conceptual/DevPedia-CocoaCore/ObjectiveC.html}{https://developer.apple.com/\-library/\-content/\-documentation/\-General/\-Conceptual/\-DevPedia-\-CocoaCore/\-ObjectiveC.html}},
    48524776    optnote     = {Accessed: 2018-03}
    48534777}
    … …  
    48594783    title       = {{X}code 7 Release Notes},
    48604784    year        = 2015,
    4861     howpublished= {\href{https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc7_release_notes.html}{https://\-developer.apple.com/\-library/\-content/\-documentation/\-Xcode/\-Conceptual/\-RN-Xcode-Archive/\-Chapters/\-xc7\_release\_notes.html}},
     4785    howpublished= {\href{https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc7_release_notes.html}{https://developer.apple.com/\-library/\-content/\-documentation/\-Xcode/\-Conceptual/\-RN-Xcode-Archive/\-Chapters/\-xc7\_release\_notes.html}},
    48624786    optnote     = {Accessed: 2017-04}
    48634787}
    … …  
    53595283}
    53605284
    5361 @misc{perf,
    5362     contributer = {pabuhr@plg},
    5363     key         = {perf},
    5364     author      = {perf},
    5365     howpublished= {\href{https://perf.wiki.kernel.org/index.php/Tutorial}{https://\-perf.wiki.kernel.org/\-index.php/\-Tutorial}},
    5366 }
    5367 
    5368 @misc{Verch12,
    5369     contributer = {pabuhr@plg},
    5370     author      = {Shaun Verch},
    5371     title       = {Performance Analysis of 64-Bit Capriccio},
    5372     month       = may,
    5373     year        = 2012,
    5374     howpublished= {\href{http://cs.brown.edu/research/pubs/theses/masters/2012/verch.pdf}{http://cs.brown.edu/\-research/\-pubs/\-theses/\-masters/\-2012/\-verch.pdf}},
    5375     optnote     = {Accessed: 2013-10-4}
    5376 }
    5377 
    53785285@article{Anderson90,
    53795286    keywords    = {spin locks, back off, performance},
    … …  
    55965503    note        = {Proceedings of the OOPSLA'89 Conference, Oct. 1--6, 1989, New Orleans, Lousiana},
    55975504    abstract    = {},
    5598 }
    5599 
    5600 @inproceedings{Buhr98,
    5601     keywords    = {profiling, monitoring, visualization},
    5602     contributer = {pabuhr@plg},
    5603     author      = {Peter A. Buhr and Robert Denda},
    5604     title       = {{$\mu$Profiler} : Profiling User-Level Threads in a Shared-Memory Programming Environment},
    5605     booktitle   = {Proceedings of the Second International Symposium on Computing in Object-Oriented Parallel Environments (ISCOPE'98)},
    5606     series      = {Lecture Notes in Computer Science},
    5607     publisher   = {Springer-Verlag},
    5608     volume      = 1505,
    5609     opteditor   = {Dennis Caromel and Rodney R. Oldehoeft and Marydell Tholburn},
    5610     address     = {Santa Fe, New Mexico, U.S.A.},
    5611     month       = dec,
    5612     year        = 1998,
    5613     pages       = {159-166},
    56145505}
    56155506
    … …  
    59645855    keywords    = {Cyclone, existential types, polymorphism, type variables},
    59655856    contributer = {a3moss@plg},
    5966     author      = {Dan Grossman},
     5857    author      = {D. Grossman},
    59675858    title       = {Quantified Types in an Imperative Language},
    59685859    journal     = toplas,
    … …  
    60735964}
    60745965
    6075 @article{Ronsse03,
    6076     keywords    = {profiling, replay},
    6077     contributer = {pabuhr@plg},
    6078     author      = {Michiel Ronsse and De Bosschere, Koen and Mark Christiaens and Jacques Chassin de Kergommeaux and Dieter Kranzlm\"{u}ller},
    6079     title       = {Record/Replay for Nondeterministic Program Executions},
    6080     journal     = cacm,
    6081     month       = sep,
    6082     year        = 2003,
    6083     volume      = 46,
    6084     number      = 9,
    6085     pages       = {62-67},
    6086 }
    6087 
    60885966@article{Robinson48,
    60895967    keywords    = {recursion, Ackermann function},
    … …  
    61246002}
    61256003
    6126 @mastersthesis{Schuster99,
    6127     author      = {Oliver Schuster},
    6128     title       = {Replay of Concurrent Shared-Memory Programs},
    6129     school      = {Universit\"at Mannheim},
    6130     address     = {Mannheim, Deutschland},
    6131     year        = 1999,
    6132     month       = apr,
    6133     type        = {Diplomarbeit},
    6134     note        = {\href{ftp://plg.uwaterloo.ca/pub/theses/SchusterThesis.ps.gz}{ftp://\-plg.uwaterloo.ca/\-pub/\-theses/\-SchusterThesis.ps.gz}},
    6135 }
    6136 
    61376004@article{Euclid,
    61386005    keywords    = {Euclid},
    … …  
    61666033    school      = {School of Computer Science, University of Waterloo},
    61676034    year        = 2017,
    6168     optaddress  = {Waterloo, Ontario, Canada, N2L 3G1},
     6035    address     = {Waterloo, Ontario, Canada, N2L 3G1},
    61696036    note        = {\href{https://uwspace.uwaterloo.ca/handle/10012/11830}{https://\-uwspace.uwaterloo.ca/\-handle/\-10012/\-11830}},
    61706037}
    … …  
    69936860    contributer = {pabuhr@plg},
    69946861    key         = {TIOBE Index},
    6995     author      = {{TIOBE Index}},
     6862    title       = {{TIOBE} Index},
    69966863    howpublished= {\href{http://www.tiobe.com/tiobe_index}{http://\-www.tiobe.com/\-tiobe\_index}},
    69976864    optnote     = {Accessed: 2018-09},
    … …  
    71337000    year        = 1980
    71347001}
    7135 
    7136 @misc{TraceCompass,
    7137     contributer = {pabuhr@plg},
    7138     key         = {Trace Compass},
    7139     author      = {{T}race {C}ompass},
    7140     howpublished= {\href{https://projects.eclipse.org/proposals/trace-compass}{https://\-projects.eclipse.org/\-proposals/\-trace-compass}},
    7141 }
    71427002 
    71437003@article{Leroy00,
    … …  
    72757135    title       = {Usability Challenges in Exception Handling},
    72767136    booktitle   = {5th International Workshop on Exception Handling (WEH)},
    7277     optorganization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)},
     7137    organization= {16th International Symposium on the Foundations of Software Engineering (FSE 16)},
    72787138    address     = {Zurich, Switzerland},
    72797139    month       = jun,
    … …  
    74197279}
    74207280
    7421 @inproceedings{vonBehren03,
    7422     keywords    = {threads, events, web server},
    7423     contributer = {pabuhr@plg},
    7424     author      = {Rob von Behren and Jeremy Condit and Eric Brewer},
    7425     title       = {Why Events Are a Bad Idea (for high-concurrency servers)},
    7426     booktitle   = {HotOS IX: The 9th Workshop on Hot Topics in Operating Systems},
    7427     publisher   = {USENIX Association},
    7428     address     = {Lihue, Hawaii, U.S.A.},
    7429     month       = may,
    7430     year        = 2003,
    7431     pages       = {19-24},
    7432 }
    7433 
    74347281@techreport{Moss90,
    74357282    keywords    = {Swizzling, database},
    … …  
    74967343    year        = 1986,
    74977344    editor      = {Norman Meyrowitz},
    7498     publisher   = sigplan,
     7345    publisher   = sigplan # " 21(11)",
    74997346    organization= {Association for Computing Machinery},
    75007347    address     = {Portland, Oregon},
    7501     month       = sep,
     7348    month       = sep # { 29}
    75027349}
    75037350
    … …  
    75087355    year        = 1987,
    75097356    editor      = {Norman Meyrowitz},
    7510     publisher   = sigplan,
     7357    publisher   = sigplan # " 22(12)",
    75117358    organization= {Association for Computing Machinery},
    75127359    address     = {Orlando, Florida},
    7513     month       = oct,
     7360    month       = oct # { 4--8}
    75147361}
    75157362
    … …  
    75207367    year        = 1988,
    75217368    editor      = {Norman Meyrowitz},
    7522     publisher   = sigplan,
     7369    publisher   = sigplan # " 23(11)",
    75237370    organization= {Association for Computing Machinery},
    75247371    address     = {San Diego, California},
    7525     month       = sep,
     7372    month       = sep # { 25--30}
    75267373}
    75277374
    … …  
    75327379    year        = 1989,
    75337380    editor      = {Norman Meyrowitz},
    7534     publisher   = sigplan,
     7381    publisher   = sigplan # " 24(10)",
    75357382    organization= {Association for Computing Machinery},
    75367383    address     = {New Orleans, Louisiana},
    7537     month       = oct,
     7384    month       = oct # { 1--6}
    75387385}
    75397386
    … …  
    75447391    year        = 1990,
    75457392    editor      = {Norman Meyrowitz},
    7546     publisher   = sigplan,
     7393    publisher   = sigplan # " 25(10)",
    75477394    organization= {Association for Computing Machinery},
    75487395    address     = {Ottawa, Canada},
    7549     month       = oct,
     7396    month       = oct # { 21--25}
    75507397}
    75517398
    … …  
    75567403    year        = 1991,
    75577404    editor      = {Andreas Paepcke},
    7558     publisher   = sigplan,
     7405    publisher   = sigplan # " 26(11)",
    75597406    organization= {Association for Computing Machinery},
    75607407    address     = {Phoenix, Arizona},
    7561     month       = oct,
    7562 }
     7408    month       = oct # { 6--11}
     7409}

  • doc/papers/general/Paper.tex

    r6d44da1 r341bb80  
    196196\author[1]{Robert Schluntz}
    197197\author[1]{Peter A. Buhr}
     198\author[]{\textcolor{blue}{Q1 AUTHOR NAMES CORRECT}}
    198199\authormark{MOSS \textsc{et al}}
    199200
    … …  
    207208The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating systems.
    208209This installation base and the programmers producing it represent a massive software engineering investment spanning decades and likely to continue for decades more.
    209 Nevertheless, C, which was first standardized almost 30 years ago, lacks many features that make programming in more modern languages safer and more productive.
     210Nevertheless, C, which was first standardized almost 30 \textcolor{blue}{CHANGE ``40'' TO ``30''} years ago, lacks many features that make programming in more modern languages safer and more productive.
    210211The goal of the \CFA project (pronounced ``C for all'') is to create an extension of C that provides modern safety and productivity features while still ensuring strong backward compatibility with C and its programmers.
    211212Prior projects have attempted similar goals but failed to honor the C programming style;
    … …  
    225226
    226227
    227 \vspace*{-10pt}
    228228\section{Introduction}
    229229
    230230The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating systems.
    231231This installation base and the programmers producing it represent a massive software engineering investment spanning decades and likely to continue for decades more.
    232 The TIOBE index~\cite{TIOBE} ranks the top five most \emph{popular} programming languages as Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, and Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail.
     232The TIOBE index~\cite{TIOBE} \textcolor{blue}{CHANGE ``TIOBE'' TO ``The TIOBE index''} ranks the top five most \emph{popular} programming languages as Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, and Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail.
    233233The top three rankings over the past 30 years are as follows.
     234\newpage
     235\textcolor{blue}{MOVE TABLE HERE}
    234236\begin{center}
    235237\setlength{\tabcolsep}{10pt}
    … …  
    244246\lstMakeShortInline@%
    245247\end{center}
     248
    246249Love it or hate it, C is extremely popular, highly used, and one of the few systems languages.
    247250In many cases, \CC is often used solely as a better C.
    248 Nevertheless, C, which was first standardized almost 30 years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
     251Nevertheless, C, which was first standardized almost 30 \textcolor{blue}{CHANGE ``40'' TO ``30''} years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
    249252
    250253\CFA (pronounced ``C for all'' and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language features to C, while maintaining source and runtime compatibility in the familiar C programming model.
    … …  
    278281ultimately, a compiler is necessary for advanced features and optimal performance.
    279282% The translator design is based on the \emph{visitor pattern}, allowing multiple passes over the abstract code-tree, which works well for incrementally adding new feature through additional visitor passes.
    280 Two key translator components are expression analysis, determining expression validity and what operations are required for its implementation, and code generation, dealing with multiple forms of overloading, polymorphism, and multiple return values by converting them into the C code for a C compiler that supports none of these features.
     283Two key translator components are expression analysis, determining expression validity and what operations are required for its implementation, and code generation, dealing with multiple forms of overloading, polymorphism, and multiple return values by converting them into C code for a C compiler that supports none of these features.
    281284Details of these components are available in chapters 2 and 3 in the work of Bilson~\cite{Bilson03} and form the base for the current \CFA translator.
    282285% @plg2[8]% cd cfa-cc/src; cloc libcfa
    … …  
    342345Section~\ref{sec:libraries} includes a number of examples of how this overloading simplifies \CFA programming relative to C.
    343346Code generation for these overloaded functions and variables is implemented by the usual approach of mangling the identifier names to include a representation of their type, while \CFA decides which overload to apply based on the same ``usual arithmetic conversions'' used in C to disambiguate operator overloads.
    344 
     347\textcolor{blue}{REMOVE ``We have the following as an example''}
    345348\newpage
     349\textcolor{blue}{UPDATE FOLLOWING PROGRAM EXAMPLE WITH ADJUSTED COMMENTS TO FIT PAGE WIDTH.}
    346350\begin{cfa}
    347351int max = 2147483647;                                           $\C[4in]{// (1)}$
    … …  
    358362In some cases, hundreds of names can be reduced to tens, resulting in a significant cognitive reduction.
    359363In the above, the name @max@ has a consistent meaning, and a programmer only needs to remember the single concept: maximum.
    360 To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler uses @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada).
     364To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler use @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada).
    361365As is shown later, there are a number of situations where \CFA takes advantage of available type information to disambiguate, where other programming languages generate ambiguities.
    362366
    … …  
    376380\label{sec:poly-fns}
    377381
    378 The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name).
     382The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name). \textcolor{blue}{REMOVE ``as follows''}
    379383\begin{cfa}
    380384`forall( otype T )` T identity( T val ) { return val; }
    … …  
    391395
    392396Since bare polymorphic types provide a restricted set of available operations, \CFA provides a \newterm{type assertion}~\cite[pp.~37-44]{Alphard} mechanism to provide further type information, where type assertions may be variable or function declarations that depend on a polymorphic type variable.
    393 For example, the function @twice@ can be defined using the \CFA syntax for operator overloading.
     397For example, the function @twice@ can be defined using the \CFA syntax for operator overloading. \textcolor{blue}{REMOVE ``as follows''}
    394398\begin{cfa}
    395399forall( otype T `| { T ?+?(T, T); }` ) T twice( T x ) { return x `+` x; }  $\C{// ? denotes operands}$
    … …  
    405409Crucial to the design of a new programming language are the libraries to access thousands of external software features.
    406410Like \CC, \CFA inherits a massive compatible library base, where other programming languages must rewrite or provide fragile interlanguage communication with C.
    407 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array.
     411A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array. \textcolor{blue}{REMOVE ``as follows''}
    408412\begin{cfa}
    409413void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
    … …  
    601605To enable interoperation among equivalent instantiations of a generic type, the translator saves the set of instantiations currently in scope and reuses the generated structure declarations where appropriate.
    602606A function declaration that accepts or returns a concrete generic type produces a declaration for the instantiated structure in the same scope, which all callers may reuse.
    603 For example, the concrete instantiation for @pair( const char *, int )@ is
     607For example, the concrete instantiation for @pair( const char *, int )@ is \textcolor{blue}{REMOVE ``as follows.''}
    604608\begin{cfa}
    605609struct _pair_conc0 {
    … …  
    630634If a dynamic generic type is declared to be passed or returned by value from a polymorphic function, the translator can safely assume that the generic type is complete (\ie has a known layout) at any call site, and the offset array is passed from the caller;
    631635if the generic type is concrete at the call site, the elements of this offset array can even be statically generated using the C @offsetof@ macro.
    632 As an example, the body of the second @value@ function is implemented as
     636As an example, the body of the second @value@ function is implemented as \textcolor{blue}{REMOVE ``follows.''}
    633637\begin{cfa}
    634638_assign_T( _retval, p + _offsetof_pair[1] ); $\C{// return *p.second}$
    … …  
    636640\newpage
    637641\noindent
    638 Here, @_assign_T@ is passed in as an implicit parameter from @otype T@, and takes two @T *@ (@void *@ in the generated code), a destination and a source, and @_retval@ is the pointer to a caller-allocated buffer for the return value, the usual \CFA method to handle dynamically sized return types.
     642\textcolor{blue}{NO PARAGRAPH INDENT} Here, @_assign_T@ is passed in as an implicit parameter from @otype T@, and takes two @T *@ (@void *@ in the generated code), a destination and a source, and @_retval@ is the pointer to a caller-allocated buffer for the return value, the usual \CFA method to handle dynamically sized return types.
    639643@_offsetof_pair@ is the offset array passed into @value@;
    640 this array is generated at the call site as
     644this array is generated at the call site as \textcolor{blue}{REMOVE ``follows.''}
    641645\begin{cfa}
    642646size_t _offsetof_pair[] = { offsetof( _pair_conc0, first ), offsetof( _pair_conc0, second ) }
    … …  
    673677
    674678Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \newterm{tag structures}.
    675 Sometimes, information is only used for type checking and can be omitted at runtime.
     679Sometimes, information is only used for type checking and can be omitted at runtime. \textcolor{blue}{REMOVE ``As an example, we have the following''}
    676680\begin{cquote}
    677681\lstDeleteShortInline@%
    … …  
    720724Both approaches are awkward.
    721725% FIX
    722 Alternatively, a programming language can directly support returning multiple values, \eg \CFA provides the following.
     726Alternatively, a programming language can directly support returning multiple values, \eg \CFA provides the following. \textcolor{blue}{REPLACE ``in \CFA, we have the following'' WITH ``\CFA provides the following''}
    723727\begin{cfa}
    724728[ int, int ] div( int num, int den );           $\C{// return two integers}$
    … …  
    741745As such, \CFA allows assigning multiple values from a function into multiple variables, using a square-bracketed list of lvalue expressions (as above), called a \newterm{tuple}.
    742746
    743 However, functions also use \newterm{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVFs), \eg, \CFA provides the following.
     747However, functions also use \newterm{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVFs), \eg, \CFA provides the following. \textcolor{blue}{REPLACE ``As an example, we have the following'' WITH ``\CFA provides the following''}
    744748\begin{cfa}
    745749printf( "%d %d\n", div( 13, 5 ) );                      $\C{// return values seperated into arguments}$
    … …  
    777781printf( "%d %d\n", qr );
    778782\end{cfa}
    779 \CFA also supports \newterm{tuple indexing} to access single components of a tuple expression.
     783\CFA also supports \newterm{tuple indexing} to access single components of a tuple expression. \textcolor{blue}{REMOVE ``as follows''}
    780784\begin{cfa}
    781785[int, int] * p = &qr;                                           $\C{// tuple pointer}$
    … …  
    805809In the call to @f@, @x@ is implicitly flattened so the components of @x@ are passed as two arguments.
    806810In the call to @g@, the values @y@ and @10@ are structured into a single argument of type @[int, int]@ to match the parameter type of @g@.
    807 Finally, in the call to @h@, @x@ is flattened to yield an argument list of length 3, of which the first component of @x@ is passed as the first parameter of @h@, and the second component of @x@ and @y@ are structured into the second argument of type @[int, int]@.
    808 The flexible structure of tuples permits a simple and expressive function call syntax to work seamlessly with both SRVFs and MRVFs with any number of arguments of arbitrarily complex structure.
     811Finally, in the call to @h@, @x@ is flattened to yield an argument list of length 3, of which the first component of @x@ is passed as the first parameter of @h@, and the second component \textcolor{blue}{CHANGE ``components'' TO ``component''} of @x@ and @y@ are structured into the second argument of type @[int, int]@.
     812The flexible structure of tuples permits a simple and expressive function call syntax to work seamlessly with both SRVFs and MRVFs \textcolor{blue}{REMOVE ``and''} with any number of arguments of arbitrarily complex structure.
    809813
    810814
    811815\subsection{Tuple assignment}
    812816
    813 \enlargethispage{-10pt}
    814817An assignment where the left side is a tuple type is called \newterm{tuple assignment}.
    815818There are two kinds of tuple assignment depending on whether the right side of the assignment operator has a tuple type or a nontuple type, called \newterm{multiple} and \newterm{mass assignment}, respectively.
    … …  
    825828Both kinds of tuple assignment have parallel semantics, so that each value on the left and right sides is evaluated before any assignments occur.
    826829As a result, it is possible to swap the values in two variables without explicitly creating any temporary variables or calling a function, \eg, @[x, y] = [y, x]@.
    827 This semantics means mass assignment differs from C cascading assignment (\eg @a = b = c@) in that conversions are applied in each individual assignment, which prevents data loss from the chain of conversions that can happen during a cascading assignment.
     830This semantics means mass assignment differs from C cascading
     831\newpage
     832assignment (\eg @a = b = c@) in that conversions are applied in each individual assignment, which prevents data loss from the chain of conversions that can happen during a cascading assignment.
    828833For example, @[y, x] = 3.14@ performs the assignments @y = 3.14@ and @x = 3.14@, yielding @y == 3.14@ and @x == 3@, whereas C cascading assignment @y = x = 3.14@ performs the assignments @x = 3.14@ and @y = x@, yielding @3@ in @y@ and @x@.
    829834Finally, tuple assignment is an expression where the result type is the type of the left-hand side of the assignment, just like all other assignment expressions in C.
    … …  
    852857[int, int, int] y = x.[2, 0, 2];                        $\C{// duplicate: [y.0, y.1, y.2] = [x.2, x.0.x.2]}$
    853858\end{cfa}
    854 It is also possible for a member access to contain other member accesses.
     859It is also possible for a member access to contain other member accesses. \textcolor{blue}{REMOVE ``, as follows.''}
    855860\begin{cfa}
    856861struct A { double i; int j; };
    … …  
    964969Since nothing is known about a parameter pack by default, assertion parameters are key to doing anything meaningful.
    965970Unlike variadic templates, @ttype@ polymorphic functions can be separately compiled.
    966 For example, the following is a generalized @sum@ function.
     971For example, the following is a \textcolor{blue}{CHANGE ``As an example, we have the following'' TO ``For example, the following is a''} generalized @sum@ function.
    967972\begin{cfa}
    968973int sum$\(_0\)$() { return 0; }
    … …  
    9981003Unlike C variadic functions, it is unnecessary to hard code the number and expected types.
    9991004Furthermore, this code is extendable for any user-defined type with a @?+?@ operator.
    1000 Summing arbitrary heterogeneous lists is possible with similar code by adding the appropriate type variables and addition operators.
     1005Summing \textcolor{blue}{REMOVE ``up''} arbitrary heterogeneous lists is possible with similar code by adding the appropriate type variables and addition operators.
    10011006
    10021007It is also possible to write a type-safe variadic print function to replace @printf@:
    … …  
    10341039Tuples are implemented in the \CFA translator via a transformation into \newterm{generic types}.
    10351040For each $N$, the first time an $N$-tuple is seen in a scope, a generic type with $N$ type parameters is generated.
    1036 For example, the following
     1041For example, the following \textcolor{blue}{CHANGE ``, as follows:'' TO ``For example, the following''}
    10371042\begin{cfa}
    10381043[int, int] f() {
    … …  
    15141519\end{cfa}
    15151520
    1516 Finally, \CFA provides a Java-like  @finally@ clause after the catch clauses.
     1521\textcolor{blue}{PARAGRAPH INDENT} Finally, \CFA provides a Java-like  @finally@ clause after the catch clauses.
    15171522\begin{cfa}
    15181523try {
    … …  
    16501655
    16511656C declaration syntax is notoriously confusing and error prone.
    1652 For example, many C programmers are confused by a declaration as simple as the following.
     1657For example, many C programmers are confused by a declaration as simple as the following. \textcolor{blue}{CHANGE ``simple a declaration as in'' TO ``declaration as simple as''}
    16531658\begin{cquote}
    16541659\lstDeleteShortInline@%
    … …  
    17041709% Specifically, the character @*@ is used to indicate a pointer, square brackets @[@\,@]@ are used to represent an array or function return value, and parentheses @()@ are used to indicate a function parameter.
    17051710However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
    1706 For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as
     1711For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as \textcolor{blue}{REMOVE ``follows.''}
    17071712\begin{cquote}
    17081713\lstDeleteShortInline@%
    … …  
    19541959Since \CFA in not object oriented, adopting dynamic scoping does not make sense;
    19551960instead, \CFA adopts \CC static nesting, using the member-selection operator ``@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``@::@'' (see Figure~\ref{f:TypeNestingQualification}).
    1956 In the C left example, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope.
    1957 In the \CFA right example, the types are not hoisted and accessible.
    19581961
    19591962\begin{figure}
    … …  
    20252028\vspace*{-8pt}
    20262029\end{figure}
     2030
     2031In the C left example, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope.
     2032In the \CFA right example, the types are not hoisted and accessible.
    20272033
    20282034
    … …  
    20602066For details of the code-generation placement of implicit constructor and destructor calls among complex executable statements, see section~2.2 in the work of Schlintz~\cite{Schluntz17}.
    20612067
    2062 \CFA also provides syntax for \newterm{initialization} and \newterm{copy}.
     2068\CFA also provides syntax for \newterm{initialization} and \newterm{copy}. \textcolor{blue}{REMOVE ``, as follows''}
    20632069\begin{cfa}
    20642070void ?{}( VLA & vla, int size, char fill = '\0' ) {  $\C{// initialization}$
    … …  
    21252131
    21262132A simple example is allowing the underscore, as in Ada, to separate prefixes, digits, and suffixes in all \CFA constants, \eg @0x`_`1.ffff`_`ffff`_`p`_`128`_`l@, where the underscore is also the standard separator in C identifiers.
    2127 \CC uses a single quote as a separator, but it is restricted among digits, precluding its use in the literal prefix or suffix, \eg @0x1.ffff@@`'@@ffffp128l@, and causes problems with most integrated development environments (IDEs), which must be extended to deal with this alternate use of the single quote.
     2133\CC uses a single quote as a separator, but it is restricted among digits, precluding its use in the literal prefix or suffix, \eg @0x1.ffff@@`'@@ffffp128l@, and causes problems with most \textcolor{blue}{Q2 CHANGE ``IDEs'' TO ``integrated development environments (IDEs)''}, which must be extended to deal with this alternate use of the single quote.
    21282134
    21292135
    … …  
    21972203y = "12345678901234567890123456789"|`mp| + "12345678901234567890123456789"|`mp|;
    21982204\end{cfa}
    2199 Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions, where @?`@ denotes a postfix-function name and @`@ denotes a postfix-function call.
     2205Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions, where @?`@ \textcolor{blue}{USE CHARACTER \lstinline@`@ NOT \textsf{'}} denotes a postfix-function name and @`@ \textcolor{blue}{USE CHARACTER \lstinline@`@ NOT `} denotes a postfix-function call.
    22002206}%
    22012207\begin{cquote}
    … …  
    23392345\lstMakeShortInline@%
    23402346\end{cquote}
    2341 The result is a significant reduction in names to access typed constants.
     2347The result is a significant reduction in names to access typed constants. \textcolor{blue}{REMOVE ``, as follows.''}
    23422348\begin{cquote}
    23432349\lstDeleteShortInline@%
    … …  
    23842390\lstMakeShortInline@%
    23852391\end{cquote}
    2386 The result is a significant reduction in names to access math functions.
     2392The result is a significant reduction in names to access math functions. \textcolor{blue}{REMOVE ``, as follows.''}
    23872393\begin{cquote}
    23882394\lstDeleteShortInline@%
    … …  
    24312437\lstMakeShortInline@%
    24322438\end{cquote}
    2433 The result is a significant reduction in names to access the utility functions.
     2439The result is a significant reduction in names to access the utility functions. \textcolor{blue}{REMOVE ``, as follows.''}
    24342440\begin{cquote}
    24352441\lstDeleteShortInline@%
    … …  
    24522458In addition, there are polymorphic functions, like @min@ and @max@, that work on any type with operator @?<?@ or @?>?@.
    24532459
    2454 The following shows one example where \CFA \emph{extends} an existing standard C interface to reduce complexity and provide safety.
     2460The following shows one example where \CFA \textcolor{blue}{ADD SPACE} \emph{extends} an existing standard C interface to reduce complexity and provide safety.
    24552461C/\Celeven provide a number of complex and overlapping storage-management operations to support the following capabilities.
    24562462\begin{list}{}{\itemsep=0pt\parsep=0pt\labelwidth=0pt\leftmargin\parindent\itemindent-\leftmargin\let\makelabel\descriptionlabel}
    … …  
    26432649\label{s:MultiPrecisionIntegers}
    26442650
    2645 \CFA has an interface to the GNU multiple precision (GMP) signed integers~\cite{GMP}, similar to the \CC interface provided by GMP.
     2651\CFA has an interface to the \textcolor{blue}{Q3 CHANGE ``GMP multiprecision'' TO ``GNU multiple precision (GMP)''} signed integers~\cite{GMP}, similar to the \CC interface provided by GMP.
    26462652The \CFA interface wraps GMP functions into operator functions to make programming with multiprecision integers identical to using fixed-sized integers.
    26472653The \CFA type name for multiprecision signed integers is @Int@ and the header file is @gmp@.
    … …  
    27362742Figure~\ref{fig:eval} and Table~\ref{tab:eval} show the results of running the benchmark in Figure~\ref{fig:BenchmarkTest} and its C, \CC, and \CCV equivalents.
    27372743The graph plots the median of five consecutive runs of each program, with an initial warm-up run omitted.
    2738 All code is compiled at \texttt{-O2} by gcc or g++ 6.4.0, with all \CC code compiled as \CCfourteen.
    2739 The benchmarks are run on an Ubuntu 16.04 workstation with 16 GB of RAM and a 6-core AMD FX-6300 CPU with 3.5 GHz maximum clock frequency.
     2744All code is compiled at \texttt{-O2} by gcc or g++ 6.4.0, with all \CC code compiled as \CCfourteen. \textcolor{blue}{CHANGE ``\CC{}fourteen'' TO ``\CCfourteen''}
     2745The benchmarks are run on an Ubuntu 16.04 workstation with 16 GB of RAM and a 6-core AMD FX-6300 CPU with 3.5 GHz \textcolor{blue}{REMOVE ``of''} maximum clock frequency.
    27402746
    27412747\begin{figure}
    … …  
    27642770\end{table}
    27652771
    2766 \enlargethispage{-10pt}
    27672772The C and \CCV variants are generally the slowest with the largest memory footprint, due to their less-efficient memory layout and the pointer indirection necessary to implement generic types;
    27682773this inefficiency is exacerbated by the second level of generic types in the pair benchmarks.
    … …  
    28552860Tuples are a generalization of @std::pair@, in that they allow for arbitrary length, fixed-size aggregation of heterogeneous values.
    28562861Operations include @std::get<N>@ to extract values, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons.
    2857 \CCseventeen proposes \emph{structured bindings}~\cite{Sutter15} to eliminate predeclaring variables and the use of @std::tie@ for binding the results.
     2862\CCseventeen \textcolor{blue}{CHANGE ``\CC{}seventeen TO ``\CCseventeen''} proposes \emph{structured bindings}~\cite{Sutter15} to eliminate predeclaring variables and the use of @std::tie@ for binding the results.
    28582863This extension requires the use of @auto@ to infer the types of the new variables; hence, complicated expressions with a nonobvious type must be documented with some other mechanism.
    28592864Furthermore, structured bindings are not a full replacement for @std::tie@, as it always declares new variables.

  • doc/user/user.tex

    r6d44da1 r341bb80  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Fri Aug 31 07:54:50 2018
    14 %% Update Count     : 3396
     13%% Last Modified On : Thu Jul 26 17:29:05 2018
     14%% Update Count     : 3366
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    210210Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
    211211For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
    212 The TIOBE index~\cite{TIOBE} for July 2018 ranks the top five most \emph{popular} programming languages as \Index*{Java} 16\%, C 14\%, \Index*[C++]{\CC{}} 7.5\%, Python 6\%, Visual Basic 4\% = 47.5\%, where the next 50 languages are less than 4\% each, with a long tail.
     212The TIOBE index~\cite{TIOBE} for July 2018 ranks the top 5 most \emph{popular} programming languages as: \Index*{Java} 16\%, C 14\%, \Index*[C++]{\CC{}} 7.5\%, Python 6\%, Visual Basic 4\% = 47.5\%, where the next 50 languages are less than 4\% each, with a long tail.
    213213The top 3 rankings over the past 30 years are:
    214214\begin{center}
    … …  
    351351The 2011 C standard plus GNU extensions.
    352352\item
    353 \Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
     353\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]@-fgnu89-inline@}}
    354354Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files.
    355355\end{description}
    … …  
    455455#endif
    456456
    457 ®#include_next <bfdlink.h>                      §\C{// must have internal check for multiple expansion}§
     457®#include_next <bfdlink.h>                                      §\C{// must have internal check for multiple expansion}§
    458458®
    459459#if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
    … …  
    504504
    505505C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
    506 \CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@©?\?©} and ©?\=?©\index{?\\=?@©\=?©}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
     506\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline@?\?@} and ©?\=?©\index{?\\=?@\lstinline@?\=?@}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
    507507The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
    508508
    … …  
    516516256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
    517517\end{cfa}
    518 Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©.
     518Parenthesis are necessary for the complex constants or the expression is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
    519519The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
    520520For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
    … …  
    527527
    528528
    529 %\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}}
    530 \subsection{\texorpdfstring{\LstKeywordStyle{if}/\LstKeywordStyle{while} Statement}{if/while Statement}}
    531 
    532 The ©if©/©while© expression allows declarations, similar to ©for© declaration expression.
    533 (Does not make sense for ©do©-©while©.)
    534 \begin{cfa}
    535 if ( ®int x = f()® ) ...                                        §\C{// x != 0}§
    536 if ( ®int x = f(), y = g()® ) ...                       §\C{// x != 0 \&\& y != 0}§
    537 if ( ®int x = f(), y = g(); x < y® ) ...        §\C{// relational expression}§
    538 if ( ®struct S { int i; } x = { f() }; x.i < 4® ) §\C{// relational expression}§
    539 
    540 while ( ®int x = f()® ) ...                                     §\C{// x != 0}§
    541 while ( ®int x = f(), y = g()® ) ...            §\C{// x != 0 \&\& y != 0}§
    542 while ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§
    543 while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... §\C{// relational expression}§
    544 \end{cfa}
    545 Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator.\footnote{\CC only provides a single declaration always compared not equal to 0.}
     529%\subsection{\texorpdfstring{\protect\lstinline@if@ Statement}{if Statement}}
     530\subsection{\texorpdfstring{\LstKeywordStyle{if} Statement}{if Statement}}
     531
     532The ©if© expression allows declarations, similar to ©for© declaration expression:
     533\begin{cfa}
     534if ( int x = f() ) ...                                          §\C{// x != 0}§
     535if ( int x = f(), y = g() ) ...                         §\C{// x != 0 \&\& y != 0}§
     536if ( int x = f(), y = g(); ®x < y® ) ...        §\C{// relational expression}§
     537\end{cfa}
     538Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if© expression, and the results are combined using the logical ©&&© operator.\footnote{\CC only provides a single declaration always compared not equal to 0.}
    546539The scope of the declaration(s) is local to the @if@ statement but exist within both the ``then'' and ``else'' clauses.
    547 
    548 
    549 %\subsection{\texorpdfstring{\protect\lstinline@for@ Statement}{for Statement}}
    550 \subsection{\texorpdfstring{\LstKeywordStyle{for} Statement}{for Statement}}
    551 
    552 The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges.
    553 An empty conditional implies ©1©.
    554 The up-to range ©~©\index{~@©~©} means exclusive range [M,N);
    555 the up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
    556 The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M);
    557 the down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
    558 ©0© is the implicit start value;
    559 ©1© is the implicit increment value for an up-to range and ©-1© for an implicit down-to range.
    560 The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
    561 \begin{cquote}
    562 \begin{tabular}{@{}ll|l@{}}
    563 \multicolumn{2}{c|}{for control} & \multicolumn{1}{c}{output} \\
    564 \hline
    565 \begin{cfa}
    566 while ®()® { sout | "empty"; break; }
    567 do { sout | "empty"; break; } while ®()®;
    568 for ®()® { sout | "empty"; break; }
    569 for ( ®0® ) { sout | "A"; }
    570 for ( ®1® ) { sout | "A"; }
    571 for ( ®10® ) { sout | "A"; }
    572 for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
    573 for ( ®10 -~= 1 ~ -2® ) { sout | "C"; }
    574 for ( ®0.5 ~ 5.5® ) { sout | "D"; }
    575 for ( ®5.5 -~ 0.5® ) { sout | "E"; }
    576 for ( ®i; 10® ) { sout | i; }
    577 for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
    578 for ( ®i; 10 -~= 1 ~ -2® ) { sout | i; }
    579 for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
    580 for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
    581 for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
    582 for ( ®ui; 10u -~= 2u ~ -2u® ) { sout | ui; }
    583 int start = 3, comp = 10, inc = 2;
    584 for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
    585 \end{cfa}
    586 &
    587 \begin{cfa}
    588 sout | endl;
    589 sout | endl;
    590 sout | endl;
    591 sout | endl;
    592 sout | endl;
    593 sout | endl;
    594 sout | endl;
    595 sout | endl;
    596 sout | endl;
    597 sout | endl;
    598 sout | endl;
    599 sout | endl;
    600 sout | endl;
    601 sout | endl;
    602 sout | endl;
    603 sout | endl;
    604 sout | endl;
    605 
    606 sout | endl;
    607 \end{cfa}
    608 &
    609 \begin{cfa}
    610 empty
    611 empty
    612 empty
    613 
    614 A
    615 A A A A A A A A A A
    616 B B B B B
    617 C C C C C
    618 D D D D D
    619 E E E E E
    620 0 1 2 3 4 5 6 7 8 9
    621 1 3 5 7 9
    622 10 8 6 4 2
    623 0.5 1.5 2.5 3.5 4.5
    624 5.5 4.5 3.5 2.5 1.5
    625 2 4 6 8 10
    626 10 8 6 4 2
    627 
    628 3 6 9
    629 \end{cfa}
    630 \end{tabular}
    631 \end{cquote}
    632540
    633541
    … …  
    892800
    893801
    894 % for ()  => for ( ;; )
    895 % for ( 10 - t ) => for ( typeof(10 - t) ? = 0 ; ? < 10 - t; ? += 1 ) // using 0 and 1
    896 % for ( i ; 10 - t ) => for ( typeof(10 - t) i = 0 ; i < 10 - t; i += 1 ) // using 0 and 1
    897 % for ( T i ; 10 - t ) => for ( T i = 0 ; i < 10 - t; i += 1 ) // using 0 and 1
    898 % for ( 3~9 ) => for ( int ? = 3 ; ? < 9; ? += 1 ) // using 1
    899 % for ( i ; 3~9 ) => for ( int i = 3 ; i < 9; i += 1 ) // using 1
    900 % for ( T i ; 3~9 ) => for ( T i = 3 ; i < 9; i += 1 ) // using 1
    901 
    902 
    903802%\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
    904803\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
    … …  
    906805While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
    907806Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
    908 To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©break©!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
     807To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline@continue@!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline@break@!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
    909808For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
    910809for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
    … …  
    991890\end{figure}
    992891
    993 Both labelled ©continue© and ©break© are a ©goto©\index{goto@©goto©!restricted} restricted in the following ways:
     892Both labelled ©continue© and ©break© are a ©goto©\index{goto@\lstinline@goto@!restricted} restricted in the following ways:
    994893\begin{itemize}
    995894\item

  • driver/as.cc

    r6d44da1 r341bb80  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // as.c -- map assembler file, scan for debug information. If found, expand file by one character and insert Cforall
    8 //         language code on the N line from the start of the debug information.
     7// as.c --
    98//
    109// Author           : Peter A. Buhr
    1110// Created On       : Wed Aug  1 10:49:42 2018
    1211// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Sat Sep  8 08:40:16 2018
    14 // Update Count     : 97
     12// Last Modified On : Thu Aug  2 17:50:09 2018
     13// Update Count     : 90
    1514//
    1615
    … …  
    2423
    2524//#define __DEBUG_H__
    26 
    27 #ifdef __DEBUG_H__
    28 #include <iostream>
    29 using namespace std;
    30 #endif // __DEBUG_H__
    3125
    3226int main( const int argc, const char * argv[] ) {
    … …  
    4438        off_t size = mystat.st_size;
    4539
    46         if ( size ) {                                                                           // cannot map 0 sized file
    47                 char * start = (char *)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
    48                 if ( start == (void *)-1 ) { perror( "mmap" ); exit( EXIT_FAILURE ); };
     40        char * start = (char *)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
     41        if ( start == (void *)-1 ) { perror( "mmap" ); exit( EXIT_FAILURE ); };
    4942
    50                 if ( char * cursor = strstr( start, ".Ldebug_info0:" ) ) { // debug information ?
    51                         // Expand file by one byte to hold 2 character Cforall language code.
    52                         if ( ftruncate( fd, size + 1 ) ) { perror( "ftruncate" ); exit( EXIT_FAILURE ); };
     43        if ( char * cursor = strstr( start, ".Ldebug_info0:" ) ) { // debug information ?
     44                // Expand file by one byte to hold 2 character Cforall language code.
     45                if ( ftruncate( fd, size + 1 ) ) { perror( "ftruncate" ); exit( EXIT_FAILURE ); };
    5346
    54                         for ( int i = 0; i < 8; i += 1 ) {                      // move N (magic) lines forward
    55                                 cursor = strstr( cursor, "\n" ) + 1;
    56                         } // for
     47                for ( int i = 0; i < 8; i += 1 ) {                              // move N (magic) lines forward
     48                        cursor = strstr( cursor, "\n" ) + 1;
     49                } // for
    5750
    58                         cursor -= 2;                                                            // backup over "c\n" language value
    59                         if ( *(cursor - 1) != 'x' ) { fprintf( stderr, "invalid C language code\n" ); exit( EXIT_FAILURE ); };
     51                cursor -= 2;                                                                    // backup over "c\n" language value
     52                if ( *(cursor - 1) != 'x' ) { fprintf( stderr, "invalid C language code\n" ); exit( EXIT_FAILURE ); };
    6053
    61                         memmove( cursor + 2, cursor + 1, start + size - cursor - 1 ); // move remaining text 1 character right
     54                memmove( cursor + 2, cursor + 1, start + size - cursor - 1 ); // move remaining text 1 character right
    6255
    63                         *(cursor) = '2';                                                        // replace C language value with CFA
    64                         *(cursor + 1) = '5';
    65                 } // if
     56                *(cursor) = '2';                                                                // replace C language value with CFA
     57                *(cursor + 1) = '5';
     58        } // if
    6659
    67                 if ( munmap( start, size ) ) { perror( "munmap" ); exit( EXIT_FAILURE ); }; // update on disk
    68         } // if
     60        if ( munmap( start, size ) ) { perror( "munmap" ); exit( EXIT_FAILURE ); }; // update on disk
    6961
    7062        argv[0] = "as";

  • driver/cc1.cc

    r6d44da1 r341bb80  
    1010// Created On       : Fri Aug 26 14:23:51 2005
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep  3 16:57:05 2018
    13 // Update Count     : 125
     12// Last Modified On : Thu Jul 19 10:46:11 2018
     13// Update Count     : 111
    1414//
    1515
    … …  
    3232string compiler_name( CFA_BACKEND_CC );                                 // path/name of C compiler
    3333
     34string D__GCC_X__( "-D__GCC_X__=" );
    3435string D__GCC_BPREFIX__( "-D__GCC_BPREFIX__=" );
    3536string D__CFA_FLAGPREFIX__( "-D__CFA_FLAG__=" );
    … …  
    4647const string suffixes[NumSuffixes] = { "cfa", "hfa", };
    4748
    48 void suffix( string arg, const char * args[], int & nargs ) {
     49bool suffix( string arg ) {
    4950        //std::cerr << arg << std::endl;
    5051        size_t dot = arg.find_last_of( "." );
    5152        //std::cerr << dot << " " << (dot != string::npos ? arg.substr( dot + 1 ) : "fred" ) << std::endl;
    52         if ( dot == string::npos ) return;
     53        if ( dot == string::npos ) return false;
    5354        string sx = arg.substr( dot + 1 );
    5455        for ( int i = 0; i < NumSuffixes; i += 1 ) {
    55                 if ( sx == suffixes[i] ) {
    56                         args[nargs] = "-x";
    57                         nargs += 1;
    58                         args[nargs] = "c";
    59                         nargs += 1;
    60                         return;
    61                 } // if
    62         } // for
     56                if ( sx == suffixes[i] ) return true;
     57        } // for
     58        return false;
    6359} // suffix
    6460
    6561
    66 void checkEnv( const char * args[], int & nargs ) {
     62void checkEnv( const char *args[], int &nargs ) {
    6763        char *value;
    6864
    69         value = getenv( "__CFA_COMPILER__" );
     65        value = getenv( "__COMPILER__" );
    7066        if ( value != NULL ) {
    7167                compiler_name = value;
    … …  
    114110void Stage1( const int argc, const char * const argv[] ) {
    115111        int code;
     112        int i;
    116113
    117114        string arg;
    … …  
    136133        cerr << "Stage1" << endl;
    137134        #endif // __DEBUG_H__
     135
     136        // process all the arguments
     137
    138138        checkEnv( args, nargs );                                                        // arguments passed via environment variables
    139         #ifdef __DEBUG_H__
    140         for ( int i = 1; i < argc; i += 1 ) {
     139
     140        for ( i = 1; i < argc; i += 1 ) {
     141                #ifdef __DEBUG_H__
    141142                cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
    142         } // for
    143         #endif // __DEBUG_H__
    144 
    145         // process all the arguments
    146 
    147         for ( int i = 1; i < argc; i += 1 ) {
     143                #endif // __DEBUG_H__
    148144                arg = argv[i];
     145                #ifdef __DEBUG_H__
     146                cerr << "arg:\"" << arg << "\"" << endl;
     147                #endif // __DEBUG_H__
    149148                if ( prefix( arg, "-" ) ) {
    150149                        // strip g++ flags that are inappropriate or cause duplicates in subsequent passes
    … …  
    180179                                ncargs += 1;
    181180                                i += 1;                                                                 // and the argument
     181                        // } else if ( prefix( arg, D__GCC_X__ ) ) {
     182                        //      args[nargs] = "-x";
     183                        //      nargs += 1;
     184                        //      args[nargs] = ( *new string( arg.substr( D__GCC_X__.size() ) ) ).c_str(); // pass the flag along
     185                        //      nargs += 1;
     186                        // } else if ( arg == "-D" && prefix( argv[i + 1], D__GCC_X__.substr(2) ) ) {
     187                        //      args[nargs] = "-x";
     188                        //      nargs += 1;
     189                        //      args[nargs] = ( *new string( string( argv[i + 1] ).substr( D__GCC_X__.size() - 2 ) ) ).c_str(); // pass the flag along
     190                        //      nargs += 1;
     191                        //      i += 1;                                                                 // and the argument
    182192                        } else if ( prefix( arg, D__GCC_BPREFIX__ ) ) {
    183193                                bprefix = arg.substr( D__GCC_BPREFIX__.size() );
    … …  
    235245        #ifdef __DEBUG_H__
    236246        cerr << "args:";
    237         for ( int i = 1; i < nargs; i += 1 ) {
     247        for ( i = 1; i < nargs; i += 1 ) {
    238248                cerr << " " << args[i];
    239249        } // for
    … …  
    253263
    254264                args[0] = compiler_name.c_str();
    255                 suffix( cpp_in, args, nargs );                                  // check suffix
    256265                args[nargs] = cpp_in;
    257266                nargs += 1;
    … …  
    266275                #ifdef __DEBUG_H__
    267276                cerr << "nargs: " << nargs << endl;
    268                 for ( int i = 0; args[i] != NULL; i += 1 ) {
     277                for ( i = 0; args[i] != NULL; i += 1 ) {
    269278                        cerr << args[i] << " ";
    270279                } // for
    … …  
    301310
    302311                args[0] = compiler_name.c_str();
    303                 suffix( cpp_in, args, nargs );                                  // check suffix
     312                if ( suffix( cpp_in ) ) {
     313                        args[nargs] = "-x";
     314                        nargs += 1;
     315                        args[nargs] = "c";
     316                        nargs += 1;
     317                } // if
    304318                args[nargs] = cpp_in;                                                   // input to cpp
    305319                nargs += 1;
    … …  
    308322                #ifdef __DEBUG_H__
    309323                cerr << "cpp nargs: " << nargs << endl;
    310                 for ( int i = 0; args[i] != NULL; i += 1 ) {
     324                for ( i = 0; args[i] != NULL; i += 1 ) {
    311325                        cerr << args[i] << " ";
    312326                } // for
    … …  
    340354
    341355        if ( fork() == 0 ) {                                                            // child runs CFA
    342                 cargs[0] = ( *new string( bprefix + "cfa-cpp" ) ).c_str();
     356                cargs[0] = ( *new string( bprefix + "/cfa-cpp" ) ).c_str();
    343357
    344358                // Source file-name used to generate routine names containing global initializations for TU.
    … …  
    361375                #ifdef __DEBUG_H__
    362376                cerr << "cfa-cpp ncargs: " << o_name << " " << CFA_flag << " " << ncargs << endl;
    363                 for ( int i = 0; cargs[i] != NULL; i += 1 ) {
     377                for ( i = 0; cargs[i] != NULL; i += 1 ) {
    364378                        cerr << cargs[i] << " ";
    365379                } // for
    … …  
    391405
    392406void Stage2( const int argc, const char * const * argv ) {
     407        int i;
     408
    393409        string arg;
    394410
    … …  
    401417        cerr << "Stage2" << endl;
    402418        #endif // __DEBUG_H__
     419
     420        // process all the arguments
     421
    403422        checkEnv( args, nargs );                                                        // arguments passed via environment variables
    404         #ifdef __DEBUG_H__
    405         for ( int i = 1; i < argc; i += 1 ) {
     423
     424        for ( i = 1; i < argc; i += 1 ) {
     425                #ifdef __DEBUG_H__
    406426                cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
    407         } // for
    408         #endif // __DEBUG_H__
    409 
    410         // process all the arguments
    411 
    412         for ( int i = 1; i < argc; i += 1 ) {
     427                #endif // __DEBUG_H__
    413428                arg = argv[i];
     429                #ifdef __DEBUG_H__
     430                cerr << "arg:\"" << arg << "\"" << endl;
     431                #endif // __DEBUG_H__
    414432                if ( prefix( arg, "-" ) ) {
    415433                        // strip inappropriate flags
    … …  
    456474        #ifdef __DEBUG_H__
    457475        cerr << "args:";
    458         for ( int i = 1; i < nargs; i += 1 ) {
     476        for ( i = 1; i < nargs; i += 1 ) {
    459477                cerr << " " << args[i];
    460478        } // for
    … …  
    472490        #ifdef __DEBUG_H__
    473491        cerr << "stage2 nargs: " << nargs << endl;
    474         for ( int i = 0; args[i] != NULL; i += 1 ) {
     492        for ( i = 0; args[i] != NULL; i += 1 ) {
    475493                cerr << args[i] << " ";
    476494        } // for
    … …  
    486504int main( const int argc, const char * const argv[], __attribute__((unused)) const char * const env[] ) {
    487505        #ifdef __DEBUG_H__
    488         for ( int int i = 0; env[i] != NULL; i += 1 ) {
     506        for ( int i = 0; env[i] != NULL; i += 1 ) {
    489507                cerr << env[i] << endl;
    490508        } // for

  • driver/cfa.cc

    r6d44da1 r341bb80  
    1010// Created On       : Tue Aug 20 13:44:49 2002
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep  3 16:47:59 2018
    13 // Update Count     : 275
     12// Last Modified On : Fri Aug 10 18:17:58 2018
     13// Update Count     : 259
    1414//
    1515
    … …  
    4343const string suffixes[NumSuffixes] = { "cfa", "hfa", };
    4444
    45 bool suffix( string arg, const char * args[], int & nargs ) {
     45bool suffix( string arg ) {
    4646        //std::cerr << arg << std::endl;
    4747        size_t dot = arg.find_last_of( "." );
    … …  
    5050        string sx = arg.substr( dot + 1 );
    5151        for ( int i = 0; i < NumSuffixes; i += 1 ) {
    52                 if ( sx == suffixes[i] ) {
    53                         args[nargs] = "-x";
    54                         nargs += 1;
    55                         args[nargs] = "c";
    56                         nargs += 1;
    57                         return true;
    58                 } // if
     52                if ( sx == suffixes[i] ) return true;
    5953        } // for
    6054        return false;
    … …  
    9286        string Major( str( CFA_VERSION_MAJOR ) ), Minor( str( CFA_VERSION_MINOR ) ), Patch( str( CFA_VERSION_PATCH ) );
    9387
    94         string installincdir( CFA_INCDIR );                                     // fixed location of include files
    95         string installlibdir( CFA_LIBDIR );                                     // fixed location of cc1 and cfa-cpp commands when installed
    96         string srcdriverdir ( TOP_BUILDDIR "driver");           // fixed location of cc1 and cfa-cpp commands when in tree
     88        string installincdir( CFA_INCDIR );                         // fixed location of include files
     89        string installlibdir( CFA_LIBDIR );                         // fixed location of cc1 and cfa-cpp commands when installed
     90        string srcdriverdir ( TOP_BUILDDIR "driver");                // fixed location of cc1 and cfa-cpp commands when in tree
    9791
    9892        string heading;                                                                         // banner printed at start of cfa compilation
    … …  
    129123        #ifdef __DEBUG_H__
    130124        cerr << "CFA:" << endl;
     125        #endif // __DEBUG_H__
     126
     127        // process command-line arguments
     128
    131129        for ( int i = 1; i < argc; i += 1 ) {
    132             cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
    133         } // for
    134         #endif // __DEBUG_H__
    135 
    136         // process command-line arguments
    137 
    138         for ( int i = 1; i < argc; i += 1 ) {
     130                #ifdef __DEBUG_H__
     131                cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl;
     132                #endif // __DEBUG_H__
    139133                arg = argv[i];                                                                  // convert to string value
     134                #ifdef __DEBUG_H__
     135                cerr << "arg:\"" << arg << "\"" << endl;
     136                #endif // __DEBUG_H__
    140137                if ( prefix( arg, "-" ) ) {
    141138                        // pass through arguments
    … …  
    181178                                if ( i == argc ) continue;                              // next argument available ?
    182179                                compiler_path = argv[i];
    183                                 if ( putenv( (char *)( *new string( string( "__CFA_COMPILER__=" ) + argv[i]) ).c_str() ) != 0 ) {
     180                                if ( putenv( (char *)( *new string( string( "__U_COMPILER__=" ) + argv[i]) ).c_str() ) != 0 ) {
    184181                                        cerr << argv[0] << " error, cannot set environment variable." << endl;
    185182                                        exit( EXIT_FAILURE );
    … …  
    200197                                args[nargs] = argv[i];                                  // pass the argument along
    201198                                nargs += 1;
     199                        } else if ( arg == "-x" ) {
     200                                xflag = true;
     201                                args[nargs] = argv[i];                                  // pass the argument along
     202                                nargs += 1;
     203                                i += 1;                                                                 // advance to argument
     204                                args[nargs] = argv[i];                                  // pass the argument along
     205                                nargs += 1;
     206                                // args[nargs] = ( *new string( string("-D__GCC_X__=") + argv[i] ) ).c_str(); // add the argument for -x
     207                                // nargs += 1;
     208                        } else if ( prefix( arg, "-x" ) ) {
     209                                xflag = true;
     210                                args[nargs] = argv[i];                                  // pass the argument along
     211                                nargs += 1;
     212                                // args[nargs] = ( *new string( string("-D__GCC_X__=") + arg.substr(2) ) ).c_str(); // add the argument for -x
     213                                // nargs += 1;
    202214                        } else if ( arg == "-w" ) {
    203215                                args[nargs] = argv[i];                                  // pass the argument along
    … …  
    281293                        } // if
    282294                } else {
    283                         bool cfa = suffix( arg, args, nargs );          // check suffix
    284                         args[nargs] = argv[i];                                          // concatenate file
     295                        bool opt = false;
     296                        if ( ! xflag && suffix( arg ) ) {
     297                                args[nargs] = "-x";
     298                                nargs += 1;
     299                                args[nargs] = "c";
     300                                nargs += 1;
     301                                // args[nargs] = ( *new string( string("-D__GCC_X__=c") ) ).c_str(); // add the argument for -x
     302                                // nargs += 1;
     303                                opt = true;
     304                        } // if
     305                        // concatenate other arguments
     306                        args[nargs] = argv[i];
    285307                        nargs += 1;
    286                         if ( cfa ) {
     308                        if ( opt ) {
    287309                                args[nargs] = "-x";
    288310                                nargs += 1;
    289311                                args[nargs] = "none";
    290312                                nargs += 1;
     313                                // args[nargs] = ( *new string( string("-D__GCC_X__=none") ) ).c_str(); // add the argument for -x
     314                                // nargs += 1;
    291315                        } // if
    292316                        nonoptarg = true;
    … …  
    294318                } // if
    295319        } // for
    296 
    297     args[nargs] = "-x";                                 // turn off language
    298     nargs += 1;
    299     args[nargs] = "none";
    300     nargs += 1;
    301320
    302321        #ifdef __x86_64__
    … …  
    322341                args[nargs] = "-I" CFA_INCDIR;
    323342                nargs += 1;
    324                 if ( ! noincstd_flag ) {                                                // do not use during build
    325                         args[nargs] = "-I" CFA_INCDIR "stdhdr";
     343                if ( ! noincstd_flag ) {                                                        // do not use during build
     344                        args[nargs] = "-I" CFA_INCDIR "/stdhdr";
    326345                        nargs += 1;
    327346                } // if
    328                 args[nargs] = "-I" CFA_INCDIR "concurrency";
    329                 nargs += 1;
    330                 args[nargs] = "-I" CFA_INCDIR "containers";
     347                args[nargs] = "-I" CFA_INCDIR "/concurrency";
     348                nargs += 1;
     349                args[nargs] = "-I" CFA_INCDIR "/containers";
    331350                nargs += 1;
    332351        } else {
    333352                args[nargs] = "-I" TOP_SRCDIR "libcfa/src";
    334353                nargs += 1;
    335                 if ( ! noincstd_flag ) {                                                // do not use during build
     354                if ( ! noincstd_flag ) {                                                        // do not use during build
    336355                        args[nargs] = "-I" TOP_SRCDIR "libcfa/src" "/stdhdr";
    337356                        nargs += 1;
    … …  
    358377        }
    359378
    360         string arch = m32 ? CFA_32_CPU : (m64 ? CFA_64_CPU : CFA_DEFAULT_CPU);
    361         if ( ! m32 && ! m64 ) {
    362                 if ( arch == "x86" ) {
    363                         args[nargs] = "-m32";
    364                         nargs += 1;
    365                 } else if ( arch == "x64" ) {
    366                         args[nargs] = "-m64";
    367                         nargs += 1;
    368                 }  // if
    369         } // if
     379        const char * const arch = m32 ? CFA_32_CPU : (m64 ? CFA_64_CPU : CFA_DEFAULT_CPU);
    370380        const char * config = debug ? "debug": "nodebug";
    371381        string libdir = libbase + arch + "-" + config;
    372 
    373         if ( ! dirExists( libdir ) ) {
     382        if( !dirExists(libdir) ) {
    374383                cerr << argv[0] << " internal error, configuration " << config << " not installed." << endl;
    375384                cerr << "Was looking for " << libdir << endl;
    376385                libdir = libbase + arch + "-" + "nolib";
    377         } // if
    378 
    379         if ( ! dirExists( libdir ) ) {
     386        }
     387
     388        if( !dirExists(libdir) ) {
    380389                cerr << argv[0] << " internal error, cannot find prelude directory." << endl;
    381390                cerr << "Was looking for " << libdir << endl;
    382391                exit( EXIT_FAILURE );
    383         } // if
     392        }
    384393
    385394        args[nargs] = ( *new string( string("-D__CFA_FLAG__=--prelude-dir=" ) + libdir + (intree ? "/prelude" : "")) ).c_str();
    … …  
    463472
    464473        if ( Bprefix.length() == 0 ) {
    465                 Bprefix = ! intree ? installlibdir : srcdriverdir;
    466                 if ( Bprefix[Bprefix.length() - 1] != '/' ) Bprefix += '/';
     474                Bprefix = !intree ? installlibdir : srcdriverdir;
    467475                args[nargs] = ( *new string( string("-D__GCC_BPREFIX__=") + Bprefix ) ).c_str();
    468476                nargs += 1;
    … …  
    498506                args[nargs] = "-D__int8_t_defined";                             // prevent gcc type-size attributes
    499507                nargs += 1;
    500                 args[nargs] = ( *new string( string("-B") + Bprefix ) ).c_str();
     508                args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();
    501509                nargs += 1;
    502510                args[nargs] = "-lm";

  • libcfa/Makefile.in

    r6d44da1 r341bb80  
    238238CFLAGS = @CFLAGS@
    239239CONFIGURATION = @CONFIGURATION@
    240 CONFIG_BUILDLIB = @CONFIG_BUILDLIB@
    241240CONFIG_CFAFLAGS = @CONFIG_CFAFLAGS@
    242241CONFIG_CFLAGS = @CONFIG_CFLAGS@

  • libcfa/configure

    r6d44da1 r341bb80  
    701701CFA_PREFIX
    702702CFA_NAME
    703 BUILDLIB_FALSE
    704 BUILDLIB_TRUE
    705 CONFIG_BUILDLIB
    706703CONFIG_CFAFLAGS
    707704CONFIG_CFLAGS
    … …  
    23792376
    23802377
    2381 
    23822378am__api_version='1.15'
    23832379
    … …  
    29512947                CONFIG_CFLAGS="-O0 -g"
    29522948                CONFIG_CFAFLAGS="-debug"
    2953                 CONFIG_BUILDLIB="yes"
    29542949        ;;
    29552950        "nodebug" )
    29562951                CONFIG_CFLAGS="-O2 -s"
    29572952                CONFIG_CFAFLAGS="-nodebug"
    2958                 CONFIG_BUILDLIB="yes"
    29592953        ;;
    29602954        "nolib"   )
    2961                 CONFIG_CFLAGS="-O2 -s"
    2962                 CONFIG_CFAFLAGS="-nodebug"
    2963                 CONFIG_BUILDLIB="no"
     2955                CONFIG_CFLAGS=""
     2956                CONFIG_CFAFLAGS=""
    29642957        ;;
    29652958esac
    29662959
    29672960
    2968 
    2969 
    2970 
    2971  if test "x${CONFIG_BUILDLIB}" = "xyes"; then
    2972   BUILDLIB_TRUE=
    2973   BUILDLIB_FALSE='#'
    2974 else
    2975   BUILDLIB_TRUE='#'
    2976   BUILDLIB_FALSE=
    2977 fi
    29782961
    29792962
    … …  
    1696116944fi
    1696216945
    16963 if test -z "${BUILDLIB_TRUE}" && test -z "${BUILDLIB_FALSE}"; then
    16964   as_fn_error $? "conditional \"BUILDLIB\" was never defined.
    16965 Usually this means the macro was only invoked conditionally." "$LINENO" 5
    16966 fi
    1696716946if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
    1696816947  as_fn_error $? "conditional \"AMDEP\" was never defined.

  • libcfa/configure.ac

    r6d44da1 r341bb80  
    4242                CONFIG_CFLAGS="-O0 -g"
    4343                CONFIG_CFAFLAGS="-debug"
    44                 CONFIG_BUILDLIB="yes"
    4544        ;;
    4645        "nodebug" )
    4746                CONFIG_CFLAGS="-O2 -s"
    4847                CONFIG_CFAFLAGS="-nodebug"
    49                 CONFIG_BUILDLIB="yes"
    5048        ;;
    5149        "nolib"   )
    52                 CONFIG_CFLAGS="-O2 -s"
    53                 CONFIG_CFAFLAGS="-nodebug"
    54                 CONFIG_BUILDLIB="no"
     50                CONFIG_CFLAGS=""
     51                CONFIG_CFAFLAGS=""
    5552        ;;
    5653esac
    … …  
    5855AC_SUBST(CONFIG_CFLAGS)
    5956AC_SUBST(CONFIG_CFAFLAGS)
    60 AC_SUBST(CONFIG_BUILDLIB)
    61 
    62 AM_CONDITIONAL([BUILDLIB], [test "x${CONFIG_BUILDLIB}" = "xyes"])
    6357
    6458#==============================================================================

  • libcfa/prelude/Makefile.am

    r6d44da1 r341bb80  
    2121# put into lib for now
    2222cfalibdir = ${CFA_LIBDIR}
    23 cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c
     23cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
     24noinst_DATA = ../src/prelude.c
    2425
    2526CC = @CFACC@
    … …  
    4445        ${AM_V_GEN}gcc -I${srcdir} -E ${srcdir}/prototypes.c | awk -f ${srcdir}/prototypes.awk > $@
    4546
    46 prelude.cfa : prelude-gen.cc
     47prelude.cf : prelude-gen.cc
    4748        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${AM_CFLAGS} ${<} -o prelude-gen -Wall -Wextra -O2 -g -std=c++14
    4849        @./prelude-gen > $@
    … …  
    6061include $(DEPDIR)/builtins.Po
    6162
    62 bootloader.c : ${srcdir}/bootloader.cf prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACPP@
     63../src/prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
     64        ${AM_V_GEN}@CFACPP@ --prelude-dir=${builddir} -l prelude.cf $@  # use src/cfa-cpp as not in lib until after install
     65
     66bootloader.c : ${srcdir}/bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
    6367        ${AM_V_GEN}@CFACPP@ --prelude-dir=${builddir} -tpm ${srcdir}/bootloader.cf $@  # use src/cfa-cpp as not in lib until after install
    6468
    … …  
    6670        rm -rf $(DEPDIR)
    6771
    68 MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cfa
     72MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cf
    6973MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}

  • libcfa/prelude/Makefile.in

    r6d44da1 r341bb80  
    153153  }
    154154am__installdirs = "$(DESTDIR)$(cfalibdir)"
    155 DATA = $(cfalib_DATA)
     155DATA = $(cfalib_DATA) $(noinst_DATA)
    156156am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
    157157am__DIST_COMMON = $(srcdir)/Makefile.in
    … …  
    181181CFLAGS = @CFLAGS@
    182182CONFIGURATION = @CONFIGURATION@
    183 CONFIG_BUILDLIB = @CONFIG_BUILDLIB@
    184183CONFIG_CFAFLAGS = @CONFIG_CFAFLAGS@
    185184CONFIG_CFLAGS = @CONFIG_CFLAGS@
    … …  
    302301# put into lib for now
    303302cfalibdir = ${CFA_LIBDIR}
    304 <<<<<<< HEAD
    305303cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
    306304noinst_DATA = ../src/prelude.c
    307305AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    308 =======
    309 cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c
    310 AM_CFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
    311 >>>>>>> master
    312306AM_CFAFLAGS = @CONFIG_CFAFLAGS@
    313 MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cfa
     307MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cf
    314308MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
    315309all: all-am
    … …  
    550544        ${AM_V_GEN}gcc -I${srcdir} -E ${srcdir}/prototypes.c | awk -f ${srcdir}/prototypes.awk > $@
    551545
    552 prelude.cfa : prelude-gen.cc
     546prelude.cf : prelude-gen.cc
    553547        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${AM_CFLAGS} ${<} -o prelude-gen -Wall -Wextra -O2 -g -std=c++14
    554548        @./prelude-gen > $@
    … …  
    566560include $(DEPDIR)/builtins.Po
    567561
    568 bootloader.c : ${srcdir}/bootloader.cf prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACPP@
     562../src/prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
     563        ${AM_V_GEN}@CFACPP@ --prelude-dir=${builddir} -l prelude.cf $@  # use src/cfa-cpp as not in lib until after install
     564
     565bootloader.c : ${srcdir}/bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
    569566        ${AM_V_GEN}@CFACPP@ --prelude-dir=${builddir} -tpm ${srcdir}/bootloader.cf $@  # use src/cfa-cpp as not in lib until after install
    570567

  • libcfa/prelude/prelude-gen.cc

    r6d44da1 r341bb80  
    142142
    143143int main() {
    144         cout << "# 2 \"prelude.cfa\"  // needed for error messages from this file" << endl;
     144        cout << "# 2 \"prelude.cf\"  // needed for error messages from this file" << endl;
    145145        cout << "trait sized(dtype T) {};" << endl;
    146146

  • libcfa/src/Makefile.am

    r6d44da1 r341bb80  
    2525lib_LTLIBRARIES =  libcfa.la
    2626
    27 VPATH += :../prelude
    28 
    2927# AM_CFLAGS for all cfa source
    3028# AM_CFAFLAGS for only cfa source
    3129# use -no-include-stdhdr to prevent rebuild cycles
    3230# The built sources must not depend on the installed headers
    33 AM_CFAFLAGS = -quiet -in-tree -I$(srcdir)/stdhdr @CONFIG_CFAFLAGS@
     31AM_CFAFLAGS = -quiet -in-tree -imacros prelude.c -I$(srcdir)/stdhdr @CONFIG_CFAFLAGS@
    3432AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    3533AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
    … …  
    3735
    3836#----------------------------------------------------------------------------------------------------------------
    39 if BUILDLIB
    4037headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
    4138          containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
    42 
    43 headers_nosrc = math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
    4439
    4540# not all platforms support concurrency, add option do disable it
    4641headers += concurrency/coroutine.hfa concurrency/thread.hfa concurrency/kernel.hfa concurrency/monitor.hfa concurrency/mutex.hfa
    4742
    48 headers_nosrc += concurrency/invoke.h
    49 
    5043libobjs = ${headers:.hfa=.lo}
    51 libsrc = startup.cfa interpose.cfa bits/debug.cfa assert.cfa exception.c virtual.c heap.cfa ${headers:.hfa=.cfa}
     44libsrc = prelude.c startup.cfa interpose.cfa bits/debug.cfa assert.cfa exception.c virtual.c heap.cfa \
     45        ${headers:.hfa=.cfa}
    5246
    5347# not all platforms support concurrency, add option do disable it
    5448libsrc += concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/preemption.cfa
    55 else
    56 headers =
    57 headers_nosrc =
    58 libsrc =
    59 endif
    60 
    6149
    6250#----------------------------------------------------------------------------------------------------------------
    6351# add dependency to cfa-cpp so all libraries are rebuilt with new translator
    64 #@CFACC@ @CFACPP@ prelude.cfa
     52${libobjs} : ${cfalib_DATA}
    6553
    66 # add dependency of cfa files
    67 libobjs = $(addsuffix .lo, $(basename $(filter %.cfa,$(libsrc))))
    68 $(libobjs) : @CFACC@ @CFACPP@ prelude.cfa
    69 
    70 
    71 # .deps inclusion is not done automatically by automake for new languages
    72 libdeps = $(join \
    73         $(addsuffix $(DEPDIR)/ , $(dir $(libobjs) ) ), \
    74         $(notdir ${libobjs:.lo=.Po}) \
    75 )
    76 
    77 -include $(libdeps)
    78 
    79 prelude.lo : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
    80         ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree -XCFA -l ${<} -c -o ${@}
    81 
    82 
    83 
    84 #----------------------------------------------------------------------------------------------------------------
    85 libcfa_la_SOURCES = prelude.cfa ${libsrc}
     54libcfa_la_SOURCES = ${libsrc}
    8655
    8756stdhdr = $(shell find $(srcdir)/stdhdr -type f -printf "%p ")
    8857
    8958cfa_includedir = $(CFA_INCDIR)
    90 nobase_cfa_include_HEADERS = ${stdhdr} ${headers} ${headers_nosrc}
     59nobase_cfa_include_HEADERS = \
     60        ${headers}             \
     61        ${stdhdr}              \
     62        math.hfa               \
     63        gmp.hfa                \
     64        time_t.hfa             \
     65        bits/align.hfa         \
     66        bits/containers.hfa    \
     67        bits/defs.hfa          \
     68        bits/debug.hfa         \
     69        bits/locks.hfa         \
     70        concurrency/invoke.h
     71
     72MOSTLYCLEANFILES = prelude.c
    9173
    9274#----------------------------------------------------------------------------------------------------------------
    9375maintainer-clean-local:
    9476        -rm -rf ${CFA_INCDIR} ${CFA_LIBDIR}
    95 
    96 
    97 # $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
    98 #       $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
    99 #       $(am__mv) $$depbase.Tpo $$depbase.Po

  • libcfa/src/Makefile.in

    r6d44da1 r341bb80  
    1919
    2020
     21VPATH = @srcdir@
    2122am__is_gnu_make = { \
    2223  if test -z '$(MAKELEVEL)'; then \
    … …  
    102103am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
    103104        $(ACLOCAL_M4)
    104 DIST_COMMON = $(srcdir)/Makefile.am \
    105         $(am__nobase_cfa_include_HEADERS_DIST) $(am__DIST_COMMON)
     105DIST_COMMON = $(srcdir)/Makefile.am $(nobase_cfa_include_HEADERS) \
     106        $(am__DIST_COMMON)
    106107mkinstalldirs = $(install_sh) -d
    107108CONFIG_CLEAN_FILES =
    … …  
    135136  }
    136137am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(cfa_includedir)"
    137 <<<<<<< HEAD
    138138LTLIBRARIES = $(lib_LTLIBRARIES)
    139139libcfa_la_LIBADD =
    … …  
    155155am__v_lt_0 = --silent
    156156am__v_lt_1 =
    157 =======
    158 LIBRARIES = $(lib_LIBRARIES)
    159 AR = ar
    160 AM_V_AR = $(am__v_AR_@AM_V@)
    161 am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
    162 am__v_AR_0 = @echo "  AR      " $@;
    163 am__v_AR_1 =
    164 libcfa_a_AR = $(AR) $(ARFLAGS)
    165 libcfa_a_LIBADD =
    166 am__libcfa_a_SOURCES_DIST = prelude.cfa startup.cfa interpose.cfa \
    167         bits/debug.cfa assert.cfa exception.c virtual.c heap.cfa \
    168         fstream.cfa iostream.cfa iterator.cfa limits.cfa rational.cfa \
    169         time.cfa stdlib.cfa common.cfa containers/maybe.cfa \
    170         containers/pair.cfa containers/result.cfa \
    171         containers/vector.cfa concurrency/coroutine.cfa \
    172         concurrency/thread.cfa concurrency/kernel.cfa \
    173         concurrency/monitor.cfa concurrency/mutex.cfa \
    174         concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa \
    175         concurrency/invoke.c concurrency/preemption.cfa
    176 am__dirstamp = $(am__leading_dot)dirstamp
    177 @BUILDLIB_TRUE@am__objects_1 = fstream.$(OBJEXT) iostream.$(OBJEXT) \
    178 @BUILDLIB_TRUE@ iterator.$(OBJEXT) limits.$(OBJEXT) \
    179 @BUILDLIB_TRUE@ rational.$(OBJEXT) time.$(OBJEXT) \
    180 @BUILDLIB_TRUE@ stdlib.$(OBJEXT) common.$(OBJEXT) \
    181 @BUILDLIB_TRUE@ containers/maybe.$(OBJEXT) \
    182 @BUILDLIB_TRUE@ containers/pair.$(OBJEXT) \
    183 @BUILDLIB_TRUE@ containers/result.$(OBJEXT) \
    184 @BUILDLIB_TRUE@ containers/vector.$(OBJEXT) \
    185 @BUILDLIB_TRUE@ concurrency/coroutine.$(OBJEXT) \
    186 @BUILDLIB_TRUE@ concurrency/thread.$(OBJEXT) \
    187 @BUILDLIB_TRUE@ concurrency/kernel.$(OBJEXT) \
    188 @BUILDLIB_TRUE@ concurrency/monitor.$(OBJEXT) \
    189 @BUILDLIB_TRUE@ concurrency/mutex.$(OBJEXT)
    190 @BUILDLIB_TRUE@am__objects_2 = startup.$(OBJEXT) interpose.$(OBJEXT) \
    191 @BUILDLIB_TRUE@ bits/debug.$(OBJEXT) assert.$(OBJEXT) \
    192 @BUILDLIB_TRUE@ exception.$(OBJEXT) virtual.$(OBJEXT) \
    193 @BUILDLIB_TRUE@ heap.$(OBJEXT) $(am__objects_1) \
    194 @BUILDLIB_TRUE@ concurrency/CtxSwitch-@ARCHITECTURE@.$(OBJEXT) \
    195 @BUILDLIB_TRUE@ concurrency/alarm.$(OBJEXT) \
    196 @BUILDLIB_TRUE@ concurrency/invoke.$(OBJEXT) \
    197 @BUILDLIB_TRUE@ concurrency/preemption.$(OBJEXT)
    198 am_libcfa_a_OBJECTS = prelude.$(OBJEXT) $(am__objects_2)
    199 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
    200 >>>>>>> master
    201157AM_V_P = $(am__v_P_@AM_V@)
    202158am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
    … …  
    243199am__v_CCLD_0 = @echo "  CCLD    " $@;
    244200am__v_CCLD_1 =
    245 <<<<<<< HEAD
    246201SOURCES = $(libcfa_la_SOURCES)
    247202DIST_SOURCES = $(libcfa_la_SOURCES)
    248 =======
    249 SOURCES = $(libcfa_a_SOURCES)
    250 DIST_SOURCES = $(am__libcfa_a_SOURCES_DIST)
    251 >>>>>>> master
    252203am__can_run_installinfo = \
    253204  case $$AM_UPDATE_INFO_DIR in \
    … …  
    255206    *) (install-info --version) >/dev/null 2>&1;; \
    256207  esac
    257 am__nobase_cfa_include_HEADERS_DIST = ${shell find ${srcdir}/stdhdr \
    258         -type f -printf "%p "} fstream.hfa iostream.hfa iterator.hfa \
    259         limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
    260         containers/maybe.hfa containers/pair.hfa containers/result.hfa \
    261         containers/vector.hfa concurrency/coroutine.hfa \
    262         concurrency/thread.hfa concurrency/kernel.hfa \
    263         concurrency/monitor.hfa concurrency/mutex.hfa math.hfa gmp.hfa \
    264         time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa \
    265         bits/debug.hfa bits/locks.hfa concurrency/invoke.h
    266208HEADERS = $(nobase_cfa_include_HEADERS)
    267209am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
    … …  
    287229        $(top_srcdir)/automake/depcomp
    288230DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    289 VPATH = @srcdir@ :../prelude
    290231ACLOCAL = @ACLOCAL@
    291232AMTAR = @AMTAR@
    … …  
    312253CFLAGS = @CFLAGS@
    313254CONFIGURATION = @CONFIGURATION@
    314 CONFIG_BUILDLIB = @CONFIG_BUILDLIB@
    315255CONFIG_CFAFLAGS = @CONFIG_CFAFLAGS@
    316256CONFIG_CFLAGS = @CONFIG_CFLAGS@
    … …  
    429369# create object files in directory with source files
    430370AUTOMAKE_OPTIONS = foreign subdir-objects
    431 <<<<<<< HEAD
    432371ACLOCAL_AMFLAGS = -I automake
    433 =======
    434 >>>>>>> master
    435372ARFLAGS = cr
    436373CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
    … …  
    450387# use -no-include-stdhdr to prevent rebuild cycles
    451388# The built sources must not depend on the installed headers
    452 <<<<<<< HEAD
    453389AM_CFAFLAGS = -quiet -in-tree -imacros prelude.c -I$(srcdir)/stdhdr @CONFIG_CFAFLAGS@
    454390AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@
    455 =======
    456 AM_CFAFLAGS = -quiet -in-tree -I$(srcdir)/stdhdr @CONFIG_CFAFLAGS@
    457 AM_CFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
    458 >>>>>>> master
    459391AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@
    460 @BUILDLIB_FALSE@headers =
    461392
    462393#----------------------------------------------------------------------------------------------------------------
    463394
    464395# not all platforms support concurrency, add option do disable it
    465 <<<<<<< HEAD
    466396headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa \
    467397        rational.hfa time.hfa stdlib.hfa common.hfa \
    … …  
    479409libcfa_la_SOURCES = ${libsrc}
    480410stdhdr = $(shell find $(srcdir)/stdhdr -type f -printf "%p ")
    481 =======
    482 @BUILDLIB_TRUE@headers = fstream.hfa iostream.hfa iterator.hfa \
    483 @BUILDLIB_TRUE@ limits.hfa rational.hfa time.hfa stdlib.hfa \
    484 @BUILDLIB_TRUE@ common.hfa containers/maybe.hfa \
    485 @BUILDLIB_TRUE@ containers/pair.hfa containers/result.hfa \
    486 @BUILDLIB_TRUE@ containers/vector.hfa concurrency/coroutine.hfa \
    487 @BUILDLIB_TRUE@ concurrency/thread.hfa concurrency/kernel.hfa \
    488 @BUILDLIB_TRUE@ concurrency/monitor.hfa concurrency/mutex.hfa
    489 @BUILDLIB_FALSE@headers_nosrc =
    490 @BUILDLIB_TRUE@headers_nosrc = math.hfa gmp.hfa time_t.hfa \
    491 @BUILDLIB_TRUE@ bits/align.hfa bits/containers.hfa \
    492 @BUILDLIB_TRUE@ bits/defs.hfa bits/debug.hfa bits/locks.hfa \
    493 @BUILDLIB_TRUE@ concurrency/invoke.h
    494 @BUILDLIB_FALSE@libsrc =
    495 
    496 # not all platforms support concurrency, add option do disable it
    497 @BUILDLIB_TRUE@libsrc = startup.cfa interpose.cfa bits/debug.cfa \
    498 @BUILDLIB_TRUE@ assert.cfa exception.c virtual.c heap.cfa \
    499 @BUILDLIB_TRUE@ ${headers:.hfa=.cfa} \
    500 @BUILDLIB_TRUE@ concurrency/CtxSwitch-@ARCHITECTURE@.S \
    501 @BUILDLIB_TRUE@ concurrency/alarm.cfa concurrency/invoke.c \
    502 @BUILDLIB_TRUE@ concurrency/preemption.cfa
    503 
    504 #----------------------------------------------------------------------------------------------------------------
    505 # add dependency to cfa-cpp so all libraries are rebuilt with new translator
    506 #@CFACC@ @CFACPP@ prelude.cfa
    507 
    508 # add dependency of cfa files
    509 libobjs = $(addsuffix .o, $(basename $(filter %.cfa,$(libsrc))))
    510 
    511 # .deps inclusion is not done automatically by automake for new languages
    512 libdeps = $(join \
    513         $(addsuffix $(DEPDIR)/ , $(dir $(libobjs) ) ), \
    514         $(notdir ${libobjs:.o=.Po}) \
    515 )
    516 
    517 
    518 #----------------------------------------------------------------------------------------------------------------
    519 libcfa_a_SOURCES = prelude.cfa ${libsrc}
    520 stdhdr = ${shell find ${srcdir}/stdhdr -type f -printf "%p "}
    521 >>>>>>> master
    522411cfa_includedir = $(CFA_INCDIR)
    523 nobase_cfa_include_HEADERS = ${stdhdr} ${headers} ${headers_nosrc}
     412nobase_cfa_include_HEADERS = \
     413        ${headers}             \
     414        ${stdhdr}              \
     415        math.hfa               \
     416        gmp.hfa                \
     417        time_t.hfa             \
     418        bits/align.hfa         \
     419        bits/containers.hfa    \
     420        bits/defs.hfa          \
     421        bits/debug.hfa         \
     422        bits/locks.hfa         \
     423        concurrency/invoke.h
     424
     425MOSTLYCLEANFILES = prelude.c
    524426all: all-am
    525427
    … …  
    652554        -rm -f *.tab.c
    653555
    654 <<<<<<< HEAD
    655556@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/exception.Plo@am__quote@
    656557@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prelude.Plo@am__quote@
    … …  
    658559@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@ARCHITECTURE@.Plo@am__quote@
    659560@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/invoke.Plo@am__quote@
    660 =======
    661 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/exception.Po@am__quote@
    662 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/virtual.Po@am__quote@
    663 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@ARCHITECTURE@.Po@am__quote@
    664 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/invoke.Po@am__quote@
    665 >>>>>>> master
    666561
    667562.S.o:
    … …  
    855750        fi
    856751mostlyclean-generic:
     752        -test -z "$(MOSTLYCLEANFILES)" || rm -f $(MOSTLYCLEANFILES)
    857753
    858754clean-generic:
    … …  
    965861
    966862
    967 .cfa.o:
     863.cfa.o: $(CFACC) $(CFACPP)
    968864        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
    969865        $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
    970866        $(am__mv) $$depbase.Tpo $$depbase.Po
    971 $(libobjs) : @CFACC@ @CFACPP@ prelude.cfa
    972 
    973 <<<<<<< HEAD
     867
    974868.cfa.lo:
    975869        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
    … …  
    980874# add dependency to cfa-cpp so all libraries are rebuilt with new translator
    981875${libobjs} : ${cfalib_DATA}
    982 =======
    983 -include $(libdeps)
    984 
    985 prelude.o : prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACC@ @CFACPP@
    986         ${AM_V_GEN}@CFACC@ ${AM_CFLAGS} ${CFLAGS} -quiet -in-tree -XCFA -l ${<} -c -o ${@}
    987 >>>>>>> master
    988876
    989877#----------------------------------------------------------------------------------------------------------------
    … …  
    991879        -rm -rf ${CFA_INCDIR} ${CFA_LIBDIR}
    992880
    993 # $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
    994 #       $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
    995 #       $(am__mv) $$depbase.Tpo $$depbase.Po
    996 
    997881# Tell versions [3.59,3.63) of GNU make to not export all variables.
    998882# Otherwise a system limit (for SysV at least) may be exceeded.

  • libcfa/src/heap.cfa

    r6d44da1 r341bb80  
     1// #comment TD : this file uses both spaces and tabs for indentation
     2
    13//
    24// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
    … …  
    1012// Created On       : Tue Dec 19 21:58:35 2017
    1113// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Sep  6 09:01:30 2018
    13 // Update Count     : 513
     14// Last Modified On : Sat Aug 11 08:22:16 2018
     15// Update Count     : 495
    1416//
    1517
    … …  
    2325
    2426// #comment TD : Many of these should be merged into math I believe
    25 #include "bits/align.hfa"                                                               // libPow2
    26 #include "bits/defs.hfa"                                                                // likely, unlikely
    27 #include "bits/locks.hfa"                                                               // __spinlock_t
     27#include "bits/align.hfa"                                                                       // libPow2
     28#include "bits/defs.hfa"                                                                        // likely, unlikely
     29#include "bits/locks.hfa"                                                                       // __spinlock_t
    2830#include "startup.hfa"                                                                  // STARTUP_PRIORITY_MEMORY
    29 #include "stdlib.hfa"                                                                   // bsearchl
     31#include "stdlib.hfa"                                                                           // bsearchl
    3032#include "malloc.h"
    3133
    … …  
    149151
    150152extern "C" {
    151         void heapAppStart() {                                                           // called by __cfaabi_appready_startup
    152                 allocFree = 0;
    153         } // heapAppStart
    154 
    155         void heapAppStop() {                                                            // called by __cfaabi_appready_startdown
    156                 fclose( stdin ); fclose( stdout );
    157                 checkUnfreed();
    158         } // heapAppStop
     153void heapAppStart() {                                                                   // called by __cfaabi_appready_startup
     154        allocFree = 0;
     155} // heapAppStart
     156
     157void heapAppStop() {                                                                    // called by __cfaabi_appready_startdown
     158        fclose( stdin ); fclose( stdout );
     159        checkUnfreed();
     160} // heapAppStop
    159161} // extern "C"
    160162#endif // __CFA_DEBUG__
    … …  
    165167
    166168        struct Storage {
    167                 struct Header {                                                                 // header
     169            struct Header {                                                                     // header
    168170                        union Kind {
    169171                                struct RealHeader {
    170172                                        union {
    171                                                 struct {                                                // 4-byte word => 8-byte header, 8-byte word => 16-byte header
     173                                                // #comment TD : this code use byte size but the comment uses bit size
     174
     175                                                struct {                                                // 32-bit word => 64-bit header, 64-bit word => 128-bit header
    172176                                                        #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4
    173177                                                        uint32_t padding;                       // unused, force home/blocksize to overlay alignment in fake header
    174                                                         #endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4
     178                                                        #endif // __ORDER_BIG_ENDIAN__ && __U_WORDSIZE__ == 32
    175179
    176180                                                        union {
    … …  
    185189                                                        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4
    186190                                                        uint32_t padding;                       // unused, force home/blocksize to overlay alignment in fake header
    187                                                         #endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4
     191                                                        #endif // __ORDER_LITTLE_ENDIAN__ && __U_WORDSIZE__ == 32
     192
    188193                                                };
    189                                                 // future code
     194
     195                                                // #comment TD : C++ code
    190196                                                #if BUCKLOCK == LOCKFREE
    191197                                                Stack<Storage>::Link next;              // freed block points next freed block of same size (double-wide)
    … …  
    205211                                } fake; // FakeHeader
    206212                        } kind; // Kind
    207                 } header; // Header
    208                 char pad[ALIGN - sizeof( Header )];
    209                 char data[0];                                                                   // storage
     213            } header; // Header
     214            char pad[ALIGN - sizeof( Header )];
     215            char data[0];                                                                       // storage
    210216        }; // Storage
    211217
    … …  
    214220        struct FreeHeader {
    215221                #if BUCKLOCK == SPINLOCK
    216                 __spinlock_t lock;                                                              // must be first field for alignment
    217                 Storage * freeList;
     222            __spinlock_t lock;                                                          // must be first field for alignment
     223            Storage * freeList;
    218224                #elif BUCKLOCK == LOCKFREE
    219                 // future code
    220                 StackLF<Storage> freeList;
     225                // #comment TD : C++ code
     226            StackLF<Storage> freeList;
    221227                #else
    222                 #error undefined lock type for bucket lock
     228                        #error undefined lock type for bucket lock
    223229                #endif // SPINLOCK
    224                 size_t blockSize;                                                               // size of allocations on this list
     230            size_t blockSize;                                                           // size of allocations on this list
    225231        }; // FreeHeader
    226232
    … …  
    243249static unsigned int maxBucketsUsed;                                             // maximum number of buckets in use
    244250
     251// #comment TD : This array is not const but it feels like it should be
    245252// Powers of 2 are common allocation sizes, so make powers of 2 generate the minimum required size.
    246 static const unsigned int bucketSizes[NoBucketSizes] @= { // different bucket sizes
     253static unsigned int bucketSizes[NoBucketSizes] @= {             // different bucket sizes
    247254        16, 32, 48, 64,
    248255        64 + sizeof(HeapManager.Storage), 96, 112, 128, 128 + sizeof(HeapManager.Storage), 160, 192, 224,
    … …  
    272279// #comment TD : The return type of this function should be commented
    273280static inline bool setMmapStart( size_t value ) {
    274   if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
     281        if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true;
    275282        mmapStart = value;                                                                      // set global
    276283
    … …  
    306313        sbrk( (char *)libCeiling( (long unsigned int)End, libAlign() ) - End ); // move start of heap to multiple of alignment
    307314        heapBegin = heapEnd = sbrk( 0 );                                        // get new start point
    308                            } // HeapManager
     315} // HeapManager
    309316
    310317
    … …  
    316323        // } // if
    317324        #endif // __STATISTICS__
    318                                 } // ~HeapManager
     325} // ~HeapManager
    319326
    320327
    … …  
    322329void memory_startup( void ) {
    323330        #ifdef __CFA_DEBUG__
    324         if ( unlikely( heapBoot ) ) {                                           // check for recursion during system boot
     331        if ( unlikely( heapBoot ) ) {                                   // check for recursion during system boot
    325332                // DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT.
    326333                abort( "boot() : internal error, recursively invoked during system boot." );
    … …  
    329336        #endif // __CFA_DEBUG__
    330337
    331         //assert( heapManager.heapBegin != 0 );
    332         //heapManager{};
    333         if ( heapManager.heapBegin == 0 ) heapManager{};
     338        // #comment TD : This assertion seems redundent with the above code
     339        assert( heapManager.heapBegin == 0 );
     340        heapManager{};
    334341} // memory_startup
    335342
    … …  
    367374        char helpText[512];
    368375        __cfaabi_dbg_bits_print_buffer( helpText, sizeof(helpText),
    369                                                                         "\nHeap statistics:\n"
    370                                                                         "  malloc: calls %u / storage %llu\n"
    371                                                                         "  calloc: calls %u / storage %llu\n"
    372                                                                         "  memalign: calls %u / storage %llu\n"
    373                                                                         "  cmemalign: calls %u / storage %llu\n"
    374                                                                         "  realloc: calls %u / storage %llu\n"
    375                                                                         "  free: calls %u / storage %llu\n"
    376                                                                         "  mmap: calls %u / storage %llu\n"
    377                                                                         "  munmap: calls %u / storage %llu\n"
    378                                                                         "  sbrk: calls %u / storage %llu\n",
    379                                                                         malloc_calls, malloc_storage,
    380                                                                         calloc_calls, calloc_storage,
    381                                                                         memalign_calls, memalign_storage,
    382                                                                         cmemalign_calls, cmemalign_storage,
    383                                                                         realloc_calls, realloc_storage,
    384                                                                         free_calls, free_storage,
    385                                                                         mmap_calls, mmap_storage,
    386                                                                         munmap_calls, munmap_storage,
    387                                                                         sbrk_calls, sbrk_storage
     376                        "\nHeap statistics:\n"
     377                        "  malloc: calls %u / storage %llu\n"
     378                        "  calloc: calls %u / storage %llu\n"
     379                        "  memalign: calls %u / storage %llu\n"
     380                        "  cmemalign: calls %u / storage %llu\n"
     381                        "  realloc: calls %u / storage %llu\n"
     382                        "  free: calls %u / storage %llu\n"
     383                        "  mmap: calls %u / storage %llu\n"
     384                        "  munmap: calls %u / storage %llu\n"
     385                        "  sbrk: calls %u / storage %llu\n",
     386                        malloc_calls, malloc_storage,
     387                        calloc_calls, calloc_storage,
     388                        memalign_calls, memalign_storage,
     389                        cmemalign_calls, cmemalign_storage,
     390                        realloc_calls, realloc_storage,
     391                        free_calls, free_storage,
     392                        mmap_calls, mmap_storage,
     393                        munmap_calls, munmap_storage,
     394                        sbrk_calls, sbrk_storage
    388395                );
    389396} // printStats
    390397
    391 static int printStatsXML( FILE * stream ) {                             // see malloc_info
     398// #comment TD : Why do we have this?
     399static int printStatsXML( FILE * stream ) {
    392400        char helpText[512];
    393401        int len = snprintf( helpText, sizeof(helpText),
    … …  
    423431static inline void noMemory() {
    424432        abort( "Heap memory exhausted at %zu bytes.\n"
    425                    "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
    426                    ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
     433                        "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
     434                        ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
    427435} // noMemory
    428436
    … …  
    436444
    437445static inline bool setHeapExpand( size_t value ) {
    438   if ( heapExpand < pageSize ) return true;
     446        if ( heapExpand < pageSize ) return true;
    439447        heapExpand = value;
    440448        return false;
    … …  
    445453        if ( unlikely( check ) ) {                                                      // bad address ?
    446454                abort( "Attempt to %s storage %p with address outside the heap.\n"
    447                            "Possible cause is duplicate free on same block or overwriting of memory.",
    448                            name, addr );
     455                                "Possible cause is duplicate free on same block or overwriting of memory.",
     456                                name, addr );
    449457        } // if
    450458} // checkHeader
    … …  
    476484
    477485        #ifdef __CFA_DEBUG__
    478         checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
     486                        checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
    479487        #endif // __CFA_DEBUG__
    480488
    … …  
    482490        //               It's called as the first statement of both branches of the last if, with the same parameters in all cases
    483491
    484         // header may be safe to dereference
    485         fakeHeader( header, size, alignment );
     492                // header may be safe to dereference
     493                fakeHeader( header, size, alignment );
    486494        #ifdef __CFA_DEBUG__
    487         checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -)
     495                        checkHeader( header < (HeapManager.Storage.Header *)heapBegin || (HeapManager.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -)
    488496        #endif // __CFA_DEBUG__
    489497
    490         freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3);
     498                freeElem = (HeapManager.FreeHeader *)((size_t)header->kind.real.home & -3);
    491499        #ifdef __CFA_DEBUG__
    492         if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) {
    493                 abort( "Attempt to %s storage %p with corrupted header.\n"
    494                           "Possible cause is duplicate free on same block or overwriting of header information.",
    495                            name, addr );
    496         } // if
     500                        if ( freeElem < &freeLists[0] || &freeLists[NoBucketSizes] <= freeElem ) {
     501                        abort( "Attempt to %s storage %p with corrupted header.\n"
     502                                "Possible cause is duplicate free on same block or overwriting of header information.",
     503                                        name, addr );
     504                        } // if
    497505        #endif // __CFA_DEBUG__
    498         size = freeElem->blockSize;
    499         return false;
     506                size = freeElem->blockSize;
     507                return false;
    500508} // headers
    501509
    … …  
    513521                        return 0;
    514522                } // if
    515                 #ifdef __STATISTICS__
     523#ifdef __STATISTICS__
    516524                sbrk_calls += 1;
    517525                sbrk_storage += increase;
    518                 #endif // __STATISTICS__
    519                 #ifdef __CFA_DEBUG__
     526#endif // __STATISTICS__
     527#ifdef __CFA_DEBUG__
    520528                // Set new memory to garbage so subsequent uninitialized usages might fail.
    521529                memset( (char *)heapEnd + heapRemaining, '\377', increase );
    522                 #endif // __CFA_DEBUG__
     530#endif // __CFA_DEBUG__
    523531                rem = heapRemaining + increase - size;
    524532        } // if
    … …  
    552560
    553561                #if defined( SPINLOCK )
    554                 lock( freeElem->lock __cfaabi_dbg_ctx2 );
    555                 block = freeElem->freeList;                                             // remove node from stack
     562                        lock( freeElem->lock __cfaabi_dbg_ctx2 );
     563                        block = freeElem->freeList;                                             // remove node from stack
    556564                #else
    557                 block = freeElem->freeList.pop();
     565                        block = freeElem->freeList.pop();
    558566                #endif // SPINLOCK
    559567                if ( unlikely( block == 0 ) ) {                                 // no free block ?
    … …  
    561569                        unlock( freeElem->lock );
    562570                        #endif // SPINLOCK
    563 
    564571                        // Freelist for that size was empty, so carve it out of the heap if there's enough left, or get some more
    565572                        // and then carve it off.
    566573
    567574                        block = (HeapManager.Storage *)extend( tsize ); // mutual exclusion on call
    568   if ( unlikely( block == 0 ) ) return 0;
     575                        if ( unlikely( block == 0 ) ) return 0;
    569576                        #if defined( SPINLOCK )
    570577                } else {
    … …  
    575582
    576583                block->header.kind.real.home = freeElem;                // pointer back to free list of apropriate size
    577         } else {                                                                                        // large size => mmap
     584                } else {                                                                                        // large size => mmap
    578585                tsize = libCeiling( tsize, pageSize );                  // must be multiple of page size
    579586                #ifdef __STATISTICS__
    580                 __atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST );
    581                 __atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST );
     587                        __atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST );
     588                        __atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST );
    582589                #endif // __STATISTICS__
    583590                block = (HeapManager.Storage *)mmap( 0, tsize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 );
    … …  
    586593                        abort( "(HeapManager &)0x%p.doMalloc() : internal error, mmap failure, size:%zu error:%d.", &heapManager, tsize, errno );
    587594                } // if
    588                 #ifdef __CFA_DEBUG__
     595#ifdef __CFA_DEBUG__
    589596                // Set new memory to garbage so subsequent uninitialized usages might fail.
    590597                memset( block, '\377', tsize );
    591                 #endif // __CFA_DEBUG__
     598#endif // __CFA_DEBUG__
    592599                block->header.kind.real.blockSize = tsize;              // storage size for munmap
    593         } // if
    594 
    595         void * area = &(block->data);                                           // adjust off header to user bytes
     600                } // if
     601
     602                void * area = &(block->data);                                           // adjust off header to user bytes
    596603
    597604        #ifdef __CFA_DEBUG__
    598         assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ?
    599         __atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST );
    600         if ( traceHeap() ) {
    601                 enum { BufferSize = 64 };
    602                 char helpText[BufferSize];
    603                 int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", area, size, tsize );
    604                 // int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", area, size );
    605                 __cfaabi_dbg_bits_write( helpText, len );
    606         } // if
     605                        assert( ((uintptr_t)area & (libAlign() - 1)) == 0 ); // minimum alignment ?
     606                        __atomic_add_fetch( &allocFree, tsize, __ATOMIC_SEQ_CST );
     607                if ( traceHeap() ) {
     608                        enum { BufferSize = 64 };
     609                        char helpText[BufferSize];
     610                        int len = snprintf( helpText, BufferSize, "%p = Malloc( %zu ) (allocated %zu)\n", area, size, tsize );
     611                        // int len = snprintf( helpText, BufferSize, "Malloc %p %zu\n", area, size );
     612                        __cfaabi_dbg_bits_write( helpText, len );
     613                } // if
    607614        #endif // __CFA_DEBUG__
    608615
    … …  
    613620static inline void doFree( void * addr ) with ( heapManager ) {
    614621        #ifdef __CFA_DEBUG__
    615         if ( unlikely( heapManager.heapBegin == 0 ) ) {
    616                 abort( "doFree( %p ) : internal error, called before heap is initialized.", addr );
    617         } // if
     622                if ( unlikely( heapManager.heapBegin == 0 ) ) {
     623                        abort( "doFree( %p ) : internal error, called before heap is initialized.", addr );
     624                } // if
    618625        #endif // __CFA_DEBUG__
    619626
    … …  
    624631        if ( headers( "free", addr, header, freeElem, size, alignment ) ) { // mmapped ?
    625632                #ifdef __STATISTICS__
    626                 __atomic_add_fetch( &munmap_calls, 1, __ATOMIC_SEQ_CST );
    627                 __atomic_add_fetch( &munmap_storage, size, __ATOMIC_SEQ_CST );
     633                        __atomic_add_fetch( &munmap_calls, 1, __ATOMIC_SEQ_CST );
     634                        __atomic_add_fetch( &munmap_storage, size, __ATOMIC_SEQ_CST );
    628635                #endif // __STATISTICS__
    629636                if ( munmap( header, size ) == -1 ) {
    630637                        #ifdef __CFA_DEBUG__
    631638                        abort( "Attempt to deallocate storage %p not allocated or with corrupt header.\n"
    632                                    "Possible cause is invalid pointer.",
    633                                    addr );
     639                                        "Possible cause is invalid pointer.",
     640                                        addr );
    634641                        #endif // __CFA_DEBUG__
    635642                } // if
    636         } else {
     643                } else {
    637644                #ifdef __CFA_DEBUG__
    638                 // Set free memory to garbage so subsequent usages might fail.
    639                 memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) );
     645                        // Set free memory to garbage so subsequent usages might fail.
     646                        memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) );
    640647                #endif // __CFA_DEBUG__
    641648
    642649                #ifdef __STATISTICS__
    643                 free_storage += size;
     650                        free_storage += size;
    644651                #endif // __STATISTICS__
    645652                #if defined( SPINLOCK )
    646                 lock( freeElem->lock __cfaabi_dbg_ctx2 );               // acquire spin lock
    647                 header->kind.real.next = freeElem->freeList;    // push on stack
    648                 freeElem->freeList = (HeapManager.Storage *)header;
    649                 unlock( freeElem->lock );                                               // release spin lock
     653                        lock( freeElem->lock __cfaabi_dbg_ctx2 );               // acquire spin lock
     654                        header->kind.real.next = freeElem->freeList;    // push on stack
     655                        freeElem->freeList = (HeapManager.Storage *)header;
     656                        unlock( freeElem->lock );                                               // release spin lock
    650657                #else
    651                 freeElem->freeList.push( *(HeapManager.Storage *)header );
     658                        freeElem->freeList.push( *(HeapManager.Storage *)header );
    652659                #endif // SPINLOCK
    653         } // if
     660                } // if
    654661
    655662        #ifdef __CFA_DEBUG__
    656         __atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST );
    657         if ( traceHeap() ) {
    658                 char helpText[64];
    659                 int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size );
    660                 __cfaabi_dbg_bits_write( helpText, len );
    661         } // if
     663                 __atomic_add_fetch( &allocFree, -size, __ATOMIC_SEQ_CST );
     664                if ( traceHeap() ) {
     665                        char helpText[64];
     666                        int len = snprintf( helpText, sizeof(helpText), "Free( %p ) size:%zu\n", addr, size );
     667                        __cfaabi_dbg_bits_write( helpText, len );
     668                } // if
    662669        #endif // __CFA_DEBUG__
    663670} // doFree
    … …  
    667674        size_t total = 0;
    668675        #ifdef __STATISTICS__
    669         __cfaabi_dbg_bits_acquire();
    670         __cfaabi_dbg_bits_print_nolock( "\nBin lists (bin size : free blocks on list)\n" );
     676                __cfaabi_dbg_bits_acquire();
     677                __cfaabi_dbg_bits_print_nolock( "\nBin lists (bin size : free blocks on list)\n" );
    671678        #endif // __STATISTICS__
    672679        for ( unsigned int i = 0; i < maxBucketsUsed; i += 1 ) {
    … …  
    688695
    689696                #ifdef __STATISTICS__
    690                 __cfaabi_dbg_bits_print_nolock( "%7zu, %-7u  ", size, N );
    691                 if ( (i + 1) % 8 == 0 ) __cfaabi_dbg_bits_print_nolock( "\n" );
     697                        __cfaabi_dbg_bits_print_nolock( "%7zu, %-7u  ", size, N );
     698                        if ( (i + 1) % 8 == 0 ) __cfaabi_dbg_bits_print_nolock( "\n" );
    692699                #endif // __STATISTICS__
    693700        } // for
    694701        #ifdef __STATISTICS__
    695         __cfaabi_dbg_bits_print_nolock( "\ntotal free blocks:%zu\n", total );
    696         __cfaabi_dbg_bits_release();
     702                __cfaabi_dbg_bits_print_nolock( "\ntotal free blocks:%zu\n", total );
     703                __cfaabi_dbg_bits_release();
    697704        #endif // __STATISTICS__
    698705        return (char *)heapEnd - (char *)heapBegin - total;
    699706} // checkFree
    700707
    701 
    702 static inline void * mallocNoStats( size_t size ) {             // necessary for malloc statistics
    703         //assert( heapManager.heapBegin != 0 );
    704         if ( unlikely( heapManager.heapBegin == 0 ) ) heapManager{}; // called before memory_startup ?
     708// #comment TD : This is not a good name, plus this feels like it could easily be folded into doMalloc
     709static inline void * malloc2( size_t size ) {                   // necessary for malloc statistics
     710        assert( heapManager.heapBegin != 0 );
    705711        void * area = doMalloc( size );
    706712        if ( unlikely( area == 0 ) ) errno = ENOMEM;            // POSIX
    707713        return area;
    708 } // mallocNoStats
    709 
    710 
    711 static inline void * memalignNoStats( size_t alignment, size_t size ) { // necessary for malloc statistics
    712         #ifdef __CFA_DEBUG__
     714} // malloc2
     715
     716
     717static inline void * memalign2( size_t alignment, size_t size ) { // necessary for malloc statistics
     718#ifdef __CFA_DEBUG__
    713719        checkAlign( alignment );                                                        // check alignment
    714         #endif // __CFA_DEBUG__
     720#endif // __CFA_DEBUG__
    715721
    716722        // if alignment <= default alignment, do normal malloc as two headers are unnecessary
    717   if ( unlikely( alignment <= libAlign() ) ) return mallocNoStats( size );
     723        if ( unlikely( alignment <= libAlign() ) ) return malloc2( size );
    718724
    719725        // Allocate enough storage to guarantee an address on the alignment boundary, and sufficient space before it for
    … …  
    726732        // subtract libAlign() because it is already the minimum alignment
    727733        // add sizeof(Storage) for fake header
    728         // #comment TD : this is the only place that calls doMalloc without calling mallocNoStats, why ?
     734        // #comment TD : this is the only place that calls doMalloc without calling malloc2, why ?
    729735        char * area = (char *)doMalloc( size + alignment - libAlign() + sizeof(HeapManager.Storage) );
    730   if ( unlikely( area == 0 ) ) return area;
     736        if ( unlikely( area == 0 ) ) return area;
    731737
    732738        // address in the block of the "next" alignment address
    … …  
    743749
    744750        return user;
    745 } // memalignNoStats
     751} // memalign2
    746752
    747753
    748754extern "C" {
    749         // The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not
    750         // initialized. If size is 0, then malloc() returns either NULL, or a unique pointer value that can later be
    751         // successfully passed to free().
     755        // The malloc() function allocates size bytes and returns a pointer to the
     756        // allocated memory. The memory is not initialized. If size is 0, then malloc()
     757        // returns either NULL, or a unique pointer value that can later be successfully
     758        // passed to free().
    752759        void * malloc( size_t size ) {
    753760                #ifdef __STATISTICS__
    754                 __atomic_add_fetch( &malloc_calls, 1, __ATOMIC_SEQ_CST );
    755                 __atomic_add_fetch( &malloc_storage, size, __ATOMIC_SEQ_CST );
    756                 #endif // __STATISTICS__
    757 
    758                 return mallocNoStats( size );
    759         } // malloc
    760 
    761         // The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to
    762         // the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either NULL, or a
    763         // unique pointer value that can later be successfully passed to free().
    764         void * calloc( size_t noOfElems, size_t elemSize ) {
     761                        __atomic_add_fetch( &malloc_calls, 1, __ATOMIC_SEQ_CST );
     762                        __atomic_add_fetch( &malloc_storage, size, __ATOMIC_SEQ_CST );
     763                #endif // __STATISTICS__
     764
     765                return malloc2( size );
     766                } // malloc
     767
     768        // The calloc() function allocates memory for an array of nmemb elements of
     769        // size bytes each and returns a pointer to the allocated memory. The memory
     770        // is set to zero. If nmemb or size is 0, then calloc() returns either NULL,
     771        // or a unique pointer value that can later be successfully passed to free().
     772                void * calloc( size_t noOfElems, size_t elemSize ) {
    765773                size_t size = noOfElems * elemSize;
    766774                #ifdef __STATISTICS__
    767                 __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST );
    768                 __atomic_add_fetch( &calloc_storage, size, __ATOMIC_SEQ_CST );
    769                 #endif // __STATISTICS__
    770 
    771                 char * area = (char *)mallocNoStats( size );
    772           if ( unlikely( area == 0 ) ) return 0;
     775                        __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST );
     776                        __atomic_add_fetch( &calloc_storage, size, __ATOMIC_SEQ_CST );
     777                #endif // __STATISTICS__
     778
     779                char * area = (char *)malloc2( size );
     780                if ( unlikely( area == 0 ) ) return 0;
    773781
    774782                HeapManager.Storage.Header * header;
    … …  
    782790                        memset( area, '\0', asize - sizeof(HeapManager.Storage) ); // set to zeros
    783791
    784                 header->kind.real.blockSize |= 2;                               // mark as zero filled
     792                header->kind.real.blockSize |= 2;               // mark as zero filled
    785793                return area;
    786         } // calloc
     794                } // calloc
    787795
    788796        // #comment TD : Document this function
    … …  
    790798                size_t size = noOfElems * elemSize;
    791799                #ifdef __STATISTICS__
    792                 __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
    793                 __atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST );
    794                 #endif // __STATISTICS__
    795 
    796                 char * area = (char *)memalignNoStats( alignment, size );
    797           if ( unlikely( area == 0 ) ) return 0;
     800                        __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
     801                        __atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST );
     802                #endif // __STATISTICS__
     803
     804                char * area = (char *)memalign2( alignment, size );
     805                if ( unlikely( area == 0 ) ) return 0;
    798806                HeapManager.Storage.Header * header;
    799807                HeapManager.FreeHeader * freeElem;
    … …  
    803811                // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
    804812                if ( ! mapped )
    805                         #endif // __CFA_DEBUG__
     813                #endif // __CFA_DEBUG__
    806814                        memset( area, '\0', asize - ( (char *)area - (char *)header ) ); // set to zeros
    807815                header->kind.real.blockSize |= 2;                               // mark as zero filled
    808816
    809817                return area;
    810         } // cmemalign
    811 
    812         // The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be
    813         // unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size
    814         // is larger than the old size, the added memory will not be initialized.  If ptr is NULL, then the call is
    815         // equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call
    816         // is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(),
    817         // calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.
    818         void * realloc( void * addr, size_t size ) {
    819                 #ifdef __STATISTICS__
    820                 __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
    821                 #endif // __STATISTICS__
    822 
    823           if ( unlikely( addr == 0 ) ) return mallocNoStats( size ); // special cases
    824           if ( unlikely( size == 0 ) ) { free( addr ); return 0; }
     818                } // cmemalign
     819
     820        // The realloc() function changes the size of the memory block pointed to by
     821        // ptr to size bytes. The contents will be unchanged in the range from the
     822        // start of the region up to the minimum of the old and new sizes. If the new
     823        // size is larger than the old size, the added memory will not be initialized.
     824        // If ptr is NULL, then the call is equivalent to malloc(size), for all values
     825        // of size; if size is equal to zero, and ptr is not NULL, then the call is
     826        // equivalent to free(ptr). Unless ptr is NULL, it must have been returned by
     827        // an earlier call to malloc(), calloc() or realloc(). If the area pointed to
     828        // was moved, a free(ptr) is done.
     829                void * realloc( void * addr, size_t size ) {
     830                #ifdef __STATISTICS__
     831                        __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
     832                #endif // __STATISTICS__
     833
     834                if ( unlikely( addr == 0 ) ) return malloc2( size ); // special cases
     835                if ( unlikely( size == 0 ) ) { free( addr ); return 0; }
    825836
    826837                HeapManager.Storage.Header * header;
    … …  
    837848
    838849                #ifdef __STATISTICS__
    839                 __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
     850                        __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
    840851                #endif // __STATISTICS__
    841852
    … …  
    844855                        area = memalign( alignment, size );                     // create new area
    845856                } else {
    846                         area = mallocNoStats( size );                           // create new area
    847                 } // if
    848           if ( unlikely( area == 0 ) ) return 0;
     857                        area = malloc2( size ); // create new area
     858                } // if
     859                if ( unlikely( area == 0 ) ) return 0;
    849860                if ( unlikely( header->kind.real.blockSize & 2 ) ) { // previous request zero fill (calloc/cmemalign) ?
    850861                        assert( (header->kind.real.blockSize & 1) == 0 );
    … …  
    853864                        // Mapped storage is zero filled, but in debug mode mapped memory is scrubbed in doMalloc, so it has to be reset to zero.
    854865                        if ( ! mapped )
    855                                 #endif // __CFA_DEBUG__
     866                        #endif // __CFA_DEBUG__
    856867                                memset( (char *)area + usize, '\0', asize - ( (char *)area - (char *)header ) - usize ); // zero-fill back part
    857868                        header->kind.real.blockSize |= 2;                       // mark new request as zero fill
    … …  
    863874
    864875
    865         // The obsolete function memalign() allocates size bytes and returns a pointer to the allocated memory. The memory
    866         // address will be a multiple of alignment, which must be a power of two.
    867         void * memalign( size_t alignment, size_t size ) {
     876        // The obsolete function memalign() allocates size bytes and returns
     877        // a pointer to the allocated memory. The memory address will be a
     878        // multiple of alignment, which must be a power of two.
     879        void * memalign( size_t alignment, size_t size ) __attribute__ ((deprecated));
     880                void * memalign( size_t alignment, size_t size ) {
    868881                #ifdef __STATISTICS__
    869882                __atomic_add_fetch( &memalign_calls, 1, __ATOMIC_SEQ_CST );
    … …  
    871884                #endif // __STATISTICS__
    872885
    873                 void * area = memalignNoStats( alignment, size );
     886                void * area = memalign2( alignment, size );
    874887
    875888                return area;
    876         } // memalign
    877 
    878         // The function aligned_alloc() is the same as memalign(), except for the added restriction that size should be a
    879         // multiple of alignment.
     889                } // memalign
     890
     891        // The function aligned_alloc() is the same as memalign(), except for
     892        // the added restriction that size should be a multiple of alignment.
    880893        void * aligned_alloc( size_t alignment, size_t size ) {
    881894                return memalign( alignment, size );
    … …  
    883896
    884897
    885         // The function posix_memalign() allocates size bytes and places the address of the allocated memory in *memptr. The
    886         // address of the allocated memory will be a multiple of alignment, which must be a power of two and a multiple of
    887         // sizeof(void *). If size is 0, then posix_memalign() returns either NULL, or a unique pointer value that can later
    888         // be successfully passed to free(3).
     898        // The function posix_memalign() allocates size bytes and places the address
     899        // of the allocated memory in *memptr. The address of the allocated memory
     900        // will be a multiple of alignment, which must be a power of two and a multiple
     901        // of sizeof(void *). If size is 0, then posix_memalign() returns either NULL,
     902        // or a unique pointer value that can later be successfully passed to free(3).
    889903        int posix_memalign( void ** memptr, size_t alignment, size_t size ) {
    890           if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment
     904                if ( alignment < sizeof(void *) || ! libPow2( alignment ) ) return EINVAL; // check alignment
    891905                * memptr = memalign( alignment, size );
    892           if ( unlikely( * memptr == 0 ) ) return ENOMEM;
     906                if ( unlikely( * memptr == 0 ) ) return ENOMEM;
    893907                return 0;
    894908        } // posix_memalign
    895909
    896         // The obsolete function valloc() allocates size bytes and returns a pointer to the allocated memory. The memory
    897         // address will be a multiple of the page size.  It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
     910        // The obsolete function valloc() allocates size bytes and returns a pointer
     911        // to the allocated memory. The memory address will be a multiple of the page size.
     912        // It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
     913        void * valloc( size_t size ) __attribute__ ((deprecated));
    898914        void * valloc( size_t size ) {
    899915                return memalign( pageSize, size );
    … …  
    901917
    902918
    903         // The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call to
    904         // malloc(), calloc() or realloc().  Otherwise, or if free(ptr) has already been called before, undefined behavior
    905         // occurs. If ptr is NULL, no operation is performed.
     919        // The free() function frees the memory space pointed to by ptr, which must
     920        // have been returned by a previous call to malloc(), calloc() or realloc().
     921        // Otherwise, or if free(ptr) has already been called before, undefined
     922        // behavior occurs. If ptr is NULL, no operation is performed.
    906923        void free( void * addr ) {
    907924                #ifdef __STATISTICS__
    908                 __atomic_add_fetch( &free_calls, 1, __ATOMIC_SEQ_CST );
     925                        __atomic_add_fetch( &free_calls, 1, __ATOMIC_SEQ_CST );
    909926                #endif // __STATISTICS__
    910927
    … …  
    914931                if ( unlikely( addr == 0 ) ) {                                  // special case
    915932                        #ifdef __CFA_DEBUG__
    916                         if ( traceHeap() ) {
    917                                 #define nullmsg "Free( 0x0 ) size:0\n"
    918                                 // Do not debug print free( 0 ), as it can cause recursive entry from sprintf.
    919                                 __cfaabi_dbg_bits_write( nullmsg, sizeof(nullmsg) - 1 );
    920                         } // if
     933                                if ( traceHeap() ) {
     934                                        #define nullmsg "Free( 0x0 ) size:0\n"
     935                                        // Do not debug print free( 0 ), as it can cause recursive entry from sprintf.
     936                                        __cfaabi_dbg_bits_write( nullmsg, sizeof(nullmsg) - 1 );
     937                                } // if
    921938                        #endif // __CFA_DEBUG__
    922939                        return;
    … …  
    926943        } // free
    927944
    928         // The mallopt() function adjusts parameters that control the behavior of the memory-allocation functions (see
    929         // malloc(3)). The param argument specifies the parameter to be modified, and value specifies the new value for that
     945        // The mallopt() function adjusts parameters that control the behavior of the
     946        // memory-allocation functions (see malloc(3)). The param argument specifies
     947        // the parameter to be modified, and value specifies the new value for that
    930948        // parameter.
    931         int mallopt( int option, int value ) {
     949                int mallopt( int option, int value ) {
    932950                choose( option ) {
    933                   case M_TOP_PAD:
    934                         if ( setHeapExpand( value ) ) fallthru default;
    935                   case M_MMAP_THRESHOLD:
    936                         if ( setMmapStart( value ) ) fallthru default;
    937                   default:
    938                         // #comment TD : 1 for unsopported feels wrong
    939                         return 1;                                                                       // success, or unsupported
     951                        case M_TOP_PAD:
     952                                if ( setHeapExpand( value ) ) fallthru default;
     953                        case M_MMAP_THRESHOLD:
     954                                if ( setMmapStart( value ) ) fallthru default;
     955                        default:
     956                                // #comment TD : 1 for unsopported feels wrong
     957                                return 1;                                                                       // success, or unsupported
    940958                } // switch
    941959                return 0;                                                                               // error
    942960        } // mallopt
    943961
    944         // The malloc_trim() function attempts to release free memory at the top of the heap (by calling sbrk(2) with a
    945         // suitable argument).
     962        // The malloc_trim() function attempts to release free memory at the top
     963        // of the heap (by calling sbrk(2) with a suitable argument).
    946964        int malloc_trim( size_t ) {
    947965                return 0;                                                                               // => impossible to release memory
    948966        } // malloc_trim
    949967
    950         // The malloc_usable_size() function returns the number of usable bytes in the block pointed to by ptr, a pointer to
    951         // a block of memory allocated by malloc(3) or a related function.
    952         size_t malloc_usable_size( void * addr ) {
    953           if ( unlikely( addr == 0 ) ) return 0;                        // null allocation has 0 size
     968        // The malloc_usable_size() function returns the number of usable bytes in the
     969        // block pointed to by ptr, a pointer to a block of memory allocated by
     970        // malloc(3) or a related function.
     971                size_t malloc_usable_size( void * addr ) {
     972                if ( unlikely( addr == 0 ) ) return 0;                  // null allocation has 0 size
    954973
    955974                HeapManager.Storage.Header * header;
    … …  
    963982
    964983
    965     // The malloc_alignment() function returns the alignment of the allocation.
     984                // #comment TD : Document this function
    966985        size_t malloc_alignment( void * addr ) {
    967           if ( unlikely( addr == 0 ) ) return libAlign();       // minimum alignment
     986                if ( unlikely( addr == 0 ) ) return libAlign(); // minimum alignment
    968987                HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) );
    969988                if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ?
    … …  
    972991                        return libAlign ();                                                     // minimum alignment
    973992                } // if
    974         } // malloc_alignment
    975 
    976 
    977     // The malloc_zero_fill() function returns true if the allocation is zero filled, i.e., initially allocated by calloc().
     993                } // malloc_alignment
     994
     995
     996                // #comment TD : Document this function
    978997        bool malloc_zero_fill( void * addr ) {
    979           if ( unlikely( addr == 0 ) ) return false;            // null allocation is not zero fill
     998                if ( unlikely( addr == 0 ) ) return false;              // null allocation is not zero fill
    980999
    9811000                HeapManager.Storage.Header * header = (HeapManager.Storage.Header *)( (char *)addr - sizeof(HeapManager.Storage) );
    … …  
    9841003                } // if
    9851004                return (header->kind.real.blockSize & 2) != 0;  // zero filled (calloc/cmemalign) ?
    986         } // malloc_zero_fill
    987 
    988 
    989     // The malloc_stats() function prints (on default standard error) statistics about memory allocated by malloc(3) and
    990     // related functions.
     1005                } // malloc_zero_fill
     1006
     1007
     1008        // #comment TD : Document this function
    9911009        void malloc_stats( void ) {
    9921010                #ifdef __STATISTICS__
    993                 printStats();
    994                 if ( checkFree() ) checkFree( heapManager );
    995                 #endif // __STATISTICS__
    996         } // malloc_stats
    997 
    998         // The malloc_stats_fd() function changes the file descripter where malloc_stats() writes the statistics.
    999         int malloc_stats_fd( int fd ) {
    1000                 #ifdef __STATISTICS__
    1001                 int temp = statfd;
    1002                 statfd = fd;
    1003                 return temp;
     1011                        printStats();
     1012                        if ( checkFree() ) checkFree( heapManager );
     1013                #endif // __STATISTICS__
     1014                } // malloc_stats
     1015
     1016        // #comment TD : Document this function
     1017                int malloc_stats_fd( int fd ) {
     1018                #ifdef __STATISTICS__
     1019                        int temp = statfd;
     1020                        statfd = fd;
     1021                        return temp;
    10041022                #else
    1005                 return -1;
    1006                 #endif // __STATISTICS__
    1007         } // malloc_stats_fd
    1008 
    1009         // The malloc_info() function exports an XML string that describes the current state of the memory-allocation
    1010         // implementation in the caller.  The string is printed on the file stream stream.  The exported string includes
    1011         // information about all arenas (see malloc(3)).
     1023                        return -1;
     1024                #endif // __STATISTICS__
     1025                } // malloc_stats_fd
     1026
     1027
     1028        // #comment TD : Document this function
    10121029        int malloc_info( int options, FILE * stream ) {
    10131030                return printStatsXML( stream );
    … …  
    10151032
    10161033
    1017         // The malloc_get_state() function records the current state of all malloc(3) internal bookkeeping variables (but
    1018         // not the actual contents of the heap or the state of malloc_hook(3) functions pointers).  The state is recorded in
    1019         // a system-dependent opaque data structure dynamically allocated via malloc(3), and a pointer to that data
    1020         // structure is returned as the function result.  (It is the caller's responsibility to free(3) this memory.)
     1034        // #comment TD : What are these two functions for?
    10211035        void * malloc_get_state( void ) {
    1022                 return 0;                                                                               // unsupported
     1036                return 0;
    10231037        } // malloc_get_state
    10241038
    1025 
    1026         // The malloc_set_state() function restores the state of all malloc(3) internal bookkeeping variables to the values
    1027         // recorded in the opaque data structure pointed to by state.
    10281039        int malloc_set_state( void * ptr ) {
    1029                 return 0;                                                                               // unsupported
     1040                return 0;
    10301041        } // malloc_set_state
    10311042} // extern "C"

  • src/CodeTools/module.mk

    r6d44da1 r341bb80  
    1616
    1717SRC += CodeTools/DeclStats.cc \
    18         CodeTools/ResolvProtoDump.cc \
    1918        CodeTools/TrackLoc.cc

  • src/CompilationState.cc

    r6d44da1 r341bb80  
    3030        parsep = false,
    3131        resolvep = false,
    32         resolvprotop = false,
    3332        symtabp = false,
    3433        treep = false,

  • src/CompilationState.h

    r6d44da1 r341bb80  
    3131        parsep,
    3232        resolvep,
    33         resolvprotop,
    3433        symtabp,
    3534        treep,

  • src/GenPoly/ScrubTyVars.cc

    r6d44da1 r341bb80  
    5050                                delete typeInst;
    5151                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
    52                           default:
    53                                 assertf(false, "Unhandled tyvar kind: %d", tyVar->second.kind);
    5452                        } // switch
    5553                } // if

  • src/Makefile.am

    r6d44da1 r341bb80  
    4444# put into lib for now
    4545cfa_cpplibdir = $(CFA_LIBDIR)
    46 cfa_cpplib_PROGRAMS = ../driver/cfa-cpp demangler
     46cfa_cpplib_PROGRAMS = ../driver/cfa-cpp
    4747___driver_cfa_cpp_SOURCES = $(SRC)
    4848___driver_cfa_cpp_LDADD = -ldl                  # yywrap
    … …  
    5050AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
    5151AM_LDFLAGS  = @HOST_FLAGS@ -Xlinker -export-dynamic
    52 ARFLAGS     = cr
    53 
    54 demangler_SOURCES = SymTab/demangler.cc
    55 
    56 demangler_LDADD = libdemangle.a     # yywrap
    57 
    58 noinst_LIBRARIES = libdemangle.a
    59 libdemangle_a_SOURCES = SymTab/Demangle.cc SymTab/ManglerCommon.cc \
    60   SynTree/Type.cc \
    61   SynTree/VoidType.cc \
    62   SynTree/BasicType.cc \
    63   SynTree/PointerType.cc \
    64   SynTree/ArrayType.cc \
    65   SynTree/ReferenceType.cc \
    66   SynTree/FunctionType.cc \
    67   SynTree/ReferenceToType.cc \
    68   SynTree/TupleType.cc \
    69   SynTree/TypeofType.cc \
    70   SynTree/AttrType.cc \
    71   SynTree/VarArgsType.cc \
    72   SynTree/ZeroOneType.cc \
    73   SynTree/Constant.cc \
    74   SynTree/Expression.cc \
    75   SynTree/TupleExpr.cc \
    76   SynTree/CommaExpr.cc \
    77   SynTree/TypeExpr.cc \
    78   SynTree/ApplicationExpr.cc \
    79   SynTree/AddressExpr.cc \
    80   SynTree/Statement.cc \
    81   SynTree/CompoundStmt.cc \
    82   SynTree/DeclStmt.cc \
    83   SynTree/Declaration.cc \
    84   SynTree/DeclarationWithType.cc \
    85   SynTree/ObjectDecl.cc \
    86   SynTree/FunctionDecl.cc \
    87   SynTree/AggregateDecl.cc \
    88   SynTree/NamedTypeDecl.cc \
    89   SynTree/TypeDecl.cc \
    90   SynTree/Initializer.cc \
    91   SynTree/TypeSubstitution.cc \
    92   SynTree/Attribute.cc \
    93   SynTree/DeclReplacer.cc \
    94   CompilationState.cc \
    95   CodeGen/CodeGenerator.cc \
    96   CodeGen/FixMain.cc \
    97   CodeGen/GenType.cc \
    98   CodeGen/OperatorTable.cc \
    99   Common/Assert.cc \
    100   Common/Eval.cc \
    101   Common/SemanticError.cc \
    102   Common/UniqueName.cc \
    103   Concurrency/Keywords.cc \
    104   ControlStruct/ForExprMutator.cc \
    105   ControlStruct/LabelFixer.cc \
    106   ControlStruct/LabelGenerator.cc \
    107   ControlStruct/MLEMutator.cc \
    108   ControlStruct/Mutate.cc \
    109   GenPoly/GenPoly.cc \
    110   GenPoly/Lvalue.cc \
    111   InitTweak/GenInit.cc \
    112   InitTweak/InitTweak.cc \
    113   Parser/LinkageSpec.cc \
    114   ResolvExpr/AdjustExprType.cc \
    115   ResolvExpr/Alternative.cc \
    116   ResolvExpr/AlternativeFinder.cc \
    117   ResolvExpr/ExplodedActual.cc \
    118   ResolvExpr/CastCost.cc \
    119   ResolvExpr/CommonType.cc \
    120   ResolvExpr/ConversionCost.cc \
    121   ResolvExpr/CurrentObject.cc \
    122   ResolvExpr/FindOpenVars.cc \
    123   ResolvExpr/Occurs.cc \
    124   ResolvExpr/PolyCost.cc \
    125   ResolvExpr/PtrsAssignable.cc \
    126   ResolvExpr/PtrsCastable.cc \
    127   ResolvExpr/RenameVars.cc \
    128   ResolvExpr/Resolver.cc \
    129   ResolvExpr/ResolveTypeof.cc \
    130   ResolvExpr/TypeEnvironment.cc \
    131   ResolvExpr/Unify.cc \
    132   SymTab/Autogen.cc \
    133   SymTab/FixFunction.cc \
    134   SymTab/Indexer.cc \
    135   SymTab/Mangler.cc \
    136   SymTab/Validate.cc \
    137   Tuples/Explode.cc \
    138   Tuples/TupleAssignment.cc \
    139   Tuples/TupleExpansion.cc \
    140   Validate/HandleAttributes.cc
    14152
    14253MAINTAINERCLEANFILES += ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}

  • src/Makefile.in

    r6d44da1 r341bb80  
    6262######################### -*- Mode: Makefile-Gmake -*- ########################
    6363###############################################################################
    64 
    6564
    6665VPATH = @srcdir@
    … …  
    138137build_triplet = @build@
    139138host_triplet = @host@
    140 cfa_cpplib_PROGRAMS = ../driver/cfa-cpp$(EXEEXT) demangler$(EXEEXT)
     139cfa_cpplib_PROGRAMS = ../driver/cfa-cpp$(EXEEXT)
    141140subdir = src
    142141ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    … …  
    150149CONFIG_CLEAN_FILES =
    151150CONFIG_CLEAN_VPATH_FILES =
    152 LIBRARIES = $(noinst_LIBRARIES)
    153 AR = ar
    154 AM_V_AR = $(am__v_AR_@AM_V@)
    155 am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
    156 am__v_AR_0 = @echo "  AR      " $@;
    157 am__v_AR_1 =
    158 libdemangle_a_AR = $(AR) $(ARFLAGS)
    159 libdemangle_a_LIBADD =
    160 am__dirstamp = $(am__leading_dot)dirstamp
    161 am_libdemangle_a_OBJECTS = SymTab/Demangle.$(OBJEXT) \
    162         SymTab/ManglerCommon.$(OBJEXT) SynTree/Type.$(OBJEXT) \
    163         SynTree/VoidType.$(OBJEXT) SynTree/BasicType.$(OBJEXT) \
    164         SynTree/PointerType.$(OBJEXT) SynTree/ArrayType.$(OBJEXT) \
    165         SynTree/ReferenceType.$(OBJEXT) SynTree/FunctionType.$(OBJEXT) \
    166         SynTree/ReferenceToType.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
    167         SynTree/TypeofType.$(OBJEXT) SynTree/AttrType.$(OBJEXT) \
    168         SynTree/VarArgsType.$(OBJEXT) SynTree/ZeroOneType.$(OBJEXT) \
    169         SynTree/Constant.$(OBJEXT) SynTree/Expression.$(OBJEXT) \
    170         SynTree/TupleExpr.$(OBJEXT) SynTree/CommaExpr.$(OBJEXT) \
    171         SynTree/TypeExpr.$(OBJEXT) SynTree/ApplicationExpr.$(OBJEXT) \
    172         SynTree/AddressExpr.$(OBJEXT) SynTree/Statement.$(OBJEXT) \
    173         SynTree/CompoundStmt.$(OBJEXT) SynTree/DeclStmt.$(OBJEXT) \
    174         SynTree/Declaration.$(OBJEXT) \
    175         SynTree/DeclarationWithType.$(OBJEXT) \
    176         SynTree/ObjectDecl.$(OBJEXT) SynTree/FunctionDecl.$(OBJEXT) \
    177         SynTree/AggregateDecl.$(OBJEXT) \
    178         SynTree/NamedTypeDecl.$(OBJEXT) SynTree/TypeDecl.$(OBJEXT) \
    179         SynTree/Initializer.$(OBJEXT) \
    180         SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
    181         SynTree/DeclReplacer.$(OBJEXT) CompilationState.$(OBJEXT) \
    182         CodeGen/CodeGenerator.$(OBJEXT) CodeGen/FixMain.$(OBJEXT) \
    183         CodeGen/GenType.$(OBJEXT) CodeGen/OperatorTable.$(OBJEXT) \
    184         Common/Assert.$(OBJEXT) Common/Eval.$(OBJEXT) \
    185         Common/SemanticError.$(OBJEXT) Common/UniqueName.$(OBJEXT) \
    186         Concurrency/Keywords.$(OBJEXT) \
    187         ControlStruct/ForExprMutator.$(OBJEXT) \
    188         ControlStruct/LabelFixer.$(OBJEXT) \
    189         ControlStruct/LabelGenerator.$(OBJEXT) \
    190         ControlStruct/MLEMutator.$(OBJEXT) \
    191         ControlStruct/Mutate.$(OBJEXT) GenPoly/GenPoly.$(OBJEXT) \
    192         GenPoly/Lvalue.$(OBJEXT) InitTweak/GenInit.$(OBJEXT) \
    193         InitTweak/InitTweak.$(OBJEXT) Parser/LinkageSpec.$(OBJEXT) \
    194         ResolvExpr/AdjustExprType.$(OBJEXT) \
    195         ResolvExpr/Alternative.$(OBJEXT) \
    196         ResolvExpr/AlternativeFinder.$(OBJEXT) \
    197         ResolvExpr/ExplodedActual.$(OBJEXT) \
    198         ResolvExpr/CastCost.$(OBJEXT) ResolvExpr/CommonType.$(OBJEXT) \
    199         ResolvExpr/ConversionCost.$(OBJEXT) \
    200         ResolvExpr/CurrentObject.$(OBJEXT) \
    201         ResolvExpr/FindOpenVars.$(OBJEXT) ResolvExpr/Occurs.$(OBJEXT) \
    202         ResolvExpr/PolyCost.$(OBJEXT) \
    203         ResolvExpr/PtrsAssignable.$(OBJEXT) \
    204         ResolvExpr/PtrsCastable.$(OBJEXT) \
    205         ResolvExpr/RenameVars.$(OBJEXT) ResolvExpr/Resolver.$(OBJEXT) \
    206         ResolvExpr/ResolveTypeof.$(OBJEXT) \
    207         ResolvExpr/TypeEnvironment.$(OBJEXT) \
    208         ResolvExpr/Unify.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
    209         SymTab/FixFunction.$(OBJEXT) SymTab/Indexer.$(OBJEXT) \
    210         SymTab/Mangler.$(OBJEXT) SymTab/Validate.$(OBJEXT) \
    211         Tuples/Explode.$(OBJEXT) Tuples/TupleAssignment.$(OBJEXT) \
    212         Tuples/TupleExpansion.$(OBJEXT) \
    213         Validate/HandleAttributes.$(OBJEXT)
    214 libdemangle_a_OBJECTS = $(am_libdemangle_a_OBJECTS)
    215151am__installdirs = "$(DESTDIR)$(cfa_cpplibdir)"
    216152PROGRAMS = $(cfa_cpplib_PROGRAMS)
     153am__dirstamp = $(am__leading_dot)dirstamp
    217154am__objects_1 = main.$(OBJEXT) MakeLibCfa.$(OBJEXT) \
    218155        CompilationState.$(OBJEXT) CodeGen/Generate.$(OBJEXT) \
    … …  
    220157        CodeGen/FixNames.$(OBJEXT) CodeGen/FixMain.$(OBJEXT) \
    221158        CodeGen/OperatorTable.$(OBJEXT) CodeTools/DeclStats.$(OBJEXT) \
    222         CodeTools/ResolvProtoDump.$(OBJEXT) \
    223159        CodeTools/TrackLoc.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
    224160        Concurrency/Waitfor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
    … …  
    260196        ResolvExpr/CurrentObject.$(OBJEXT) \
    261197        ResolvExpr/ExplodedActual.$(OBJEXT) SymTab/Indexer.$(OBJEXT) \
    262         SymTab/Mangler.$(OBJEXT) SymTab/ManglerCommon.$(OBJEXT) \
    263         SymTab/Validate.$(OBJEXT) SymTab/FixFunction.$(OBJEXT) \
    264         SymTab/Autogen.$(OBJEXT) SynTree/Type.$(OBJEXT) \
    265         SynTree/VoidType.$(OBJEXT) SynTree/BasicType.$(OBJEXT) \
    266         SynTree/PointerType.$(OBJEXT) SynTree/ArrayType.$(OBJEXT) \
    267         SynTree/ReferenceType.$(OBJEXT) SynTree/FunctionType.$(OBJEXT) \
     198        SymTab/Mangler.$(OBJEXT) SymTab/Validate.$(OBJEXT) \
     199        SymTab/FixFunction.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
     200        SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
     201        SynTree/BasicType.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
     202        SynTree/ArrayType.$(OBJEXT) SynTree/ReferenceType.$(OBJEXT) \
     203        SynTree/FunctionType.$(OBJEXT) \
    268204        SynTree/ReferenceToType.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
    269205        SynTree/TypeofType.$(OBJEXT) SynTree/AttrType.$(OBJEXT) \
    … …  
    289225___driver_cfa_cpp_OBJECTS = $(am____driver_cfa_cpp_OBJECTS)
    290226___driver_cfa_cpp_DEPENDENCIES =
    291 am_demangler_OBJECTS = SymTab/demangler.$(OBJEXT)
    292 demangler_OBJECTS = $(am_demangler_OBJECTS)
    293 demangler_DEPENDENCIES = libdemangle.a
    294227AM_V_P = $(am__v_P_@AM_V@)
    295228am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
    … …  
    346279am__v_CCLD_0 = @echo "  CCLD    " $@;
    347280am__v_CCLD_1 =
    348 SOURCES = $(libdemangle_a_SOURCES) $(___driver_cfa_cpp_SOURCES) \
    349         $(demangler_SOURCES)
    350 DIST_SOURCES = $(libdemangle_a_SOURCES) $(___driver_cfa_cpp_SOURCES) \
    351         $(demangler_SOURCES)
     281SOURCES = $(___driver_cfa_cpp_SOURCES)
     282DIST_SOURCES = $(___driver_cfa_cpp_SOURCES)
    352283am__can_run_installinfo = \
    353284  case $$AM_UPDATE_INFO_DIR in \
    … …  
    520451        CodeGen/FixNames.cc CodeGen/FixMain.cc \
    521452        CodeGen/OperatorTable.cc CodeTools/DeclStats.cc \
    522         CodeTools/ResolvProtoDump.cc CodeTools/TrackLoc.cc \
    523         Concurrency/Keywords.cc Concurrency/Waitfor.cc \
    524         Common/SemanticError.cc Common/UniqueName.cc \
    525         Common/DebugMalloc.cc Common/Assert.cc Common/Heap.cc \
    526         Common/Eval.cc ControlStruct/LabelGenerator.cc \
     453        CodeTools/TrackLoc.cc Concurrency/Keywords.cc \
     454        Concurrency/Waitfor.cc Common/SemanticError.cc \
     455        Common/UniqueName.cc Common/DebugMalloc.cc Common/Assert.cc \
     456        Common/Heap.cc Common/Eval.cc ControlStruct/LabelGenerator.cc \
    527457        ControlStruct/LabelFixer.cc ControlStruct/MLEMutator.cc \
    528458        ControlStruct/Mutate.cc ControlStruct/ForExprMutator.cc \
    … …  
    547477        ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
    548478        ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
    549         SymTab/Indexer.cc SymTab/Mangler.cc SymTab/ManglerCommon.cc \
    550         SymTab/Validate.cc SymTab/FixFunction.cc SymTab/Autogen.cc \
    551         SynTree/Type.cc SynTree/VoidType.cc SynTree/BasicType.cc \
     479        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
     480        SymTab/FixFunction.cc SymTab/Autogen.cc SynTree/Type.cc \
     481        SynTree/VoidType.cc SynTree/BasicType.cc \
    552482        SynTree/PointerType.cc SynTree/ArrayType.cc \
    553483        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
    … …  
    581511AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
    582512AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
    583 ARFLAGS = cr
    584 demangler_SOURCES = SymTab/demangler.cc
    585 demangler_LDADD = libdemangle.a     # yywrap
    586 noinst_LIBRARIES = libdemangle.a
    587 libdemangle_a_SOURCES = SymTab/Demangle.cc SymTab/ManglerCommon.cc \
    588   SynTree/Type.cc \
    589   SynTree/VoidType.cc \
    590   SynTree/BasicType.cc \
    591   SynTree/PointerType.cc \
    592   SynTree/ArrayType.cc \
    593   SynTree/ReferenceType.cc \
    594   SynTree/FunctionType.cc \
    595   SynTree/ReferenceToType.cc \
    596   SynTree/TupleType.cc \
    597   SynTree/TypeofType.cc \
    598   SynTree/AttrType.cc \
    599   SynTree/VarArgsType.cc \
    600   SynTree/ZeroOneType.cc \
    601   SynTree/Constant.cc \
    602   SynTree/Expression.cc \
    603   SynTree/TupleExpr.cc \
    604   SynTree/CommaExpr.cc \
    605   SynTree/TypeExpr.cc \
    606   SynTree/ApplicationExpr.cc \
    607   SynTree/AddressExpr.cc \
    608   SynTree/Statement.cc \
    609   SynTree/CompoundStmt.cc \
    610   SynTree/DeclStmt.cc \
    611   SynTree/Declaration.cc \
    612   SynTree/DeclarationWithType.cc \
    613   SynTree/ObjectDecl.cc \
    614   SynTree/FunctionDecl.cc \
    615   SynTree/AggregateDecl.cc \
    616   SynTree/NamedTypeDecl.cc \
    617   SynTree/TypeDecl.cc \
    618   SynTree/Initializer.cc \
    619   SynTree/TypeSubstitution.cc \
    620   SynTree/Attribute.cc \
    621   SynTree/DeclReplacer.cc \
    622   CompilationState.cc \
    623   CodeGen/CodeGenerator.cc \
    624   CodeGen/FixMain.cc \
    625   CodeGen/GenType.cc \
    626   CodeGen/OperatorTable.cc \
    627   Common/Assert.cc \
    628   Common/Eval.cc \
    629   Common/SemanticError.cc \
    630   Common/UniqueName.cc \
    631   Concurrency/Keywords.cc \
    632   ControlStruct/ForExprMutator.cc \
    633   ControlStruct/LabelFixer.cc \
    634   ControlStruct/LabelGenerator.cc \
    635   ControlStruct/MLEMutator.cc \
    636   ControlStruct/Mutate.cc \
    637   GenPoly/GenPoly.cc \
    638   GenPoly/Lvalue.cc \
    639   InitTweak/GenInit.cc \
    640   InitTweak/InitTweak.cc \
    641   Parser/LinkageSpec.cc \
    642   ResolvExpr/AdjustExprType.cc \
    643   ResolvExpr/Alternative.cc \
    644   ResolvExpr/AlternativeFinder.cc \
    645   ResolvExpr/ExplodedActual.cc \
    646   ResolvExpr/CastCost.cc \
    647   ResolvExpr/CommonType.cc \
    648   ResolvExpr/ConversionCost.cc \
    649   ResolvExpr/CurrentObject.cc \
    650   ResolvExpr/FindOpenVars.cc \
    651   ResolvExpr/Occurs.cc \
    652   ResolvExpr/PolyCost.cc \
    653   ResolvExpr/PtrsAssignable.cc \
    654   ResolvExpr/PtrsCastable.cc \
    655   ResolvExpr/RenameVars.cc \
    656   ResolvExpr/Resolver.cc \
    657   ResolvExpr/ResolveTypeof.cc \
    658   ResolvExpr/TypeEnvironment.cc \
    659   ResolvExpr/Unify.cc \
    660   SymTab/Autogen.cc \
    661   SymTab/FixFunction.cc \
    662   SymTab/Indexer.cc \
    663   SymTab/Mangler.cc \
    664   SymTab/Validate.cc \
    665   Tuples/Explode.cc \
    666   Tuples/TupleAssignment.cc \
    667   Tuples/TupleExpansion.cc \
    668   Validate/HandleAttributes.cc
    669 
    670513all: $(BUILT_SOURCES)
    671514        $(MAKE) $(AM_MAKEFLAGS) all-am
    … …  
    703546        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
    704547$(am__aclocal_m4_deps):
    705 
    706 clean-noinstLIBRARIES:
    707         -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
    708 SymTab/$(am__dirstamp):
    709         @$(MKDIR_P) SymTab
    710         @: > SymTab/$(am__dirstamp)
    711 SymTab/$(DEPDIR)/$(am__dirstamp):
    712         @$(MKDIR_P) SymTab/$(DEPDIR)
    713         @: > SymTab/$(DEPDIR)/$(am__dirstamp)
    714 SymTab/Demangle.$(OBJEXT): SymTab/$(am__dirstamp) \
    715         SymTab/$(DEPDIR)/$(am__dirstamp)
    716 SymTab/ManglerCommon.$(OBJEXT): SymTab/$(am__dirstamp) \
    717         SymTab/$(DEPDIR)/$(am__dirstamp)
    718 SynTree/$(am__dirstamp):
    719         @$(MKDIR_P) SynTree
    720         @: > SynTree/$(am__dirstamp)
    721 SynTree/$(DEPDIR)/$(am__dirstamp):
    722         @$(MKDIR_P) SynTree/$(DEPDIR)
    723         @: > SynTree/$(DEPDIR)/$(am__dirstamp)
    724 SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
    725         SynTree/$(DEPDIR)/$(am__dirstamp)
    726 SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
    727         SynTree/$(DEPDIR)/$(am__dirstamp)
    728 SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
    729         SynTree/$(DEPDIR)/$(am__dirstamp)
    730 SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
    731         SynTree/$(DEPDIR)/$(am__dirstamp)
    732 SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
    733         SynTree/$(DEPDIR)/$(am__dirstamp)
    734 SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
    735         SynTree/$(DEPDIR)/$(am__dirstamp)
    736 SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
    737         SynTree/$(DEPDIR)/$(am__dirstamp)
    738 SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
    739         SynTree/$(DEPDIR)/$(am__dirstamp)
    740 SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
    741         SynTree/$(DEPDIR)/$(am__dirstamp)
    742 SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
    743         SynTree/$(DEPDIR)/$(am__dirstamp)
    744 SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
    745         SynTree/$(DEPDIR)/$(am__dirstamp)
    746 SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
    747         SynTree/$(DEPDIR)/$(am__dirstamp)
    748 SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
    749         SynTree/$(DEPDIR)/$(am__dirstamp)
    750 SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
    751         SynTree/$(DEPDIR)/$(am__dirstamp)
    752 SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
    753         SynTree/$(DEPDIR)/$(am__dirstamp)
    754 SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    755         SynTree/$(DEPDIR)/$(am__dirstamp)
    756 SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    757         SynTree/$(DEPDIR)/$(am__dirstamp)
    758 SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    759         SynTree/$(DEPDIR)/$(am__dirstamp)
    760 SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    761         SynTree/$(DEPDIR)/$(am__dirstamp)
    762 SynTree/AddressExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
    763         SynTree/$(DEPDIR)/$(am__dirstamp)
    764 SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
    765         SynTree/$(DEPDIR)/$(am__dirstamp)
    766 SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
    767         SynTree/$(DEPDIR)/$(am__dirstamp)
    768 SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
    769         SynTree/$(DEPDIR)/$(am__dirstamp)
    770 SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
    771         SynTree/$(DEPDIR)/$(am__dirstamp)
    772 SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
    773         SynTree/$(DEPDIR)/$(am__dirstamp)
    774 SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    775         SynTree/$(DEPDIR)/$(am__dirstamp)
    776 SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    777         SynTree/$(DEPDIR)/$(am__dirstamp)
    778 SynTree/AggregateDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    779         SynTree/$(DEPDIR)/$(am__dirstamp)
    780 SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    781         SynTree/$(DEPDIR)/$(am__dirstamp)
    782 SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
    783         SynTree/$(DEPDIR)/$(am__dirstamp)
    784 SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
    785         SynTree/$(DEPDIR)/$(am__dirstamp)
    786 SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
    787         SynTree/$(DEPDIR)/$(am__dirstamp)
    788 SynTree/Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
    789         SynTree/$(DEPDIR)/$(am__dirstamp)
    790 SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
    791         SynTree/$(DEPDIR)/$(am__dirstamp)
    792 CodeGen/$(am__dirstamp):
    793         @$(MKDIR_P) CodeGen
    794         @: > CodeGen/$(am__dirstamp)
    795 CodeGen/$(DEPDIR)/$(am__dirstamp):
    796         @$(MKDIR_P) CodeGen/$(DEPDIR)
    797         @: > CodeGen/$(DEPDIR)/$(am__dirstamp)
    798 CodeGen/CodeGenerator.$(OBJEXT): CodeGen/$(am__dirstamp) \
    799         CodeGen/$(DEPDIR)/$(am__dirstamp)
    800 CodeGen/FixMain.$(OBJEXT): CodeGen/$(am__dirstamp) \
    801         CodeGen/$(DEPDIR)/$(am__dirstamp)
    802 CodeGen/GenType.$(OBJEXT): CodeGen/$(am__dirstamp) \
    803         CodeGen/$(DEPDIR)/$(am__dirstamp)
    804 CodeGen/OperatorTable.$(OBJEXT): CodeGen/$(am__dirstamp) \
    805         CodeGen/$(DEPDIR)/$(am__dirstamp)
    806 Common/$(am__dirstamp):
    807         @$(MKDIR_P) Common
    808         @: > Common/$(am__dirstamp)
    809 Common/$(DEPDIR)/$(am__dirstamp):
    810         @$(MKDIR_P) Common/$(DEPDIR)
    811         @: > Common/$(DEPDIR)/$(am__dirstamp)
    812 Common/Assert.$(OBJEXT): Common/$(am__dirstamp) \
    813         Common/$(DEPDIR)/$(am__dirstamp)
    814 Common/Eval.$(OBJEXT): Common/$(am__dirstamp) \
    815         Common/$(DEPDIR)/$(am__dirstamp)
    816 Common/SemanticError.$(OBJEXT): Common/$(am__dirstamp) \
    817         Common/$(DEPDIR)/$(am__dirstamp)
    818 Common/UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
    819         Common/$(DEPDIR)/$(am__dirstamp)
    820 Concurrency/$(am__dirstamp):
    821         @$(MKDIR_P) Concurrency
    822         @: > Concurrency/$(am__dirstamp)
    823 Concurrency/$(DEPDIR)/$(am__dirstamp):
    824         @$(MKDIR_P) Concurrency/$(DEPDIR)
    825         @: > Concurrency/$(DEPDIR)/$(am__dirstamp)
    826 Concurrency/Keywords.$(OBJEXT): Concurrency/$(am__dirstamp) \
    827         Concurrency/$(DEPDIR)/$(am__dirstamp)
    828 ControlStruct/$(am__dirstamp):
    829         @$(MKDIR_P) ControlStruct
    830         @: > ControlStruct/$(am__dirstamp)
    831 ControlStruct/$(DEPDIR)/$(am__dirstamp):
    832         @$(MKDIR_P) ControlStruct/$(DEPDIR)
    833         @: > ControlStruct/$(DEPDIR)/$(am__dirstamp)
    834 ControlStruct/ForExprMutator.$(OBJEXT): ControlStruct/$(am__dirstamp) \
    835         ControlStruct/$(DEPDIR)/$(am__dirstamp)
    836 ControlStruct/LabelFixer.$(OBJEXT): ControlStruct/$(am__dirstamp) \
    837         ControlStruct/$(DEPDIR)/$(am__dirstamp)
    838 ControlStruct/LabelGenerator.$(OBJEXT): ControlStruct/$(am__dirstamp) \
    839         ControlStruct/$(DEPDIR)/$(am__dirstamp)
    840 ControlStruct/MLEMutator.$(OBJEXT): ControlStruct/$(am__dirstamp) \
    841         ControlStruct/$(DEPDIR)/$(am__dirstamp)
    842 ControlStruct/Mutate.$(OBJEXT): ControlStruct/$(am__dirstamp) \
    843         ControlStruct/$(DEPDIR)/$(am__dirstamp)
    844 GenPoly/$(am__dirstamp):
    845         @$(MKDIR_P) GenPoly
    846         @: > GenPoly/$(am__dirstamp)
    847 GenPoly/$(DEPDIR)/$(am__dirstamp):
    848         @$(MKDIR_P) GenPoly/$(DEPDIR)
    849         @: > GenPoly/$(DEPDIR)/$(am__dirstamp)
    850 GenPoly/GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \
    851         GenPoly/$(DEPDIR)/$(am__dirstamp)
    852 GenPoly/Lvalue.$(OBJEXT): GenPoly/$(am__dirstamp) \
    853         GenPoly/$(DEPDIR)/$(am__dirstamp)
    854 InitTweak/$(am__dirstamp):
    855         @$(MKDIR_P) InitTweak
    856         @: > InitTweak/$(am__dirstamp)
    857 InitTweak/$(DEPDIR)/$(am__dirstamp):
    858         @$(MKDIR_P) InitTweak/$(DEPDIR)
    859         @: > InitTweak/$(DEPDIR)/$(am__dirstamp)
    860 InitTweak/GenInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
    861         InitTweak/$(DEPDIR)/$(am__dirstamp)
    862 InitTweak/InitTweak.$(OBJEXT): InitTweak/$(am__dirstamp) \
    863         InitTweak/$(DEPDIR)/$(am__dirstamp)
    864 Parser/$(am__dirstamp):
    865         @$(MKDIR_P) Parser
    866         @: > Parser/$(am__dirstamp)
    867 Parser/$(DEPDIR)/$(am__dirstamp):
    868         @$(MKDIR_P) Parser/$(DEPDIR)
    869         @: > Parser/$(DEPDIR)/$(am__dirstamp)
    870 Parser/LinkageSpec.$(OBJEXT): Parser/$(am__dirstamp) \
    871         Parser/$(DEPDIR)/$(am__dirstamp)
    872 ResolvExpr/$(am__dirstamp):
    873         @$(MKDIR_P) ResolvExpr
    874         @: > ResolvExpr/$(am__dirstamp)
    875 ResolvExpr/$(DEPDIR)/$(am__dirstamp):
    876         @$(MKDIR_P) ResolvExpr/$(DEPDIR)
    877         @: > ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    878 ResolvExpr/AdjustExprType.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    879         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    880 ResolvExpr/Alternative.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    881         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    882 ResolvExpr/AlternativeFinder.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    883         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    884 ResolvExpr/ExplodedActual.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    885         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    886 ResolvExpr/CastCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    887         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    888 ResolvExpr/CommonType.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    889         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    890 ResolvExpr/ConversionCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    891         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    892 ResolvExpr/CurrentObject.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    893         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    894 ResolvExpr/FindOpenVars.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    895         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    896 ResolvExpr/Occurs.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    897         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    898 ResolvExpr/PolyCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    899         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    900 ResolvExpr/PtrsAssignable.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    901         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    902 ResolvExpr/PtrsCastable.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    903         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    904 ResolvExpr/RenameVars.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    905         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    906 ResolvExpr/Resolver.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    907         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    908 ResolvExpr/ResolveTypeof.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    909         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    910 ResolvExpr/TypeEnvironment.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    911         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    912 ResolvExpr/Unify.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    913         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    914 SymTab/Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
    915         SymTab/$(DEPDIR)/$(am__dirstamp)
    916 SymTab/FixFunction.$(OBJEXT): SymTab/$(am__dirstamp) \
    917         SymTab/$(DEPDIR)/$(am__dirstamp)
    918 SymTab/Indexer.$(OBJEXT): SymTab/$(am__dirstamp) \
    919         SymTab/$(DEPDIR)/$(am__dirstamp)
    920 SymTab/Mangler.$(OBJEXT): SymTab/$(am__dirstamp) \
    921         SymTab/$(DEPDIR)/$(am__dirstamp)
    922 SymTab/Validate.$(OBJEXT): SymTab/$(am__dirstamp) \
    923         SymTab/$(DEPDIR)/$(am__dirstamp)
    924 Tuples/$(am__dirstamp):
    925         @$(MKDIR_P) Tuples
    926         @: > Tuples/$(am__dirstamp)
    927 Tuples/$(DEPDIR)/$(am__dirstamp):
    928         @$(MKDIR_P) Tuples/$(DEPDIR)
    929         @: > Tuples/$(DEPDIR)/$(am__dirstamp)
    930 Tuples/Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
    931         Tuples/$(DEPDIR)/$(am__dirstamp)
    932 Tuples/TupleAssignment.$(OBJEXT): Tuples/$(am__dirstamp) \
    933         Tuples/$(DEPDIR)/$(am__dirstamp)
    934 Tuples/TupleExpansion.$(OBJEXT): Tuples/$(am__dirstamp) \
    935         Tuples/$(DEPDIR)/$(am__dirstamp)
    936 Validate/$(am__dirstamp):
    937         @$(MKDIR_P) Validate
    938         @: > Validate/$(am__dirstamp)
    939 Validate/$(DEPDIR)/$(am__dirstamp):
    940         @$(MKDIR_P) Validate/$(DEPDIR)
    941         @: > Validate/$(DEPDIR)/$(am__dirstamp)
    942 Validate/HandleAttributes.$(OBJEXT): Validate/$(am__dirstamp) \
    943         Validate/$(DEPDIR)/$(am__dirstamp)
    944 
    945 libdemangle.a: $(libdemangle_a_OBJECTS) $(libdemangle_a_DEPENDENCIES) $(EXTRA_libdemangle_a_DEPENDENCIES)
    946         $(AM_V_at)-rm -f libdemangle.a
    947         $(AM_V_AR)$(libdemangle_a_AR) libdemangle.a $(libdemangle_a_OBJECTS) $(libdemangle_a_LIBADD)
    948         $(AM_V_at)$(RANLIB) libdemangle.a
    949548install-cfa_cpplibPROGRAMS: $(cfa_cpplib_PROGRAMS)
    950549        @$(NORMAL_INSTALL)
    … …  
    989588clean-cfa_cpplibPROGRAMS:
    990589        -test -z "$(cfa_cpplib_PROGRAMS)" || rm -f $(cfa_cpplib_PROGRAMS)
     590CodeGen/$(am__dirstamp):
     591        @$(MKDIR_P) CodeGen
     592        @: > CodeGen/$(am__dirstamp)
     593CodeGen/$(DEPDIR)/$(am__dirstamp):
     594        @$(MKDIR_P) CodeGen/$(DEPDIR)
     595        @: > CodeGen/$(DEPDIR)/$(am__dirstamp)
    991596CodeGen/Generate.$(OBJEXT): CodeGen/$(am__dirstamp) \
    992597        CodeGen/$(DEPDIR)/$(am__dirstamp)
     598CodeGen/CodeGenerator.$(OBJEXT): CodeGen/$(am__dirstamp) \
     599        CodeGen/$(DEPDIR)/$(am__dirstamp)
     600CodeGen/GenType.$(OBJEXT): CodeGen/$(am__dirstamp) \
     601        CodeGen/$(DEPDIR)/$(am__dirstamp)
    993602CodeGen/FixNames.$(OBJEXT): CodeGen/$(am__dirstamp) \
     603        CodeGen/$(DEPDIR)/$(am__dirstamp)
     604CodeGen/FixMain.$(OBJEXT): CodeGen/$(am__dirstamp) \
     605        CodeGen/$(DEPDIR)/$(am__dirstamp)
     606CodeGen/OperatorTable.$(OBJEXT): CodeGen/$(am__dirstamp) \
    994607        CodeGen/$(DEPDIR)/$(am__dirstamp)
    995608CodeTools/$(am__dirstamp):
    … …  
    1001614CodeTools/DeclStats.$(OBJEXT): CodeTools/$(am__dirstamp) \
    1002615        CodeTools/$(DEPDIR)/$(am__dirstamp)
    1003 CodeTools/ResolvProtoDump.$(OBJEXT): CodeTools/$(am__dirstamp) \
    1004         CodeTools/$(DEPDIR)/$(am__dirstamp)
    1005616CodeTools/TrackLoc.$(OBJEXT): CodeTools/$(am__dirstamp) \
    1006617        CodeTools/$(DEPDIR)/$(am__dirstamp)
     618Concurrency/$(am__dirstamp):
     619        @$(MKDIR_P) Concurrency
     620        @: > Concurrency/$(am__dirstamp)
     621Concurrency/$(DEPDIR)/$(am__dirstamp):
     622        @$(MKDIR_P) Concurrency/$(DEPDIR)
     623        @: > Concurrency/$(DEPDIR)/$(am__dirstamp)
     624Concurrency/Keywords.$(OBJEXT): Concurrency/$(am__dirstamp) \
     625        Concurrency/$(DEPDIR)/$(am__dirstamp)
    1007626Concurrency/Waitfor.$(OBJEXT): Concurrency/$(am__dirstamp) \
    1008627        Concurrency/$(DEPDIR)/$(am__dirstamp)
     628Common/$(am__dirstamp):
     629        @$(MKDIR_P) Common
     630        @: > Common/$(am__dirstamp)
     631Common/$(DEPDIR)/$(am__dirstamp):
     632        @$(MKDIR_P) Common/$(DEPDIR)
     633        @: > Common/$(DEPDIR)/$(am__dirstamp)
     634Common/SemanticError.$(OBJEXT): Common/$(am__dirstamp) \
     635        Common/$(DEPDIR)/$(am__dirstamp)
     636Common/UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
     637        Common/$(DEPDIR)/$(am__dirstamp)
    1009638Common/DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
     639        Common/$(DEPDIR)/$(am__dirstamp)
     640Common/Assert.$(OBJEXT): Common/$(am__dirstamp) \
    1010641        Common/$(DEPDIR)/$(am__dirstamp)
    1011642Common/Heap.$(OBJEXT): Common/$(am__dirstamp) \
    1012643        Common/$(DEPDIR)/$(am__dirstamp)
     644Common/Eval.$(OBJEXT): Common/$(am__dirstamp) \
     645        Common/$(DEPDIR)/$(am__dirstamp)
     646ControlStruct/$(am__dirstamp):
     647        @$(MKDIR_P) ControlStruct
     648        @: > ControlStruct/$(am__dirstamp)
     649ControlStruct/$(DEPDIR)/$(am__dirstamp):
     650        @$(MKDIR_P) ControlStruct/$(DEPDIR)
     651        @: > ControlStruct/$(DEPDIR)/$(am__dirstamp)
     652ControlStruct/LabelGenerator.$(OBJEXT): ControlStruct/$(am__dirstamp) \
     653        ControlStruct/$(DEPDIR)/$(am__dirstamp)
     654ControlStruct/LabelFixer.$(OBJEXT): ControlStruct/$(am__dirstamp) \
     655        ControlStruct/$(DEPDIR)/$(am__dirstamp)
     656ControlStruct/MLEMutator.$(OBJEXT): ControlStruct/$(am__dirstamp) \
     657        ControlStruct/$(DEPDIR)/$(am__dirstamp)
     658ControlStruct/Mutate.$(OBJEXT): ControlStruct/$(am__dirstamp) \
     659        ControlStruct/$(DEPDIR)/$(am__dirstamp)
     660ControlStruct/ForExprMutator.$(OBJEXT): ControlStruct/$(am__dirstamp) \
     661        ControlStruct/$(DEPDIR)/$(am__dirstamp)
    1013662ControlStruct/ExceptTranslate.$(OBJEXT):  \
    1014663        ControlStruct/$(am__dirstamp) \
    1015664        ControlStruct/$(DEPDIR)/$(am__dirstamp)
     665GenPoly/$(am__dirstamp):
     666        @$(MKDIR_P) GenPoly
     667        @: > GenPoly/$(am__dirstamp)
     668GenPoly/$(DEPDIR)/$(am__dirstamp):
     669        @$(MKDIR_P) GenPoly/$(DEPDIR)
     670        @: > GenPoly/$(DEPDIR)/$(am__dirstamp)
    1016671GenPoly/Box.$(OBJEXT): GenPoly/$(am__dirstamp) \
    1017672        GenPoly/$(DEPDIR)/$(am__dirstamp)
     673GenPoly/GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \
     674        GenPoly/$(DEPDIR)/$(am__dirstamp)
    1018675GenPoly/ScrubTyVars.$(OBJEXT): GenPoly/$(am__dirstamp) \
     676        GenPoly/$(DEPDIR)/$(am__dirstamp)
     677GenPoly/Lvalue.$(OBJEXT): GenPoly/$(am__dirstamp) \
    1019678        GenPoly/$(DEPDIR)/$(am__dirstamp)
    1020679GenPoly/Specialize.$(OBJEXT): GenPoly/$(am__dirstamp) \
    … …  
    1024683GenPoly/InstantiateGeneric.$(OBJEXT): GenPoly/$(am__dirstamp) \
    1025684        GenPoly/$(DEPDIR)/$(am__dirstamp)
     685InitTweak/$(am__dirstamp):
     686        @$(MKDIR_P) InitTweak
     687        @: > InitTweak/$(am__dirstamp)
     688InitTweak/$(DEPDIR)/$(am__dirstamp):
     689        @$(MKDIR_P) InitTweak/$(DEPDIR)
     690        @: > InitTweak/$(DEPDIR)/$(am__dirstamp)
     691InitTweak/GenInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
     692        InitTweak/$(DEPDIR)/$(am__dirstamp)
    1026693InitTweak/FixInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
    1027694        InitTweak/$(DEPDIR)/$(am__dirstamp)
    1028695InitTweak/FixGlobalInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
    1029696        InitTweak/$(DEPDIR)/$(am__dirstamp)
     697InitTweak/InitTweak.$(OBJEXT): InitTweak/$(am__dirstamp) \
     698        InitTweak/$(DEPDIR)/$(am__dirstamp)
    1030699Parser/parser.hh: Parser/parser.cc
    1031700        @if test ! -f $@; then rm -f Parser/parser.cc; else :; fi
    1032701        @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) Parser/parser.cc; else :; fi
     702Parser/$(am__dirstamp):
     703        @$(MKDIR_P) Parser
     704        @: > Parser/$(am__dirstamp)
     705Parser/$(DEPDIR)/$(am__dirstamp):
     706        @$(MKDIR_P) Parser/$(DEPDIR)
     707        @: > Parser/$(DEPDIR)/$(am__dirstamp)
    1033708Parser/parser.$(OBJEXT): Parser/$(am__dirstamp) \
    1034709        Parser/$(DEPDIR)/$(am__dirstamp)
    … …  
    1049724Parser/TypeData.$(OBJEXT): Parser/$(am__dirstamp) \
    1050725        Parser/$(DEPDIR)/$(am__dirstamp)
     726Parser/LinkageSpec.$(OBJEXT): Parser/$(am__dirstamp) \
     727        Parser/$(DEPDIR)/$(am__dirstamp)
    1051728Parser/parserutility.$(OBJEXT): Parser/$(am__dirstamp) \
    1052729        Parser/$(DEPDIR)/$(am__dirstamp)
     730ResolvExpr/$(am__dirstamp):
     731        @$(MKDIR_P) ResolvExpr
     732        @: > ResolvExpr/$(am__dirstamp)
     733ResolvExpr/$(DEPDIR)/$(am__dirstamp):
     734        @$(MKDIR_P) ResolvExpr/$(DEPDIR)
     735        @: > ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     736ResolvExpr/AlternativeFinder.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     737        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     738ResolvExpr/Alternative.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     739        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     740ResolvExpr/Unify.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     741        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     742ResolvExpr/PtrsAssignable.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     743        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     744ResolvExpr/CommonType.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     745        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     746ResolvExpr/ConversionCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     747        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     748ResolvExpr/CastCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     749        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     750ResolvExpr/PtrsCastable.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     751        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     752ResolvExpr/AdjustExprType.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     753        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    1053754ResolvExpr/AlternativePrinter.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
    1054755        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     756ResolvExpr/Resolver.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     757        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     758ResolvExpr/ResolveTypeof.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     759        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     760ResolvExpr/RenameVars.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     761        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     762ResolvExpr/FindOpenVars.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     763        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     764ResolvExpr/PolyCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     765        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     766ResolvExpr/Occurs.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     767        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     768ResolvExpr/TypeEnvironment.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     769        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     770ResolvExpr/CurrentObject.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     771        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     772ResolvExpr/ExplodedActual.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
     773        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     774SymTab/$(am__dirstamp):
     775        @$(MKDIR_P) SymTab
     776        @: > SymTab/$(am__dirstamp)
     777SymTab/$(DEPDIR)/$(am__dirstamp):
     778        @$(MKDIR_P) SymTab/$(DEPDIR)
     779        @: > SymTab/$(DEPDIR)/$(am__dirstamp)
     780SymTab/Indexer.$(OBJEXT): SymTab/$(am__dirstamp) \
     781        SymTab/$(DEPDIR)/$(am__dirstamp)
     782SymTab/Mangler.$(OBJEXT): SymTab/$(am__dirstamp) \
     783        SymTab/$(DEPDIR)/$(am__dirstamp)
     784SymTab/Validate.$(OBJEXT): SymTab/$(am__dirstamp) \
     785        SymTab/$(DEPDIR)/$(am__dirstamp)
     786SymTab/FixFunction.$(OBJEXT): SymTab/$(am__dirstamp) \
     787        SymTab/$(DEPDIR)/$(am__dirstamp)
     788SymTab/Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
     789        SymTab/$(DEPDIR)/$(am__dirstamp)
     790SynTree/$(am__dirstamp):
     791        @$(MKDIR_P) SynTree
     792        @: > SynTree/$(am__dirstamp)
     793SynTree/$(DEPDIR)/$(am__dirstamp):
     794        @$(MKDIR_P) SynTree/$(DEPDIR)
     795        @: > SynTree/$(DEPDIR)/$(am__dirstamp)
     796SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
     797        SynTree/$(DEPDIR)/$(am__dirstamp)
     798SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
     799        SynTree/$(DEPDIR)/$(am__dirstamp)
     800SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
     801        SynTree/$(DEPDIR)/$(am__dirstamp)
     802SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
     803        SynTree/$(DEPDIR)/$(am__dirstamp)
     804SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
     805        SynTree/$(DEPDIR)/$(am__dirstamp)
     806SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
     807        SynTree/$(DEPDIR)/$(am__dirstamp)
     808SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
     809        SynTree/$(DEPDIR)/$(am__dirstamp)
     810SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
     811        SynTree/$(DEPDIR)/$(am__dirstamp)
     812SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
     813        SynTree/$(DEPDIR)/$(am__dirstamp)
     814SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
     815        SynTree/$(DEPDIR)/$(am__dirstamp)
     816SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
     817        SynTree/$(DEPDIR)/$(am__dirstamp)
     818SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
     819        SynTree/$(DEPDIR)/$(am__dirstamp)
     820SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
     821        SynTree/$(DEPDIR)/$(am__dirstamp)
     822SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
     823        SynTree/$(DEPDIR)/$(am__dirstamp)
     824SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
     825        SynTree/$(DEPDIR)/$(am__dirstamp)
     826SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     827        SynTree/$(DEPDIR)/$(am__dirstamp)
     828SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     829        SynTree/$(DEPDIR)/$(am__dirstamp)
     830SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     831        SynTree/$(DEPDIR)/$(am__dirstamp)
     832SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     833        SynTree/$(DEPDIR)/$(am__dirstamp)
     834SynTree/AddressExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
     835        SynTree/$(DEPDIR)/$(am__dirstamp)
     836SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
     837        SynTree/$(DEPDIR)/$(am__dirstamp)
     838SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
     839        SynTree/$(DEPDIR)/$(am__dirstamp)
     840SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
     841        SynTree/$(DEPDIR)/$(am__dirstamp)
     842SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
     843        SynTree/$(DEPDIR)/$(am__dirstamp)
     844SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
     845        SynTree/$(DEPDIR)/$(am__dirstamp)
     846SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     847        SynTree/$(DEPDIR)/$(am__dirstamp)
     848SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     849        SynTree/$(DEPDIR)/$(am__dirstamp)
     850SynTree/AggregateDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     851        SynTree/$(DEPDIR)/$(am__dirstamp)
     852SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     853        SynTree/$(DEPDIR)/$(am__dirstamp)
     854SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
     855        SynTree/$(DEPDIR)/$(am__dirstamp)
     856SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
     857        SynTree/$(DEPDIR)/$(am__dirstamp)
     858SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
     859        SynTree/$(DEPDIR)/$(am__dirstamp)
     860SynTree/Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
     861        SynTree/$(DEPDIR)/$(am__dirstamp)
     862SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
     863        SynTree/$(DEPDIR)/$(am__dirstamp)
     864Tuples/$(am__dirstamp):
     865        @$(MKDIR_P) Tuples
     866        @: > Tuples/$(am__dirstamp)
     867Tuples/$(DEPDIR)/$(am__dirstamp):
     868        @$(MKDIR_P) Tuples/$(DEPDIR)
     869        @: > Tuples/$(DEPDIR)/$(am__dirstamp)
     870Tuples/TupleAssignment.$(OBJEXT): Tuples/$(am__dirstamp) \
     871        Tuples/$(DEPDIR)/$(am__dirstamp)
     872Tuples/TupleExpansion.$(OBJEXT): Tuples/$(am__dirstamp) \
     873        Tuples/$(DEPDIR)/$(am__dirstamp)
     874Tuples/Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
     875        Tuples/$(DEPDIR)/$(am__dirstamp)
     876Validate/$(am__dirstamp):
     877        @$(MKDIR_P) Validate
     878        @: > Validate/$(am__dirstamp)
     879Validate/$(DEPDIR)/$(am__dirstamp):
     880        @$(MKDIR_P) Validate/$(DEPDIR)
     881        @: > Validate/$(DEPDIR)/$(am__dirstamp)
     882Validate/HandleAttributes.$(OBJEXT): Validate/$(am__dirstamp) \
     883        Validate/$(DEPDIR)/$(am__dirstamp)
    1055884Virtual/$(am__dirstamp):
    1056885        @$(MKDIR_P) Virtual
    … …  
    1068897        @rm -f ../driver/cfa-cpp$(EXEEXT)
    1069898        $(AM_V_CXXLD)$(CXXLINK) $(___driver_cfa_cpp_OBJECTS) $(___driver_cfa_cpp_LDADD) $(LIBS)
    1070 SymTab/demangler.$(OBJEXT): SymTab/$(am__dirstamp) \
    1071         SymTab/$(DEPDIR)/$(am__dirstamp)
    1072 
    1073 demangler$(EXEEXT): $(demangler_OBJECTS) $(demangler_DEPENDENCIES) $(EXTRA_demangler_DEPENDENCIES)
    1074         @rm -f demangler$(EXEEXT)
    1075         $(AM_V_CXXLD)$(CXXLINK) $(demangler_OBJECTS) $(demangler_LDADD) $(LIBS)
    1076899
    1077900mostlyclean-compile:
    … …  
    1105928@AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/OperatorTable.Po@am__quote@
    1106929@AMDEP_TRUE@@am__include@ @am__quote@CodeTools/$(DEPDIR)/DeclStats.Po@am__quote@
    1107 @AMDEP_TRUE@@am__include@ @am__quote@CodeTools/$(DEPDIR)/ResolvProtoDump.Po@am__quote@
    1108930@AMDEP_TRUE@@am__include@ @am__quote@CodeTools/$(DEPDIR)/TrackLoc.Po@am__quote@
    1109931@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/Assert.Po@am__quote@
    … …  
    1163985@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/Unify.Po@am__quote@
    1164986@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/Autogen.Po@am__quote@
    1165 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/Demangle.Po@am__quote@
    1166987@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/FixFunction.Po@am__quote@
    1167988@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/Indexer.Po@am__quote@
    1168989@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/Mangler.Po@am__quote@
    1169 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/ManglerCommon.Po@am__quote@
    1170990@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/Validate.Po@am__quote@
    1171 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/demangler.Po@am__quote@
    1172991@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/AddressExpr.Po@am__quote@
    1173992@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/AggregateDecl.Po@am__quote@
    … …  
    13171136check: $(BUILT_SOURCES)
    13181137        $(MAKE) $(AM_MAKEFLAGS) check-am
    1319 all-am: Makefile $(LIBRARIES) $(PROGRAMS)
     1138all-am: Makefile $(PROGRAMS)
    13201139installdirs:
    13211140        for dir in "$(DESTDIR)$(cfa_cpplibdir)"; do \
    … …  
    13901209clean: clean-am
    13911210
    1392 clean-am: clean-cfa_cpplibPROGRAMS clean-generic clean-noinstLIBRARIES \
    1393         mostlyclean-am
     1211clean-am: clean-cfa_cpplibPROGRAMS clean-generic mostlyclean-am
    13941212
    13951213distclean: distclean-am
    … …  
    14611279
    14621280.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
    1463         clean-cfa_cpplibPROGRAMS clean-generic clean-noinstLIBRARIES \
    1464         cscopelist-am ctags ctags-am distclean distclean-compile \
    1465         distclean-generic distclean-tags distdir dvi dvi-am html \
    1466         html-am info info-am install install-am \
    1467         install-cfa_cpplibPROGRAMS install-data install-data-am \
    1468         install-dvi install-dvi-am install-exec install-exec-am \
    1469         install-html install-html-am install-info install-info-am \
    1470         install-man install-pdf install-pdf-am install-ps \
    1471         install-ps-am install-strip installcheck installcheck-am \
    1472         installdirs maintainer-clean maintainer-clean-generic \
    1473         mostlyclean mostlyclean-compile mostlyclean-generic pdf pdf-am \
    1474         ps ps-am tags tags-am uninstall uninstall-am \
    1475         uninstall-cfa_cpplibPROGRAMS
     1281        clean-cfa_cpplibPROGRAMS clean-generic cscopelist-am ctags \
     1282        ctags-am distclean distclean-compile distclean-generic \
     1283        distclean-tags distdir dvi dvi-am html html-am info info-am \
     1284        install install-am install-cfa_cpplibPROGRAMS install-data \
     1285        install-data-am install-dvi install-dvi-am install-exec \
     1286        install-exec-am install-html install-html-am install-info \
     1287        install-info-am install-man install-pdf install-pdf-am \
     1288        install-ps install-ps-am install-strip installcheck \
     1289        installcheck-am installdirs maintainer-clean \
     1290        maintainer-clean-generic mostlyclean mostlyclean-compile \
     1291        mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
     1292        uninstall-am uninstall-cfa_cpplibPROGRAMS
    14761293
    14771294.PRECIOUS: Makefile

  • src/Parser/LinkageSpec.cc

    r6d44da1 r341bb80  
    1010// Created On       : Sat May 16 13:22:09 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Spt 12 15:59:00 2018
    13 // Update Count     : 26
     12// Last Modified On : Fri Jul  7 11:11:00 2017
     13// Update Count     : 25
    1414//
    1515
    … …  
    2323
    2424namespace LinkageSpec {
     25
     26Spec linkageCheck( CodeLocation location, const string * spec ) {
     27        assert( spec );
     28        unique_ptr<const string> guard( spec ); // allocated by lexer
     29        if ( *spec == "\"Cforall\"" ) {
     30                return Cforall;
     31        } else if ( *spec == "\"C\"" ) {
     32                return C;
     33        } else if ( *spec == "\"BuiltinC\"" ) {
     34                return BuiltinC;
     35        } else {
     36                SemanticError( location, "Invalid linkage specifier " + *spec );
     37        } // if
     38}
    2539
    2640Spec linkageUpdate( CodeLocation location, Spec old_spec, const string * cmd ) {

  • src/Parser/LinkageSpec.h

    r6d44da1 r341bb80  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Sat May 16 13:24:28 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Spt 13 15:59:00 2018
    13 // Update Count     : 17
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jul  2 07:46:49 2018
     13// Update Count     : 16
    1414//
    1515
    … …  
    4141
    4242
     43        Spec linkageCheck( CodeLocation location, const std::string * );
     44        // Returns the Spec with the given name (limited to C, Cforall & BuiltinC)
    4345        Spec linkageUpdate( CodeLocation location, Spec old_spec, const std::string * cmd );
    4446        /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false

  • src/Parser/lex.ll

    r6d44da1 r341bb80  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Aug 29 15:02:41 2018
    13  * Update Count     : 686
     12 * Last Modified On : Wed Aug  8 17:23:17 2018
     13 * Update Count     : 685
    1414 */
    1515
    … …  
    410410">>="                   { NAMEDOP_RETURN(RSassign); }
    411411
     412"~="                    { NAMEDOP_RETURN(Erange); }                             // CFA
    412413"@="                    { NAMEDOP_RETURN(ATassign); }                   // CFA
    413 "~="                    { NAMEDOP_RETURN(ErangeUpEq); }                 // CFA
    414 "-~"                    { NAMEDOP_RETURN(ErangeDown); }                 // CFA
    415 "-~="                   { NAMEDOP_RETURN(ErangeDownEq); }               // CFA
    416414
    417415                                /* CFA, operator identifier */

  • src/Parser/parser.yy

    r6d44da1 r341bb80  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 30 17:02:25 2018
    13 // Update Count     : 4029
     12// Last Modified On : Wed Aug  8 17:50:07 2018
     13// Update Count     : 3998
    1414//
    1515
    … …  
    186186} // fieldDecl
    187187
    188 ExpressionNode *forInc( const OperKinds op ) {
    189         return new ExpressionNode( build_constantInteger( *new string( op == OperKinds::LThan || op == OperKinds::LEThan ? "1" : "-1" ) ) );
    190 } // forInc
    191 
    192188ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
    193         ConstantExpr *constant = dynamic_cast<ConstantExpr *>(type->get_expr());
    194         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
    195         type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
    196         } // if
    197189        return new ForCtrl(
    198190                distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
    … …  
    222214
    223215// Types declaration for productions
    224 %union {
     216%union
     217{
    225218        Token tok;
    226219        ParseNode * pn;
    … …  
    297290%token ANDassign        ERassign        ORassign                                // &=   ^=      |=
    298291
    299 %token ErangeUpEq       ErangeDown      ErangeDownEq                    // ~=   -~      -~=
     292%token Erange                                                                                   // ~=
    300293%token ATassign                                                                                 // @=
    301294
    … …  
    11451138                                $$ = new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr );
    11461139                        } else {
    1147                                 $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1148                                                           OperKinds::LThan, $1->clone(), forInc( OperKinds::LThan ) );
     1140                                $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $1->clone(),
     1141                                                         new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
    11491142                        } // if
    11501143                }
    11511144        | constant_expression inclexcl constant_expression      // CFA
    1152                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, forInc( $2 ) ); }
     1145                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
    11531146        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
    11541147                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
    … …  
    11611154                        } else {
    11621155                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
    1163                                         $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
    1164                                                                   OperKinds::LThan, $3->clone(), forInc( OperKinds::LThan ) );
     1156                                        $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $3->clone(),
     1157                                                                 new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
    11651158                                } else {
    11661159                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
    … …  
    11741167                        } else {
    11751168                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
    1176                                         $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, forInc( $4 ) );
     1169                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
    11771170                                } else {
    11781171                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
    … …  
    12011194        '~'
    12021195                { $$ = OperKinds::LThan; }
    1203         | ErangeUpEq
     1196        | Erange
    12041197                { $$ = OperKinds::LEThan; }
    1205         | ErangeDown
    1206                 { $$ = OperKinds::GThan; }
    1207         | ErangeDownEq
    1208                 { $$ = OperKinds::GEThan; }
    12091198        ;
    12101199

  • src/ResolvExpr/AlternativeFinder.cc

    r6d44da1 r341bb80  
    2525#include <vector>                  // for vector
    2626
    27 #include "CompilationState.h"      // for resolvep
    2827#include "Alternative.h"           // for AltList, Alternative
    2928#include "AlternativeFinder.h"
    … …  
    5049#include "typeops.h"               // for adjustExprType, polyCost, castCost
    5150
     51extern bool resolvep;
    5252#define PRINT( text ) if ( resolvep ) { text }
    5353//#define DEBUG_COST

  • src/ResolvExpr/Resolver.cc

    r6d44da1 r341bb80  
    3030#include "RenameVars.h"                  // for RenameVars, global_renamer
    3131#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
     32#include "ResolveTypeof.h"               // for resolveTypeof
    3233#include "Resolver.h"
    3334#include "SymTab/Autogen.h"              // for SizeType
    … …  
    5657                void postvisit( FunctionDecl *functionDecl );
    5758                void previsit( ObjectDecl *objectDecll );
     59                void previsit( TypeDecl *typeDecl );
    5860                void previsit( EnumDecl * enumDecl );
    5961                void previsit( StaticAssertDecl * assertDecl );
    … …  
    7577                void previsit( CatchStmt *catchStmt );
    7678                void previsit( WaitForStmt * stmt );
     79                void previsit( WithStmt * withStmt );
    7780
    7881                void previsit( SingleInit *singleInit );
    … …  
    8588                void handlePtrType( PtrType * type );
    8689
     90                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
    8791                void fallbackInit( ConstructorInit * ctorInit );
    8892
    … …  
    9094                CurrentObject currentObject = nullptr;
    9195                bool inEnumDecl = false;
    92         };
    93 
    94         struct ResolveWithExprs : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveWithExprs>, public WithShortCircuiting, public WithStmtsToAdd {
    95                 void previsit( FunctionDecl * );
    96                 void previsit( WithStmt * );
    97 
    98                 void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
    9996        };
    10097
    … …  
    305302        }
    306303
    307 
    308         bool isStructOrUnion( const Alternative & alt ) {
    309                 Type * t = alt.expr->result->stripReferences();
    310                 return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
    311         }
    312 
    313         void resolveWithExprs( std::list< Declaration * > & translationUnit ) {
    314                 PassVisitor<ResolveWithExprs> resolver;
    315                 acceptAll( translationUnit, resolver );
    316         }
    317 
    318         void ResolveWithExprs::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
    319                 for ( Expression *& expr : withExprs )  {
    320                         // only struct- and union-typed expressions are viable candidates
    321                         findKindExpression( expr, indexer, "with statement", isStructOrUnion );
    322 
    323                         // if with expression might be impure, create a temporary so that it is evaluated once
    324                         if ( Tuples::maybeImpure( expr ) ) {
    325                                 static UniqueName tmpNamer( "_with_tmp_" );
    326                                 ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
    327                                 expr = new VariableExpr( tmp );
    328                                 newStmts.push_back( new DeclStmt( tmp ) );
    329                                 if ( InitTweak::isConstructable( tmp->type ) ) {
    330                                         // generate ctor/dtor and resolve them
    331                                         tmp->init = InitTweak::genCtorInit( tmp );
    332                                         tmp->accept( *visitor );
    333                                 }
    334                         }
    335                 }
    336         }
    337 
    338         void ResolveWithExprs::previsit( WithStmt * withStmt ) {
    339                 resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
    340         }
    341 
    342         void ResolveWithExprs::previsit( FunctionDecl * functionDecl ) {
     304        void Resolver::previsit( ObjectDecl *objectDecl ) {
     305                Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
     306                objectDecl->set_type( new_type );
     307                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
     308                // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
     309                // initContext because of a function type can contain object declarations in the return and parameter types. So
     310                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
     311                // the RHS.
     312                GuardValue( currentObject );
     313                currentObject = CurrentObject( objectDecl->get_type() );
     314                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
     315                        // enumerator initializers should not use the enum type to initialize, since
     316                        // the enum type is still incomplete at this point. Use signed int instead.
     317                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
     318                }
     319        }
     320
     321        template< typename PtrType >
     322        void Resolver::handlePtrType( PtrType * type ) {
     323                if ( type->get_dimension() ) {
     324                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
     325                }
     326        }
     327
     328        void Resolver::previsit( ArrayType * at ) {
     329                handlePtrType( at );
     330        }
     331
     332        void Resolver::previsit( PointerType * pt ) {
     333                handlePtrType( pt );
     334        }
     335
     336        void Resolver::previsit( TypeDecl *typeDecl ) {
     337                if ( typeDecl->get_base() ) {
     338                        Type *new_type = resolveTypeof( typeDecl->get_base(), indexer );
     339                        typeDecl->set_base( new_type );
     340                } // if
     341        }
     342
     343        void Resolver::previsit( FunctionDecl *functionDecl ) {
     344#if 0
     345                std::cerr << "resolver visiting functiondecl ";
     346                functionDecl->print( std::cerr );
     347                std::cerr << std::endl;
     348#endif
     349                Type *new_type = resolveTypeof( functionDecl->type, indexer );
     350                functionDecl->set_type( new_type );
     351                GuardValue( functionReturn );
     352                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
     353
    343354                {
    344355                        // resolve with-exprs with parameters in scope and add any newly generated declarations to the
    … …  
    354365                        }
    355366                }
    356         }
    357 
    358         void Resolver::previsit( ObjectDecl *objectDecl ) {
    359                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
    360                 // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
    361                 // initContext because of a function type can contain object declarations in the return and parameter types. So
    362                 // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
    363                 // the RHS.
    364                 GuardValue( currentObject );
    365                 currentObject = CurrentObject( objectDecl->get_type() );
    366                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
    367                         // enumerator initializers should not use the enum type to initialize, since
    368                         // the enum type is still incomplete at this point. Use signed int instead.
    369                         currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    370                 }
    371         }
    372 
    373         template< typename PtrType >
    374         void Resolver::handlePtrType( PtrType * type ) {
    375                 if ( type->get_dimension() ) {
    376                         findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
    377                 }
    378         }
    379 
    380         void Resolver::previsit( ArrayType * at ) {
    381                 handlePtrType( at );
    382         }
    383 
    384         void Resolver::previsit( PointerType * pt ) {
    385                 handlePtrType( pt );
    386         }
    387 
    388         void Resolver::previsit( FunctionDecl *functionDecl ) {
    389 #if 0
    390                 std::cerr << "resolver visiting functiondecl ";
    391                 functionDecl->print( std::cerr );
    392                 std::cerr << std::endl;
    393 #endif
    394                 GuardValue( functionReturn );
    395                 functionReturn = ResolvExpr::extractResultType( functionDecl->type );
    396367        }
    397368
    … …  
    724695                        stmt->orelse.statement->accept( *visitor );
    725696                }
     697        }
     698
     699        bool isStructOrUnion( const Alternative & alt ) {
     700                Type * t = alt.expr->result->stripReferences();
     701                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
     702        }
     703
     704        void Resolver::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
     705                for ( Expression *& expr : withExprs )  {
     706                        // only struct- and union-typed expressions are viable candidates
     707                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
     708
     709                        // if with expression might be impure, create a temporary so that it is evaluated once
     710                        if ( Tuples::maybeImpure( expr ) ) {
     711                                static UniqueName tmpNamer( "_with_tmp_" );
     712                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
     713                                expr = new VariableExpr( tmp );
     714                                newStmts.push_back( new DeclStmt( tmp ) );
     715                                if ( InitTweak::isConstructable( tmp->type ) ) {
     716                                        // generate ctor/dtor and resolve them
     717                                        tmp->init = InitTweak::genCtorInit( tmp );
     718                                        tmp->accept( *visitor );
     719                                }
     720                        }
     721                }
     722        }
     723
     724        void Resolver::previsit( WithStmt * withStmt ) {
     725                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
    726726        }
    727727

  • src/ResolvExpr/Resolver.h

    r6d44da1 r341bb80  
    3838        /// Searches expr and returns the first DeletedExpr found, otherwise nullptr
    3939        DeletedExpr * findDeletedExpr( Expression * expr );
    40         /// Resolves with-stmts and with-clauses on functions
    41         void resolveWithExprs( std::list< Declaration * > & translationUnit );
    4240} // namespace ResolvExpr
    4341

  • src/ResolvExpr/TypeEnvironment.cc

    r6d44da1 r341bb80  
    6969        }
    7070
    71         EqvClass::EqvClass( EqvClass &&other )
    72         : vars{std::move(other.vars)}, type{other.type},
     71        EqvClass::EqvClass( EqvClass &&other ) 
     72        : vars{std::move(other.vars)}, type{other.type}, 
    7373          allowWidening{std::move(other.allowWidening)}, data{std::move(other.data)} {
    7474                  other.type = nullptr;
    … …  
    8585                if ( this == &other ) return *this;
    8686                delete type;
    87 
     87               
    8888                vars = std::move(other.vars);
    8989                type = other.type;
    … …  
    132132                        ++next;
    133133                        std::set<std::string> intersection;
    134                         std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(),
     134                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), 
    135135                                std::inserter( intersection, intersection.begin() ) );
    136136                        if ( ! intersection.empty() ) { env.erase( i ); }
    … …  
    240240                        // ttype unifies with any tuple type
    241241                        return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
    242                   default:
    243                         assertf(false, "Unhandled tyvar kind: %d", data.kind);
    244242                } // switch
    245243                return false;
    … …  
    247245
    248246        bool TypeEnvironment::bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
    249 
     247               
    250248                // remove references from other, so that type variables can only bind to value types
    251249                bindTo = bindTo->stripReferences();
    … …  
    293291                auto class1 = internal_lookup( var1->get_name() );
    294292                auto class2 = internal_lookup( var2->get_name() );
    295 
     293               
    296294                // exit early if variables already bound together
    297295                if ( class1 != env.end() && class1 == class2 ) {

  • src/SymTab/Mangler.cc

    r6d44da1 r341bb80  
    7373                                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
    7474                                bool inFunctionType = false;    ///< Include type qualifiers if false.
    75                                 bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
    7675
    7776                                void mangleDecl( DeclarationWithType *declaration );
    … …  
    111110                                        isTopLevel = false;
    112111                                } // if
    113                                 mangleName << Encoding::manglePrefix;
     112                                mangleName << "__";
    114113                                CodeGen::OperatorInfo opInfo;
    115114                                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
    116                                         mangleName << opInfo.outputName.size() << opInfo.outputName;
     115                                        mangleName << opInfo.outputName;
    117116                                } else {
    118                                         mangleName << declaration->name.size() << declaration->name;
     117                                        mangleName << declaration->get_name();
    119118                                } // if
     119                                mangleName << "__";
    120120                                maybeAccept( declaration->get_type(), *visitor );
    121121                                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
    … …  
    123123                                        // so they need a different name mangling
    124124                                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
    125                                                 mangleName << Encoding::autogen;
     125                                                mangleName << "autogen__";
    126126                                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
    127                                                 mangleName << Encoding::intrinsic;
     127                                                mangleName << "intrinsic__";
    128128                                        } else {
    129129                                                // if we add another kind of overridable function, this has to change
    … …  
    144144                        void Mangler::postvisit( VoidType * voidType ) {
    145145                                printQualifiers( voidType );
    146                                 mangleName << Encoding::void_t;
     146                                mangleName << "v";
    147147                        }
    148148
    149149                        void Mangler::postvisit( BasicType * basicType ) {
     150                                static const char *btLetter[] = {
     151                                        "b",    // Bool
     152                                        "c",    // Char
     153                                        "Sc",   // SignedChar
     154                                        "Uc",   // UnsignedChar
     155                                        "s",    // ShortSignedInt
     156                                        "Us",   // ShortUnsignedInt
     157                                        "i",    // SignedInt
     158                                        "Ui",   // UnsignedInt
     159                                        "l",    // LongSignedInt
     160                                        "Ul",   // LongUnsignedInt
     161                                        "q",    // LongLongSignedInt
     162                                        "Uq",   // LongLongUnsignedInt
     163                                        "f",    // Float
     164                                        "d",    // Double
     165                                        "r",    // LongDouble
     166                                        "Xf",   // FloatComplex
     167                                        "Xd",   // DoubleComplex
     168                                        "Xr",   // LongDoubleComplex
     169                                        "If",   // FloatImaginary
     170                                        "Id",   // DoubleImaginary
     171                                        "Ir",   // LongDoubleImaginary
     172                                        "w",    // SignedInt128
     173                                        "Uw",   // UnsignedInt128
     174                                        "x",    // Float80
     175                                        "y",    // Float128
     176                                };
     177                                static_assert(
     178                                        sizeof(btLetter)/sizeof(btLetter[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
     179                                        "Each basic type kind should have a corresponding mangler letter"
     180                                );
     181
    150182                                printQualifiers( basicType );
    151                                 assertf( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->get_kind() );
    152                                 mangleName << Encoding::basicTypes[ basicType->get_kind() ];
     183                                assert( basicType->get_kind() < sizeof(btLetter)/sizeof(btLetter[0]) );
     184                                mangleName << btLetter[ basicType->get_kind() ];
    153185                        }
    154186
    … …  
    156188                                printQualifiers( pointerType );
    157189                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
    158                                 if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << Encoding::pointer;
     190                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << "P";
    159191                                maybeAccept( pointerType->base, *visitor );
    160192                        }
    … …  
    163195                                // TODO: encode dimension
    164196                                printQualifiers( arrayType );
    165                                 mangleName << Encoding::array << "0";
     197                                mangleName << "A0";
    166198                                maybeAccept( arrayType->base, *visitor );
    167199                        }
    … …  
    188220                        void Mangler::postvisit( FunctionType * functionType ) {
    189221                                printQualifiers( functionType );
    190                                 mangleName << Encoding::function;
     222                                mangleName << "F";
    191223                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
    192224                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
    … …  
    195227                                inFunctionType = true;
    196228                                std::list< Type* > returnTypes = getTypes( functionType->returnVals );
    197                                 if (returnTypes.empty()) mangleName << Encoding::void_t;
    198                                 else acceptAll( returnTypes, *visitor );
     229                                acceptAll( returnTypes, *visitor );
    199230                                mangleName << "_";
    200231                                std::list< Type* > paramTypes = getTypes( functionType->parameters );
    … …  
    206237                                printQualifiers( refType );
    207238
    208                                 mangleName << prefix << refType->name.length() << refType->name;
     239                                mangleName << ( refType->name.length() + prefix.length() ) << prefix << refType->name;
    209240
    210241                                if ( mangleGenericParams ) {
    … …  
    223254
    224255                        void Mangler::postvisit( StructInstType * aggregateUseType ) {
    225                                 mangleRef( aggregateUseType, Encoding::struct_t );
     256                                mangleRef( aggregateUseType, "s" );
    226257                        }
    227258
    228259                        void Mangler::postvisit( UnionInstType * aggregateUseType ) {
    229                                 mangleRef( aggregateUseType, Encoding::union_t );
     260                                mangleRef( aggregateUseType, "u" );
    230261                        }
    231262
    232263                        void Mangler::postvisit( EnumInstType * aggregateUseType ) {
    233                                 mangleRef( aggregateUseType, Encoding::enum_t );
     264                                mangleRef( aggregateUseType, "e" );
    234265                        }
    235266
    … …  
    237268                                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
    238269                                if ( varNum == varNums.end() ) {
    239                                         mangleRef( typeInst, Encoding::type );
     270                                        mangleRef( typeInst, "t" );
    240271                                } else {
    241272                                        printQualifiers( typeInst );
    242                                         // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
    243                                         //   forall(dtype T) void f(T);
    244                                         //   forall(dtype S) void f(S);
    245                                         // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
    246                                         // are first found and prefixing with the appropriate encoding for the type class.
    247                                         assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
    248                                         mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
     273                                        std::ostringstream numStream;
     274                                        numStream << varNum->second.first;
     275                                        switch ( (TypeDecl::Kind )varNum->second.second ) {
     276                                          case TypeDecl::Dtype:
     277                                                mangleName << "d";
     278                                                break;
     279                                          case TypeDecl::Ftype:
     280                                                mangleName << "f";
     281                                                break;
     282                                                case TypeDecl::Ttype:
     283                                                mangleName << "tVARGS";
     284                                                break;
     285                                                default:
     286                                                assert( false );
     287                                        } // switch
     288                                        mangleName << numStream.str();
    249289                                } // if
    250290                        }
    … …  
    252292                        void Mangler::postvisit( TraitInstType * inst ) {
    253293                                printQualifiers( inst );
    254                                 mangleName << inst->name.size() << inst->name;
     294                                mangleName << "_Y" << inst->name << "_";
    255295                        }
    256296
    257297                        void Mangler::postvisit( TupleType * tupleType ) {
    258298                                printQualifiers( tupleType );
    259                                 mangleName << Encoding::tuple << tupleType->types.size();
     299                                mangleName << "T";
    260300                                acceptAll( tupleType->types, *visitor );
     301                                mangleName << "_";
    261302                        }
    262303
    263304                        void Mangler::postvisit( VarArgsType * varArgsType ) {
    264305                                printQualifiers( varArgsType );
    265                                 static const std::string vargs = "__builtin_va_list";
    266                                 mangleName << Encoding::type << vargs.size() << vargs;
     306                                mangleName << "VARGS";
    267307                        }
    268308
    269309                        void Mangler::postvisit( ZeroType * ) {
    270                                 mangleName << Encoding::zero;
     310                                mangleName << "Z";
    271311                        }
    272312
    273313                        void Mangler::postvisit( OneType * ) {
    274                                 mangleName << Encoding::one;
     314                                mangleName << "O";
    275315                        }
    276316
    277317                        void Mangler::postvisit( QualifiedType * qualType ) {
    278                                 bool inqual = inQualifiedType;
    279                                 if (! inqual ) {
    280                                         // N marks the start of a qualified type
    281                                         inQualifiedType = true;
    282                                         mangleName << Encoding::qualifiedTypeStart;
    283                                 }
    284318                                maybeAccept( qualType->parent, *visitor );
     319                                mangleName << "__";
    285320                                maybeAccept( qualType->child, *visitor );
    286                                 if ( ! inqual ) {
    287                                         // E marks the end of a qualified type
    288                                         inQualifiedType = false;
    289                                         mangleName << Encoding::qualifiedTypeEnd;
    290                                 }
    291321                        }
    292322
    293323                        void Mangler::postvisit( TypeDecl * decl ) {
    294                                 // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
    295                                 // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
    296                                 // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
    297                                 // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
    298                                 // aside from the assert false.
    299                                 assertf(false, "Mangler should not visit typedecl: %s", toCString(decl));
    300                                 assertf( decl->get_kind() < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->get_kind() );
    301                                 mangleName << Encoding::typeVariables[ decl->get_kind() ] << ( decl->name.length() ) << decl->name;
     324                                static const char *typePrefix[] = { "BT", "BD", "BF" };
     325                                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
    302326                        }
    303327
    … …  
    313337                                if ( ! type->get_forall().empty() ) {
    314338                                        std::list< std::string > assertionNames;
    315                                         int dcount = 0, fcount = 0, vcount = 0, acount = 0;
    316                                         mangleName << Encoding::forall;
     339                                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
     340                                        mangleName << "A";
    317341                                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
    318342                                                switch ( (*i)->get_kind() ) {
    … …  
    337361                                                        (*assert)->accept( sub_mangler );
    338362                                                        assertionNames.push_back( sub_mangler.pass.mangleName.str() );
    339                                                         acount++;
    340363                                                } // for
    341364                                        } // for
    342                                         mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
     365                                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
    343366                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
    344367                                        mangleName << "_";
    … …  
    347370                                        // these qualifiers do not distinguish the outermost type of a function parameter
    348371                                        if ( type->get_const() ) {
    349                                                 mangleName << Encoding::qualifiers.at(Type::Const);
     372                                                mangleName << "C";
    350373                                        } // if
    351374                                        if ( type->get_volatile() ) {
    352                                                 mangleName << Encoding::qualifiers.at(Type::Volatile);
     375                                                mangleName << "V";
    353376                                        } // if
    354377                                        // Removed due to restrict not affecting function compatibility in GCC
    … …  
    357380                                        // } // if
    358381                                        if ( type->get_atomic() ) {
    359                                                 mangleName << Encoding::qualifiers.at(Type::Atomic);
     382                                                mangleName << "A";
    360383                                        } // if
    361384                                }
    362385                                if ( type->get_mutex() ) {
    363                                         mangleName << Encoding::qualifiers.at(Type::Mutex);
     386                                        mangleName << "M";
    364387                                } // if
    365388                                if ( type->get_lvalue() ) {
    366389                                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
    367                                         mangleName << Encoding::qualifiers.at(Type::Lvalue);
     390                                        mangleName << "L";
    368391                                }
    369392

  • src/SymTab/Mangler.h

    r6d44da1 r341bb80  
    2424#include "SynTree/Visitor.h"  // for Visitor, maybeAccept
    2525
    26 // https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
    27 // The CFA name mangling scheme is based closely on the itanium C++ name mangling scheme, with the following key differences:
    28 // * Variable names are also mangled to include type information, not just functions
    29 // * CFA does not have template expansion, so the rules for function specialization do not apply.
    30 // * CFA instead has to handle type parameters and assertion parameters.
    31 // * Currently name compression is not implemented.
    32 
    3326namespace SymTab {
    3427        namespace Mangler {
    … …  
    4033                /// Mangle ignoring generic type parameters
    4134                std::string mangleConcrete( Type* ty );
    42 
    43                 namespace Encoding {
    44                         extern const std::string manglePrefix;
    45                         extern const std::string basicTypes[];
    46                         extern const std::map<int, std::string> qualifiers;
    47 
    48                         extern const std::string void_t;
    49                         extern const std::string zero;
    50                         extern const std::string one;
    51 
    52                         extern const std::string function;
    53                         extern const std::string tuple;
    54                         extern const std::string pointer;
    55                         extern const std::string array;
    56                         extern const std::string qualifiedTypeStart;
    57                         extern const std::string qualifiedTypeEnd;
    58 
    59                         extern const std::string forall;
    60                         extern const std::string typeVariables[];
    61 
    62                         extern const std::string struct_t;
    63                         extern const std::string union_t;
    64                         extern const std::string enum_t;
    65                         extern const std::string type;
    66 
    67                         extern const std::string autogen;
    68                         extern const std::string intrinsic;
    69                 };
    7035        } // Mangler
    7136} // SymTab
    72 
    73 extern "C" {
    74         char * cforall_demangle(const char *, int);
    75 }
    7637
    7738// Local Variables: //

  • src/SymTab/Validate.cc

    r6d44da1 r341bb80  
    6262#include "ResolvExpr/typeops.h"        // for typesCompatible
    6363#include "ResolvExpr/Resolver.h"       // for findSingleExpression
    64 #include "ResolvExpr/ResolveTypeof.h"  // for resolveTypeof
    6564#include "SymTab/Autogen.h"            // for SizeType
    6665#include "SynTree/Attribute.h"         // for noAttributes, Attribute
    … …  
    248247                void previsit( StructInstType * inst );
    249248                void previsit( UnionInstType * inst );
    250         };
    251 
    252         struct FixObjectType : public WithIndexer {
    253                 /// resolves typeof type in object, function, and type declarations
    254                 static void fix( std::list< Declaration * > & translationUnit );
    255 
    256                 void previsit( ObjectDecl * );
    257                 void previsit( FunctionDecl * );
    258                 void previsit( TypeDecl * );
    259249        };
    260250
    … …  
    322312                Concurrency::implementThreadStarter( translationUnit );
    323313                mutateAll( translationUnit, compoundliteral );
    324                 ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
    325                 FixObjectType::fix( translationUnit );
    326314                ArrayLength::computeLength( translationUnit );
    327315                acceptAll( translationUnit, finder ); // xxx - remove this pass soon
    … …  
    403391                        assert( aggr ); // TODO: need to handle forward declarations
    404392                        for ( Declaration * member : aggr->members ) {
    405                                 if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
     393                                if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
     394                                        if ( StructDecl * aggr = dynamic_cast< StructDecl * >( member ) ) {
     395                                                if ( aggr->name == inst->name ) {
     396                                                        // TODO: is this case, and other non-TypeInstType cases, necessary?
     397                                                        return new StructInstType( qualType->get_qualifiers(), aggr );
     398                                                }
     399                                        }
     400                                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
     401                                        if ( UnionDecl * aggr = dynamic_cast< UnionDecl * > ( member ) ) {
     402                                                if ( aggr->name == inst->name ) {
     403                                                        return new UnionInstType( qualType->get_qualifiers(), aggr );
     404                                                }
     405                                        }
     406                                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
     407                                        if ( EnumDecl * aggr = dynamic_cast< EnumDecl * > ( member ) ) {
     408                                                if ( aggr->name == inst->name ) {
     409                                                        return new EnumInstType( qualType->get_qualifiers(), aggr );
     410                                                }
     411                                        }
     412                                } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
    406413                                        // name on the right is a typedef
    407414                                        if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
    … …  
    410417                                                        Type * ret = aggr->base->clone();
    411418                                                        ret->get_qualifiers() = qualType->get_qualifiers();
    412                                                         TypeSubstitution sub = parent->genericSubstitution();
    413                                                         sub.apply(ret);
    414419                                                        return ret;
    415420                                                }
    … …  
    12331238        }
    12341239
    1235         void FixObjectType::fix( std::list< Declaration * > & translationUnit ) {
    1236                 PassVisitor<FixObjectType> fixer;
    1237                 acceptAll( translationUnit, fixer );
    1238         }
    1239 
    1240         void FixObjectType::previsit( ObjectDecl * objDecl ) {
    1241                 Type *new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer );
    1242                 new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
    1243                 objDecl->set_type( new_type );
    1244         }
    1245 
    1246         void FixObjectType::previsit( FunctionDecl * funcDecl ) {
    1247                 Type *new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer );
    1248                 new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
    1249                 funcDecl->set_type( new_type );
    1250         }
    1251 
    1252         void FixObjectType::previsit( TypeDecl *typeDecl ) {
    1253                 if ( typeDecl->get_base() ) {
    1254                         Type *new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer );
    1255                         new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
    1256                         typeDecl->set_base( new_type );
    1257                 } // if
    1258         }
    1259 
    12601240        void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
    12611241                PassVisitor<ArrayLength> len;

  • src/SymTab/module.mk

    r6d44da1 r341bb80  
    1717SRC += SymTab/Indexer.cc \
    1818       SymTab/Mangler.cc \
    19        SymTab/ManglerCommon.cc \
    2019       SymTab/Validate.cc \
    2120       SymTab/FixFunction.cc \

  • src/SynTree/Declaration.h

    r6d44da1 r341bb80  
    202202        typedef NamedTypeDecl Parent;
    203203  public:
    204         enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS };
     204        enum Kind { Dtype, Ftype, Ttype };
    205205
    206206        Type * init;

  • src/cfa.make

    r6d44da1 r341bb80  
    1212am__v_CFA_1 =
    1313
    14 .cfa.o:
     14.cfa.o: $(CFACC) $(CFACPP)
    1515        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
    1616        $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

  • src/main.cc

    r6d44da1 r341bb80  
    3434#include "CodeGen/Generate.h"               // for generate
    3535#include "CodeTools/DeclStats.h"            // for printDeclStats
    36 #include "CodeTools/ResolvProtoDump.h"      // for dumpAsResolvProto
    3736#include "CodeTools/TrackLoc.h"             // for fillLocations
    3837#include "Common/CompilerError.h"           // for CompilerError
    … …  
    172171                        if ( filename == nullptr ) filename = argv[ optind ];
    173172                        // prelude filename comes in differently
    174                         if ( libcfap ) filename = "prelude.cfa";
     173                        if ( libcfap ) filename = "prelude.cf";
    175174                        optind += 1;
    176175                } else {                                                                                // no input file name
    … …  
    199198                        if ( ! libcfap ) {
    200199                                // read the prelude in, if not generating the cfa library
    201                                 FILE * prelude = fopen( (PreludeDirector + "/prelude.cfa").c_str(), "r" );
    202                                 assertf( prelude, "cannot open prelude.cfa\n" );
     200                                FILE * prelude = fopen( (PreludeDirector + "/prelude.cf").c_str(), "r" );
     201                                assertf( prelude, "cannot open prelude.cf\n" );
    203202                                parse( prelude, LinkageSpec::Intrinsic );
    204203
    … …  
    271270
    272271                CodeTools::fillLocations( translationUnit );
    273 
    274                 if ( resolvprotop ) {
    275                         CodeTools::dumpAsResolvProto( translationUnit );
    276                         return 0;
    277                 }
    278272
    279273                PASS( "resolve", ResolvExpr::resolve( translationUnit ) );
    … …  
    382376
    383377void parse_cmdline( int argc, char * argv[], const char *& filename ) {
    384         enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Linemarks, Nolinemarks, Nopreamble, Parse, PreludeDir, Prototypes, Resolver, ResolvProto, Symbol, Tree, TupleExpansion, Validate, };
     378        enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Linemarks, Nolinemarks, Nopreamble, Parse, PreludeDir, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, };
    385379
    386380        static struct option long_opts[] = {
    … …  
    401395                { "no-prototypes", no_argument, 0, Prototypes },
    402396                { "resolver", no_argument, 0, Resolver },
    403                 { "resolv-proto", no_argument, 0, ResolvProto },
    404397                { "symbol", no_argument, 0, Symbol },
    405398                { "tree", no_argument, 0, Tree },
    … …  
    414407        bool Wsuppress = false, Werror = false;
    415408        int c;
    416         while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrRstTvwW:yzZD:F:", long_opts, &long_index )) != -1 ) {
     409        while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrstTvwW:yzZD:F:", long_opts, &long_index )) != -1 ) {
    417410                switch ( c ) {
    418411                  case Ast:
    … …  
    486479                  case 'r':                                                                             // print resolver steps
    487480                        resolvep = true;
    488                         break;
    489                         case 'R':                                                                               // dump resolv-proto instance
    490                         resolvprotop = true;
    491481                        break;
    492482                  case Symbol:

  • tests/.expect/KRfunctions.x64.txt

    r6d44da1 r341bb80  
    1 signed int _X2f0Fi_iPKii__1(signed int _X1ai_1, const signed int *_X1bPKi_1, signed int _X1ci_1){
    2     __attribute__ ((unused)) signed int _X10_retval_f0i_1;
     1signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
     2    __attribute__ ((unused)) signed int ___retval_f0__i_1;
    33}
    4 signed int _X2f1Fi_PiiPi__1(signed int *_X1aPi_1, __attribute__ ((unused)) signed int _X1bi_1, signed int *_X1cPi_1){
    5     __attribute__ ((unused)) signed int _X10_retval_f1i_1;
     4signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){
     5    __attribute__ ((unused)) signed int ___retval_f1__i_1;
    66}
    7 signed int _X2f2Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    8     __attribute__ ((unused)) signed int _X10_retval_f2i_1;
     7signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     8    __attribute__ ((unused)) signed int ___retval_f2__i_1;
    99}
    1010struct S {
    11     signed int _X1ii_1;
     11    signed int __i__i_1;
    1212};
    13 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    14 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    15 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    16 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    17 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    18 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    19     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
     13static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     14static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     15static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     16static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     17static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
     18static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     19    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
    2020}
    21 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    22     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
     21static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     22    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
    2323}
    24 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    25     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
     24static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     25    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
    2626}
    27 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    28     struct S _X4_retS1S_1;
    29     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    30     ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    31     return _X4_retS1S_1;
     27static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     28    struct S ___ret__2sS_1;
     29    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     30    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     31    return ___ret__2sS_1;
    3232}
    33 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    34     ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
     33static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
     34    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
    3535}
    36 signed int _X2f3Fi_S1SS1SPi__1(struct S _X1aS1S_1, struct S _X1bS1S_1, signed int *_X1cPi_1){
    37     __attribute__ ((unused)) signed int _X10_retval_f3i_1;
    38     struct S _X1sS1S_2;
     36signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
     37    __attribute__ ((unused)) signed int ___retval_f3__i_1;
     38    struct S __s__2sS_2;
    3939}
    40 signed int _X2f4Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    41     __attribute__ ((unused)) signed int _X10_retval_f4i_1;
     40signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     41    __attribute__ ((unused)) signed int ___retval_f4__i_1;
    4242}
    43 signed int _X2f5Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    44     __attribute__ ((unused)) signed int _X10_retval_f5i_1;
     43signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     44    __attribute__ ((unused)) signed int ___retval_f5__i_1;
    4545}
    46 signed int (*_X2f6FFi_i__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(signed int __anonymous_object0){
    47     __attribute__ ((unused)) signed int (*_X10_retval_f6Fi_i__1)(signed int __anonymous_object1);
     46signed int (*__f6__FFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
     47    __attribute__ ((unused)) signed int (*___retval_f6__Fi_i__1)(signed int __anonymous_object1);
    4848}
    49 signed int (*_X2f7FFi_ii__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(signed int _X1ai_1, signed int _X1bi_1){
    50     __attribute__ ((unused)) signed int (*_X10_retval_f7Fi_ii__1)(signed int _X1ai_1, signed int _X1bi_1);
     49signed int (*__f7__FFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
     50    __attribute__ ((unused)) signed int (*___retval_f7__Fi_ii__1)(signed int __a__i_1, signed int __b__i_1);
    5151}
    52 signed int *_X2f8FPi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    53     __attribute__ ((unused)) signed int *_X10_retval_f8Pi_1;
     52signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     53    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
    5454}
    55 signed int *const _X2f9FPi_PiiPi__1(signed int *_X1aPi_1, signed int _X1bi_1, signed int *_X1cPi_1){
    56     __attribute__ ((unused)) signed int *const _X10_retval_f9KPi_1;
     55signed int *const __f9__FPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     56    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
    5757}
    58 signed int *(*_X3f10FFPi_ii__iPiPid__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1, double _X1yd_1))(signed int _X1xi_1, signed int _X1yi_1){
    59     __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
    60     signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    61     ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
    62     return _X11_retval_f10FPi_ii__1;
     58signed int *(*__f10__FFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
     59    __attribute__ ((unused)) signed int *(*___retval_f10__FPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
     60    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     61    ((void)(___retval_f10__FPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     62    return ___retval_f10__FPi_ii__1;
    6363}
    64 signed int (*_X3f11FPA0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[]{
    65     __attribute__ ((unused)) signed int (*_X11_retval_f11PA0i_1)[];
     64signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
     65    __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[];
    6666}
    67 signed int (*_X3f12FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
    68     __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )10)];
     67signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     68    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned long int )10)];
    6969}
    70 signed int (*_X3f13FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
    71     __attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned long int )10)];
     70signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     71    __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned long int )10)];
    7272}
    73 signed int (*_X3f14FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
    74     __attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned long int )10)];
     73signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned long int )10)]{
     74    __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned long int )10)];
    7575}
    76 signed int _X3f15Fi_iii__1(signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
    77     __attribute__ ((unused)) signed int _X11_retval_f15i_1;
     76signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     77    __attribute__ ((unused)) signed int ___retval_f15__i_1;
    7878}
    79 const signed int _X4fredFi___1(){
    80     __attribute__ ((unused)) const signed int _X12_retval_fredKi_1;
    81     signed int *(*_X1xFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
    82     signed int _X1ai_2;
    83     signed int _X1bi_2;
    84     signed int *(*_tmp_cp_ret2)(signed int _X1xi_1, signed int _X1yi_1);
    85     ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret2=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret2)));
     79const signed int __fred__Fi___1(){
     80    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
     81    signed int *(*__x__FPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     82    signed int __a__i_2;
     83    signed int __b__i_2;
     84    signed int *(*_tmp_cp_ret2)(signed int __x__i_1, signed int __y__i_1);
     85    ((void)(__x__FPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
    8686    ((void)(_tmp_cp_ret2) /* ^?{} */);
    87     const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
    88         __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;
     87    const signed int __f1__Fi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
     88        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
    8989    }
    90     const signed int _X2f2Fi_iii__2(signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    91         __attribute__ ((unused)) const signed int _X10_retval_f2Ki_2;
     90    const signed int __f2__Fi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     91        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
    9292    }
    9393}

  • tests/.expect/KRfunctions.x86.txt

    r6d44da1 r341bb80  
    1 signed int _X2f0Fi_iPKii__1(signed int _X1ai_1, const signed int *_X1bPKi_1, signed int _X1ci_1){
    2     __attribute__ ((unused)) signed int _X10_retval_f0i_1;
     1signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){
     2    __attribute__ ((unused)) signed int ___retval_f0__i_1;
    33}
    4 signed int _X2f1Fi_PiiPi__1(signed int *_X1aPi_1, __attribute__ ((unused)) signed int _X1bi_1, signed int *_X1cPi_1){
    5     __attribute__ ((unused)) signed int _X10_retval_f1i_1;
     4signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){
     5    __attribute__ ((unused)) signed int ___retval_f1__i_1;
    66}
    7 signed int _X2f2Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    8     __attribute__ ((unused)) signed int _X10_retval_f2i_1;
     7signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     8    __attribute__ ((unused)) signed int ___retval_f2__i_1;
    99}
    1010struct S {
    11     signed int _X1ii_1;
     11    signed int __i__i_1;
    1212};
    13 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    14 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    15 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    16 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    17 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    18 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    19     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
     13static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     14static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     15static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     16static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     17static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
     18static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     19    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
    2020}
    21 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    22     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
     21static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     22    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
    2323}
    24 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    25     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
     24static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     25    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
    2626}
    27 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    28     struct S _X4_retS1S_1;
    29     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    30     ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    31     return _X4_retS1S_1;
     27static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     28    struct S ___ret__2sS_1;
     29    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     30    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     31    return ___ret__2sS_1;
    3232}
    33 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    34     ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
     33static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
     34    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
    3535}
    36 signed int _X2f3Fi_S1SS1SPi__1(struct S _X1aS1S_1, struct S _X1bS1S_1, signed int *_X1cPi_1){
    37     __attribute__ ((unused)) signed int _X10_retval_f3i_1;
    38     struct S _X1sS1S_2;
     36signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
     37    __attribute__ ((unused)) signed int ___retval_f3__i_1;
     38    struct S __s__2sS_2;
    3939}
    40 signed int _X2f4Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    41     __attribute__ ((unused)) signed int _X10_retval_f4i_1;
     40signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     41    __attribute__ ((unused)) signed int ___retval_f4__i_1;
    4242}
    43 signed int _X2f5Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    44     __attribute__ ((unused)) signed int _X10_retval_f5i_1;
     43signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     44    __attribute__ ((unused)) signed int ___retval_f5__i_1;
    4545}
    46 signed int (*_X2f6FFi_i__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(signed int __anonymous_object0){
    47     __attribute__ ((unused)) signed int (*_X10_retval_f6Fi_i__1)(signed int __anonymous_object1);
     46signed int (*__f6__FFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
     47    __attribute__ ((unused)) signed int (*___retval_f6__Fi_i__1)(signed int __anonymous_object1);
    4848}
    49 signed int (*_X2f7FFi_ii__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(signed int _X1ai_1, signed int _X1bi_1){
    50     __attribute__ ((unused)) signed int (*_X10_retval_f7Fi_ii__1)(signed int _X1ai_1, signed int _X1bi_1);
     49signed int (*__f7__FFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
     50    __attribute__ ((unused)) signed int (*___retval_f7__Fi_ii__1)(signed int __a__i_1, signed int __b__i_1);
    5151}
    52 signed int *_X2f8FPi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
    53     __attribute__ ((unused)) signed int *_X10_retval_f8Pi_1;
     52signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     53    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
    5454}
    55 signed int *const _X2f9FPi_PiiPi__1(signed int *_X1aPi_1, signed int _X1bi_1, signed int *_X1cPi_1){
    56     __attribute__ ((unused)) signed int *const _X10_retval_f9KPi_1;
     55signed int *const __f9__FPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     56    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
    5757}
    58 signed int *(*_X3f10FFPi_ii__iPiPid__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1, double _X1yd_1))(signed int _X1xi_1, signed int _X1yi_1){
    59     __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
    60     signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    61     ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
    62     return _X11_retval_f10FPi_ii__1;
     58signed int *(*__f10__FFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
     59    __attribute__ ((unused)) signed int *(*___retval_f10__FPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
     60    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     61    ((void)(___retval_f10__FPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     62    return ___retval_f10__FPi_ii__1;
    6363}
    64 signed int (*_X3f11FPA0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[]{
    65     __attribute__ ((unused)) signed int (*_X11_retval_f11PA0i_1)[];
     64signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
     65    __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[];
    6666}
    67 signed int (*_X3f12FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
    68     __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned int )10)];
     67signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
     68    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];
    6969}
    70 signed int (*_X3f13FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
    71     __attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned int )10)];
     70signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
     71    __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];
    7272}
    73 signed int (*_X3f14FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
    74     __attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned int )10)];
     73signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{
     74    __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];
    7575}
    76 signed int _X3f15Fi_iii__1(signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
    77     __attribute__ ((unused)) signed int _X11_retval_f15i_1;
     76signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     77    __attribute__ ((unused)) signed int ___retval_f15__i_1;
    7878}
    79 const signed int _X4fredFi___1(){
    80     __attribute__ ((unused)) const signed int _X12_retval_fredKi_1;
    81     signed int *(*_X1xFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
    82     signed int _X1ai_2;
    83     signed int _X1bi_2;
    84     signed int *(*_tmp_cp_ret2)(signed int _X1xi_1, signed int _X1yi_1);
    85     ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret2=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret2)));
     79const signed int __fred__Fi___1(){
     80    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
     81    signed int *(*__x__FPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     82    signed int __a__i_2;
     83    signed int __b__i_2;
     84    signed int *(*_tmp_cp_ret2)(signed int __x__i_1, signed int __y__i_1);
     85    ((void)(__x__FPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
    8686    ((void)(_tmp_cp_ret2) /* ^?{} */);
    87     const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
    88         __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;
     87    const signed int __f1__Fi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
     88        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
    8989    }
    90     const signed int _X2f2Fi_iii__2(signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    91         __attribute__ ((unused)) const signed int _X10_retval_f2Ki_2;
     90    const signed int __f2__Fi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     91        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
    9292    }
    9393}

  • tests/.expect/attributes.x64.txt

    r6d44da1 r341bb80  
    1 signed int _X2laFi___1(){
    2     __attribute__ ((unused)) signed int _X10_retval_lai_1;
     1signed int __la__Fi___1(){
     2    __attribute__ ((unused)) signed int ___retval_la__i_1;
    33    L: __attribute__ ((unused)) ((void)1);
    44}
    55struct __attribute__ ((unused)) __anonymous0 {
    66};
    7 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    8 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    9 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    10 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    11 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    12 }
    13 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    14 }
    15 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    16 }
    17 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    18     struct __anonymous0 _X4_retS12__anonymous0_1;
    19     ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    20     return _X4_retS12__anonymous0_1;
     7static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     8static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     9static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     10static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     11static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     12}
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     14}
     15static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     16}
     17static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     18    struct __anonymous0 ___ret__13s__anonymous0_1;
     19    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
     20    return ___ret__13s__anonymous0_1;
    2121}
    2222struct __attribute__ ((unused)) Agn1;
    2323struct __attribute__ ((unused)) Agn2 {
    2424};
    25 static inline void _X12_constructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1);
    26 static inline void _X12_constructorFv_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1);
    27 static inline void _X11_destructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1);
    28 static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1);
    29 static inline void _X12_constructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1){
    30 }
    31 static inline void _X12_constructorFv_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    32 }
    33 static inline void _X11_destructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1){
    34 }
    35 static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    36     struct Agn2 _X4_retS4Agn2_1;
    37     ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
    38     return _X4_retS4Agn2_1;
     25static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     26static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     27static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     28static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     29static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     30}
     31static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     32}
     33static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     34}
     35static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     36    struct Agn2 ___ret__5sAgn2_1;
     37    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
     38    return ___ret__5sAgn2_1;
    3939}
    4040enum __attribute__ ((unused)) __anonymous1 {
    41     _X2E1KM12__anonymous1_1,
     41    __E1__C13e__anonymous1_1,
    4242};
    4343enum __attribute__ ((unused)) Agn3;
    4444enum __attribute__ ((packed)) Agn3 {
    45     _X2E2KM4Agn3_1,
     45    __E2__C5eAgn3_1,
    4646};
    4747struct __attribute__ ((unused)) __anonymous2 {
    4848};
    49 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    50 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    51 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    52 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    53 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    54 }
    55 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    56 }
    57 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    58 }
    59 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    60     struct __anonymous2 _X4_retS12__anonymous2_1;
    61     ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    62     return _X4_retS12__anonymous2_1;
     49static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     50static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     51static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     52static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     53static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     54}
     55static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     56}
     57static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     58}
     59static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     60    struct __anonymous2 ___ret__13s__anonymous2_1;
     61    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__anonymous2_1)));
     62    return ___ret__13s__anonymous2_1;
    6363}
    6464struct __attribute__ ((unused)) Agn4 {
    6565};
    66 static inline void _X12_constructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1);
    67 static inline void _X12_constructorFv_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1);
    68 static inline void _X11_destructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1);
    69 static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1);
    70 static inline void _X12_constructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1){
    71 }
    72 static inline void _X12_constructorFv_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    73 }
    74 static inline void _X11_destructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1){
    75 }
    76 static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    77     struct Agn4 _X4_retS4Agn4_1;
    78     ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
    79     return _X4_retS4Agn4_1;
     66static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
     67static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
     68static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
     69static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
     70static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
     71}
     72static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
     73}
     74static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
     75}
     76static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
     77    struct Agn4 ___ret__5sAgn4_1;
     78    ((void)___constructor__F_5sAgn45sAgn4_autogen___1((&___ret__5sAgn4_1), (*___dst__5sAgn4_1)));
     79    return ___ret__5sAgn4_1;
    8080}
    8181struct Fdl {
    82     __attribute__ ((unused)) signed int _X2f1i_1;
    83     __attribute__ ((unused)) signed int _X2f2i_1;
    84     __attribute__ ((unused,unused)) signed int _X2f3i_1;
    85     __attribute__ ((unused)) signed int _X2f4i_1;
    86     __attribute__ ((unused,unused)) signed int _X2f5i_1;
    87     __attribute__ ((used,packed)) signed int _X2f6i_1;
    88     __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
    89     __attribute__ ((used,used,unused)) signed int _X2f8i_1;
    90     __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
    91 };
    92 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
    93 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1);
    94 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
    95 static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1);
    96 static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1);
    97 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1);
    98 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1);
    99 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1);
    100 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1);
    101 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1);
    102 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1);
    103 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1);
    104 static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
    105 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    106     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
    107     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    108     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    109     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    110     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    111     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    112     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    113     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    114     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    115 }
    116 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    117     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
    118     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
    119     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
    120     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
    121     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
    122     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
    123     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
    124     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
    125     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
    126 }
    127 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    128     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
    129     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
    130     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
    131     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
    132     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
    133     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
    134     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
    135     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
    136     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
    137 }
    138 static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    139     struct Fdl _X4_retS3Fdl_1;
    140     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
    141     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
    142     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
    143     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
    144     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
    145     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
    146     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
    147     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
    148     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
    149     ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
    150     return _X4_retS3Fdl_1;
    151 }
    152 static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1){
    153     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    154     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    155     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    156     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    157     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    158     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    159     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    160     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    161     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    162 }
    163 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
    164     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    165     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    166     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    167     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    168     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    169     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    170     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    171     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    172     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    173 }
    174 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
    175     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    176     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    177     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    178     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    179     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    180     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    181     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    182     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    183     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    184 }
    185 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
    186     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    187     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    188     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    189     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    190     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    191     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    192     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    193     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    194     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    195 }
    196 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
    197     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    198     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    199     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    200     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    201     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    202     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    203     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    204     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    205     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    206 }
    207 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
    208     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    209     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    210     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    211     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    212     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    213     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    214     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    215     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    216     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    217 }
    218 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
    219     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    220     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    221     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    222     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    223     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    224     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    225     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    226     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    227     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    228 }
    229 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
    230     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    231     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    232     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    233     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    234     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    235     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    236     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    237     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    238     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    239 }
    240 static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
    241     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    242     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    243     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    244     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    245     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    246     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    247     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    248     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    249     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
    250 }
    251 __attribute__ ((unused)) signed int _X1fFi___1() asm ( "xyz" );
    252 __attribute__ ((used,used)) const signed int _X3vd1Ki_1;
    253 __attribute__ ((used,unused)) const signed int _X3vd2Ki_1;
    254 __attribute__ ((used,used,used,used)) const signed int *_X3vd3PKi_1;
    255 __attribute__ ((used,used,unused,used,unused)) const signed int *_X3vd4PKi_1;
    256 __attribute__ ((used,used,used)) const signed int _X3vd5A0Ki_1[((unsigned long int )5)];
    257 __attribute__ ((used,used,unused,used)) const signed int _X3vd6A0Ki_1[((unsigned long int )5)];
    258 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
    259 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
    260 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
    261 __attribute__ ((unused)) signed int _X2f1Fi___1(){
    262     __attribute__ ((unused)) signed int _X10_retval_f1i_1;
    263 }
    264 __attribute__ ((unused,unused,unused,used)) signed int **const _X2f2FPPi___1();
    265 __attribute__ ((unused,unused,unused)) signed int **const _X2f2FPPi___1(){
    266     __attribute__ ((unused)) signed int **const _X10_retval_f2KPPi_1;
    267 }
    268 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
    269 __attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
    270     __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
    271 }
    272 __attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object1);
    273 __attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object2){
    274     __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
    275 }
    276 signed int _X3vtrFi___1(){
    277     __attribute__ ((unused)) signed int _X11_retval_vtri_1;
    278     __attribute__ ((unused,unused,used)) signed int _X2t1i_2;
    279     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t2PPi_2;
    280     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
    281     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
    282     __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
    283     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
    284 }
    285 signed int _X4ipd1Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int _X1pi_1, __attribute__ ((unused,unused,unused)) signed int _X1qi_1);
    286 signed int _X4ipd1Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int _X1pi_1, __attribute__ ((unused,unused,unused)) signed int _X1qi_1){
    287     __attribute__ ((unused)) signed int _X12_retval_ipd1i_1;
    288 }
    289 signed int _X4ipd2Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1);
    290 signed int _X4ipd2Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1){
    291     __attribute__ ((unused)) signed int _X12_retval_ipd2i_1;
    292 }
    293 signed int _X4ipd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1);
    294 signed int _X4ipd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1){
    295     __attribute__ ((unused)) signed int _X12_retval_ipd3i_1;
    296 }
    297 signed int _X4ipd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X1pFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*_X1qFi___1)());
    298 signed int _X4ipd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X1pFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*_X1qFi___1)()){
    299     __attribute__ ((unused)) signed int _X12_retval_ipd4i_1;
    300 }
    301 signed int _X4tpr1Fi_i__1(__attribute__ ((unused,unused,unused)) signed int _X3Fooi_1);
    302 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
    303 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
    304 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object4)(__attribute__ ((unused,unused)) signed int __anonymous_object5[((unsigned long int )5)]));
    305 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
    306 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
    307 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object6)(__attribute__ ((unused)) signed int (*__anonymous_object7)(__attribute__ ((unused,unused)) signed int __anonymous_object8)));
    308 signed int _X2adFi___1(){
    309     __attribute__ ((unused)) signed int _X10_retval_adi_1;
    310     __attribute__ ((used,unused)) signed int _X3ad1i_2;
    311     __attribute__ ((unused,unused,unused)) signed int *_X3ad2Pi_2;
    312     __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned long int )5)];
    313     __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned long int )10)];
    314     __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
    315     __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
     82    __attribute__ ((unused)) signed int __f1__i_1;
     83    __attribute__ ((unused)) signed int __f2__i_1;
     84    __attribute__ ((unused,unused)) signed int __f3__i_1;
     85    __attribute__ ((unused)) signed int __f4__i_1;
     86    __attribute__ ((unused,unused)) signed int __f5__i_1;
     87    __attribute__ ((used,packed)) signed int __f6__i_1;
     88    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
     89    __attribute__ ((used,used,unused)) signed int __f8__i_1;
     90    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
     91};
     92static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     93static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     94static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     95static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     96static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
     97static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
     98static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
     99static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
     100static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
     101static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
     102static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
     103static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
     104static inline void ___constructor__F_4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
     105static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     106    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
     107    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     108    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     109    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     110    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     111    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     112    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     113    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     114    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     115}
     116static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     117    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     118    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     119    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     120    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     121    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     122    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
     123    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     124    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
     125    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
     126}
     127static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     128    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
     129    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
     130    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
     131    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
     132    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
     133    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
     134    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
     135    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
     136    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
     137}
     138static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     139    struct Fdl ___ret__4sFdl_1;
     140    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     141    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     142    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     143    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     144    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     145    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
     146    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     147    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     148    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     149    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
     150    return ___ret__4sFdl_1;
     151}
     152static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
     153    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     154    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     155    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     156    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     157    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     158    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     159    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     160    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     161    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     162}
     163static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
     164    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     165    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     166    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     167    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     168    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     169    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     170    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     171    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     172    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     173}
     174static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
     175    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     176    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     177    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     178    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     179    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     180    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     181    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     182    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     183    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     184}
     185static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
     186    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     187    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     188    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     189    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     190    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     191    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     192    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     193    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     194    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     195}
     196static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
     197    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     198    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     199    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     200    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     201    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     202    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     203    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     204    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     205    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     206}
     207static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
     208    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     209    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     210    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     211    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     212    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     213    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     214    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     215    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     216    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     217}
     218static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
     219    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     220    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     221    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     222    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     223    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     224    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     225    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     226    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     227    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     228}
     229static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
     230    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     231    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     232    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     233    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     234    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     235    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     236    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     237    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     238    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     239}
     240static inline void ___constructor__F_4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
     241    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     242    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     243    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     244    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     245    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     246    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     247    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     248    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     249    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
     250}
     251__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     252__attribute__ ((used,used)) const signed int __vd1__Ci_1;
     253__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
     254__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
     255__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
     256__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned long int )5)];
     257__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned long int )5)];
     258__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
     259__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
     260__attribute__ ((unused,used)) signed int __f1__Fi___1();
     261__attribute__ ((unused)) signed int __f1__Fi___1(){
     262    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     263}
     264__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
     265__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
     266    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
     267}
     268__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object0))[];
     269__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     270    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
     271}
     272__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object1);
     273__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object2){
     274    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object3);
     275}
     276signed int __vtr__Fi___1(){
     277    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
     278    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
     279    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
     280    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned long int )5)];
     281    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned long int )5)];
     282    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
     283    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
     284}
     285signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
     286signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
     287    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
     288}
     289signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     290signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     291    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
     292}
     293signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     294signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     295    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
     296}
     297signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
     298signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
     299    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
     300}
     301signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
     302signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
     303signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
     304signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object4)(__attribute__ ((unused,unused)) signed int __anonymous_object5[((unsigned long int )5)]));
     305signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     306signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     307signed int __tpr7__Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object6)(__attribute__ ((unused)) signed int (*__anonymous_object7)(__attribute__ ((unused,unused)) signed int __anonymous_object8)));
     308signed int __ad__Fi___1(){
     309    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     310    __attribute__ ((used,unused)) signed int __ad1__i_2;
     311    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
     312    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned long int )5)];
     313    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned long int )10)];
     314    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
     315    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
    316316    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
    317317    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
    … …  
    320320    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    321321    struct __attribute__ ((unused)) __anonymous3 {
    322         signed int _X1ii_2;
     322        signed int __i__i_2;
    323323    };
    324     inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    325         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
    326     }
    327     inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    328         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
    329     }
    330     inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    331         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
    332     }
    333     inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    334         struct __anonymous3 _X4_retS12__anonymous3_2;
    335         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
    336         ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
    337         return _X4_retS12__anonymous3_2;
    338     }
    339     inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
    340         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     324    inline void ___constructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
     325        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ?{} */);
     326    }
     327    inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
     328        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2) /* ?{} */);
     329    }
     330    inline void ___destructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
     331        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ^?{} */);
     332    }
     333    inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
     334        struct __anonymous3 ___ret__13s__anonymous3_2;
     335        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2));
     336        ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___2((&___ret__13s__anonymous3_2), (*___dst__13s__anonymous3_2)));
     337        return ___ret__13s__anonymous3_2;
     338    }
     339    inline void ___constructor__F_13s__anonymous3i_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, signed int __i__i_2){
     340        ((void)((*___dst__13s__anonymous3_2).__i__i_2=__i__i_2) /* ?{} */);
    341341    }
    342342    ((void)sizeof(struct __anonymous3 ));
    343343    enum __attribute__ ((unused)) __anonymous4 {
    344         _X1RKM12__anonymous4_2,
     344        __R__C13e__anonymous4_2,
    345345    };
    346     inline void _X12_constructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
    347     }
    348     inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    349         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
    350     }
    351     inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
    352     }
    353     inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    354         enum __anonymous4 _X4_retM12__anonymous4_2;
    355         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
    356         ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
    357         return _X4_retM12__anonymous4_2;
     346    inline void ___constructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
     347    }
     348    inline void ___constructor__F_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
     349        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2) /* ?{} */);
     350    }
     351    inline void ___destructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
     352    }
     353    inline enum __anonymous4 ___operator_assign__F13e__anonymous4_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
     354        enum __anonymous4 ___ret__13e__anonymous4_2;
     355        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2));
     356        ((void)(___ret__13e__anonymous4_2=(*___dst__13e__anonymous4_2)) /* ?{} */);
     357        return ___ret__13e__anonymous4_2;
    358358    }
    359359    ((void)sizeof(enum __anonymous4 ));
    360360}
    361 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
    362 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object11, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12);
    363 signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object13, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object14);
    364 signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)());
    365 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __anonymous_object18), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object19)(__attribute__ ((unused)) signed int __anonymous_object20));
    366 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)());
    367 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
     361signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
     362signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object11, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12);
     363signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object13, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object14);
     364signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)());
     365signed int __apd5__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __anonymous_object18), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object19)(__attribute__ ((unused)) signed int __anonymous_object20));
     366signed int __apd6__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)());
     367signed int __apd7__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
    368368struct Vad {
    369369    __attribute__ ((unused)) signed int __anonymous_object27:4;
    … …  
    371371    __attribute__ ((unused,unused)) signed int __anonymous_object29:6;
    372372};
    373 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1);
    374 static inline void _X12_constructorFv_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1);
    375 static inline void _X11_destructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1);
    376 static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1);
    377 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1){
    378 }
    379 static inline void _X12_constructorFv_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    380 }
    381 static inline void _X11_destructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1){
    382 }
    383 static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    384     struct Vad _X4_retS3Vad_1;
    385     ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
    386     return _X4_retS3Vad_1;
    387 }
     373static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     374static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     375static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     376static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     377static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     378}
     379static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     380}
     381static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     382}
     383static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     384    struct Vad ___ret__4sVad_1;
     385    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
     386    return ___ret__4sVad_1;
     387}

  • tests/.expect/attributes.x86.txt

    r6d44da1 r341bb80  
    1 signed int _X2laFi___1(){
    2     __attribute__ ((unused)) signed int _X10_retval_lai_1;
     1signed int __la__Fi___1(){
     2    __attribute__ ((unused)) signed int ___retval_la__i_1;
    33    L: __attribute__ ((unused)) ((void)1);
    44}
    55struct __attribute__ ((unused)) __anonymous0 {
    66};
    7 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    8 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    9 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    10 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    11 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    12 }
    13 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    14 }
    15 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    16 }
    17 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    18     struct __anonymous0 _X4_retS12__anonymous0_1;
    19     ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    20     return _X4_retS12__anonymous0_1;
     7static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     8static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     9static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     10static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     11static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     12}
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     14}
     15static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     16}
     17static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     18    struct __anonymous0 ___ret__13s__anonymous0_1;
     19    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
     20    return ___ret__13s__anonymous0_1;
    2121}
    2222struct __attribute__ ((unused)) Agn1;
    2323struct __attribute__ ((unused)) Agn2 {
    2424};
    25 static inline void _X12_constructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1);
    26 static inline void _X12_constructorFv_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1);
    27 static inline void _X11_destructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1);
    28 static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1);
    29 static inline void _X12_constructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1){
    30 }
    31 static inline void _X12_constructorFv_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    32 }
    33 static inline void _X11_destructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1){
    34 }
    35 static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    36     struct Agn2 _X4_retS4Agn2_1;
    37     ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
    38     return _X4_retS4Agn2_1;
     25static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     26static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     27static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     28static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     29static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     30}
     31static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     32}
     33static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     34}
     35static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     36    struct Agn2 ___ret__5sAgn2_1;
     37    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
     38    return ___ret__5sAgn2_1;
    3939}
    4040enum __attribute__ ((unused)) __anonymous1 {
    41     _X2E1KM12__anonymous1_1,
     41    __E1__C13e__anonymous1_1,
    4242};
    4343enum __attribute__ ((unused)) Agn3;
    4444enum __attribute__ ((packed)) Agn3 {
    45     _X2E2KM4Agn3_1,
     45    __E2__C5eAgn3_1,
    4646};
    4747struct __attribute__ ((unused)) __anonymous2 {
    4848};
    49 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    50 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    51 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    52 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    53 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    54 }
    55 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    56 }
    57 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    58 }
    59 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    60     struct __anonymous2 _X4_retS12__anonymous2_1;
    61     ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    62     return _X4_retS12__anonymous2_1;
     49static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     50static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     51static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     52static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     53static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     54}
     55static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     56}
     57static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     58}
     59static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     60    struct __anonymous2 ___ret__13s__anonymous2_1;
     61    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__anonymous2_1)));
     62    return ___ret__13s__anonymous2_1;
    6363}
    6464struct __attribute__ ((unused)) Agn4 {
    6565};
    66 static inline void _X12_constructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1);
    67 static inline void _X12_constructorFv_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1);
    68 static inline void _X11_destructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1);
    69 static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1);
    70 static inline void _X12_constructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1){
    71 }
    72 static inline void _X12_constructorFv_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    73 }
    74 static inline void _X11_destructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1){
    75 }
    76 static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    77     struct Agn4 _X4_retS4Agn4_1;
    78     ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
    79     return _X4_retS4Agn4_1;
     66static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
     67static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
     68static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
     69static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
     70static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
     71}
     72static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
     73}
     74static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
     75}
     76static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
     77    struct Agn4 ___ret__5sAgn4_1;
     78    ((void)___constructor__F_5sAgn45sAgn4_autogen___1((&___ret__5sAgn4_1), (*___dst__5sAgn4_1)));
     79    return ___ret__5sAgn4_1;
    8080}
    8181struct Fdl {
    82     __attribute__ ((unused)) signed int _X2f1i_1;
    83     __attribute__ ((unused)) signed int _X2f2i_1;
    84     __attribute__ ((unused,unused)) signed int _X2f3i_1;
    85     __attribute__ ((unused)) signed int _X2f4i_1;
    86     __attribute__ ((unused,unused)) signed int _X2f5i_1;
    87     __attribute__ ((used,packed)) signed int _X2f6i_1;
    88     __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
    89     __attribute__ ((used,used,unused)) signed int _X2f8i_1;
    90     __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
    91 };
    92 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
    93 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1);
    94 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
    95 static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1);
    96 static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1);
    97 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1);
    98 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1);
    99 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1);
    100 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1);
    101 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1);
    102 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1);
    103 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1);
    104 static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
    105 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    106     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
    107     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    108     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    109     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    110     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    111     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    112     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    113     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    114     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    115 }
    116 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    117     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
    118     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
    119     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
    120     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
    121     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
    122     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
    123     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
    124     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
    125     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
    126 }
    127 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    128     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
    129     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
    130     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
    131     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
    132     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
    133     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
    134     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
    135     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
    136     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
    137 }
    138 static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    139     struct Fdl _X4_retS3Fdl_1;
    140     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
    141     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
    142     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
    143     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
    144     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
    145     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
    146     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
    147     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
    148     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
    149     ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
    150     return _X4_retS3Fdl_1;
    151 }
    152 static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1){
    153     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    154     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    155     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    156     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    157     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    158     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    159     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    160     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    161     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    162 }
    163 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
    164     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    165     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    166     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    167     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    168     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    169     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    170     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    171     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    172     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    173 }
    174 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
    175     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    176     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    177     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    178     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    179     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    180     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    181     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    182     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    183     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    184 }
    185 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
    186     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    187     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    188     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    189     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    190     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    191     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    192     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    193     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    194     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    195 }
    196 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
    197     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    198     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    199     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    200     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    201     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    202     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    203     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    204     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    205     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    206 }
    207 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
    208     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    209     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    210     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    211     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    212     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    213     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    214     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    215     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    216     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    217 }
    218 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
    219     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    220     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    221     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    222     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    223     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    224     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    225     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    226     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    227     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    228 }
    229 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
    230     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    231     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    232     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    233     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    234     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    235     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    236     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    237     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    238     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    239 }
    240 static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
    241     ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    242     ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    243     ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    244     ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    245     ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    246     ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    247     ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    248     ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    249     ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
    250 }
    251 __attribute__ ((unused)) signed int _X1fFi___1() asm ( "xyz" );
    252 __attribute__ ((used,used)) const signed int _X3vd1Ki_1;
    253 __attribute__ ((used,unused)) const signed int _X3vd2Ki_1;
    254 __attribute__ ((used,used,used,used)) const signed int *_X3vd3PKi_1;
    255 __attribute__ ((used,used,unused,used,unused)) const signed int *_X3vd4PKi_1;
    256 __attribute__ ((used,used,used)) const signed int _X3vd5A0Ki_1[((unsigned int )5)];
    257 __attribute__ ((used,used,unused,used)) const signed int _X3vd6A0Ki_1[((unsigned int )5)];
    258 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
    259 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
    260 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
    261 __attribute__ ((unused)) signed int _X2f1Fi___1(){
    262     __attribute__ ((unused)) signed int _X10_retval_f1i_1;
    263 }
    264 __attribute__ ((unused,unused,unused,used)) signed int **const _X2f2FPPi___1();
    265 __attribute__ ((unused,unused,unused)) signed int **const _X2f2FPPi___1(){
    266     __attribute__ ((unused)) signed int **const _X10_retval_f2KPPi_1;
    267 }
    268 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
    269 __attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
    270     __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
    271 }
    272 __attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object1);
    273 __attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object2){
    274     __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
    275 }
    276 signed int _X3vtrFi___1(){
    277     __attribute__ ((unused)) signed int _X11_retval_vtri_1;
    278     __attribute__ ((unused,unused,used)) signed int _X2t1i_2;
    279     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t2PPi_2;
    280     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned int )5)];
    281     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned int )5)];
    282     __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
    283     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
    284 }
    285 signed int _X4ipd1Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int _X1pi_1, __attribute__ ((unused,unused,unused)) signed int _X1qi_1);
    286 signed int _X4ipd1Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int _X1pi_1, __attribute__ ((unused,unused,unused)) signed int _X1qi_1){
    287     __attribute__ ((unused)) signed int _X12_retval_ipd1i_1;
    288 }
    289 signed int _X4ipd2Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1);
    290 signed int _X4ipd2Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1){
    291     __attribute__ ((unused)) signed int _X12_retval_ipd2i_1;
    292 }
    293 signed int _X4ipd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1);
    294 signed int _X4ipd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1){
    295     __attribute__ ((unused)) signed int _X12_retval_ipd3i_1;
    296 }
    297 signed int _X4ipd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X1pFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*_X1qFi___1)());
    298 signed int _X4ipd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X1pFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*_X1qFi___1)()){
    299     __attribute__ ((unused)) signed int _X12_retval_ipd4i_1;
    300 }
    301 signed int _X4tpr1Fi_i__1(__attribute__ ((unused,unused,unused)) signed int _X3Fooi_1);
    302 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
    303 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
    304 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object4)(__attribute__ ((unused,unused)) signed int __anonymous_object5[((unsigned int )5)]));
    305 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
    306 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
    307 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object6)(__attribute__ ((unused)) signed int (*__anonymous_object7)(__attribute__ ((unused,unused)) signed int __anonymous_object8)));
    308 signed int _X2adFi___1(){
    309     __attribute__ ((unused)) signed int _X10_retval_adi_1;
    310     __attribute__ ((used,unused)) signed int _X3ad1i_2;
    311     __attribute__ ((unused,unused,unused)) signed int *_X3ad2Pi_2;
    312     __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned int )5)];
    313     __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned int )10)];
    314     __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
    315     __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
     82    __attribute__ ((unused)) signed int __f1__i_1;
     83    __attribute__ ((unused)) signed int __f2__i_1;
     84    __attribute__ ((unused,unused)) signed int __f3__i_1;
     85    __attribute__ ((unused)) signed int __f4__i_1;
     86    __attribute__ ((unused,unused)) signed int __f5__i_1;
     87    __attribute__ ((used,packed)) signed int __f6__i_1;
     88    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
     89    __attribute__ ((used,used,unused)) signed int __f8__i_1;
     90    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
     91};
     92static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     93static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     94static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     95static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     96static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
     97static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
     98static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
     99static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
     100static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
     101static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
     102static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
     103static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
     104static inline void ___constructor__F_4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
     105static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     106    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
     107    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     108    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     109    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     110    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     111    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     112    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     113    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     114    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     115}
     116static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     117    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     118    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     119    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     120    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     121    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     122    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
     123    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     124    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
     125    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
     126}
     127static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     128    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
     129    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
     130    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
     131    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
     132    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
     133    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
     134    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
     135    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
     136    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
     137}
     138static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     139    struct Fdl ___ret__4sFdl_1;
     140    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     141    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     142    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     143    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     144    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     145    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
     146    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     147    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     148    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     149    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
     150    return ___ret__4sFdl_1;
     151}
     152static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
     153    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     154    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     155    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     156    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     157    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     158    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     159    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     160    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     161    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     162}
     163static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
     164    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     165    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     166    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     167    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     168    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     169    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     170    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     171    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     172    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     173}
     174static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
     175    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     176    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     177    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     178    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     179    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     180    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     181    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     182    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     183    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     184}
     185static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
     186    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     187    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     188    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     189    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     190    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     191    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     192    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     193    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     194    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     195}
     196static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
     197    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     198    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     199    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     200    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     201    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     202    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     203    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     204    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     205    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     206}
     207static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
     208    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     209    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     210    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     211    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     212    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     213    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     214    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     215    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     216    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     217}
     218static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
     219    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     220    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     221    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     222    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     223    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     224    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     225    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     226    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     227    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     228}
     229static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
     230    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     231    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     232    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     233    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     234    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     235    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     236    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     237    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     238    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     239}
     240static inline void ___constructor__F_4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
     241    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     242    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     243    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     244    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     245    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     246    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     247    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     248    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     249    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
     250}
     251__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     252__attribute__ ((used,used)) const signed int __vd1__Ci_1;
     253__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
     254__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
     255__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
     256__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)];
     257__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)];
     258__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
     259__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
     260__attribute__ ((unused,used)) signed int __f1__Fi___1();
     261__attribute__ ((unused)) signed int __f1__Fi___1(){
     262    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     263}
     264__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
     265__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
     266    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
     267}
     268__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object0))[];
     269__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     270    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
     271}
     272__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object1);
     273__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object2){
     274    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object3);
     275}
     276signed int __vtr__Fi___1(){
     277    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
     278    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
     279    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
     280    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned int )5)];
     281    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned int )5)];
     282    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
     283    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
     284}
     285signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
     286signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
     287    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
     288}
     289signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     290signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     291    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
     292}
     293signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
     294signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
     295    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
     296}
     297signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
     298signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
     299    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
     300}
     301signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
     302signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
     303signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
     304signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object4)(__attribute__ ((unused,unused)) signed int __anonymous_object5[((unsigned int )5)]));
     305signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     306signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     307signed int __tpr7__Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object6)(__attribute__ ((unused)) signed int (*__anonymous_object7)(__attribute__ ((unused,unused)) signed int __anonymous_object8)));
     308signed int __ad__Fi___1(){
     309    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     310    __attribute__ ((used,unused)) signed int __ad1__i_2;
     311    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
     312    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned int )5)];
     313    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned int )10)];
     314    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
     315    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
    316316    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
    317317    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
    … …  
    320320    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    321321    struct __attribute__ ((unused)) __anonymous3 {
    322         signed int _X1ii_2;
     322        signed int __i__i_2;
    323323    };
    324     inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    325         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
    326     }
    327     inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    328         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
    329     }
    330     inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    331         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
    332     }
    333     inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    334         struct __anonymous3 _X4_retS12__anonymous3_2;
    335         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
    336         ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
    337         return _X4_retS12__anonymous3_2;
    338     }
    339     inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
    340         ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     324    inline void ___constructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
     325        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ?{} */);
     326    }
     327    inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
     328        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2) /* ?{} */);
     329    }
     330    inline void ___destructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
     331        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ^?{} */);
     332    }
     333    inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
     334        struct __anonymous3 ___ret__13s__anonymous3_2;
     335        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2));
     336        ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___2((&___ret__13s__anonymous3_2), (*___dst__13s__anonymous3_2)));
     337        return ___ret__13s__anonymous3_2;
     338    }
     339    inline void ___constructor__F_13s__anonymous3i_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, signed int __i__i_2){
     340        ((void)((*___dst__13s__anonymous3_2).__i__i_2=__i__i_2) /* ?{} */);
    341341    }
    342342    ((void)sizeof(struct __anonymous3 ));
    343343    enum __attribute__ ((unused)) __anonymous4 {
    344         _X1RKM12__anonymous4_2,
     344        __R__C13e__anonymous4_2,
    345345    };
    346     inline void _X12_constructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
    347     }
    348     inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    349         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
    350     }
    351     inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
    352     }
    353     inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    354         enum __anonymous4 _X4_retM12__anonymous4_2;
    355         ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
    356         ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
    357         return _X4_retM12__anonymous4_2;
     346    inline void ___constructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
     347    }
     348    inline void ___constructor__F_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
     349        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2) /* ?{} */);
     350    }
     351    inline void ___destructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
     352    }
     353    inline enum __anonymous4 ___operator_assign__F13e__anonymous4_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
     354        enum __anonymous4 ___ret__13e__anonymous4_2;
     355        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2));
     356        ((void)(___ret__13e__anonymous4_2=(*___dst__13e__anonymous4_2)) /* ?{} */);
     357        return ___ret__13e__anonymous4_2;
    358358    }
    359359    ((void)sizeof(enum __anonymous4 ));
    360360}
    361 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
    362 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object11, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12);
    363 signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object13, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object14);
    364 signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)());
    365 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __anonymous_object18), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object19)(__attribute__ ((unused)) signed int __anonymous_object20));
    366 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)());
    367 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
     361signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
     362signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object11, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12);
     363signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object13, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object14);
     364signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)());
     365signed int __apd5__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __anonymous_object18), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object19)(__attribute__ ((unused)) signed int __anonymous_object20));
     366signed int __apd6__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)());
     367signed int __apd7__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
    368368struct Vad {
    369369    __attribute__ ((unused)) signed int __anonymous_object27:4;
    … …  
    371371    __attribute__ ((unused,unused)) signed int __anonymous_object29:6;
    372372};
    373 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1);
    374 static inline void _X12_constructorFv_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1);
    375 static inline void _X11_destructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1);
    376 static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1);
    377 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1){
    378 }
    379 static inline void _X12_constructorFv_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    380 }
    381 static inline void _X11_destructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1){
    382 }
    383 static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    384     struct Vad _X4_retS3Vad_1;
    385     ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
    386     return _X4_retS3Vad_1;
    387 }
     373static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     374static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     375static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     376static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     377static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     378}
     379static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     380}
     381static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     382}
     383static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     384    struct Vad ___ret__4sVad_1;
     385    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
     386    return ___ret__4sVad_1;
     387}

  • tests/.expect/declarationSpecifier.x64.txt

    r6d44da1 r341bb80  
    1 volatile const signed short int _X2x1KVs_1;
    2 static volatile const signed short int _X2x2KVs_1;
    3 static volatile const signed short int _X2x3KVs_1;
    4 static volatile const signed short int _X2x4KVs_1;
    5 static volatile const signed short int _X2x5KVs_1;
    6 static volatile const signed short int _X2x6KVs_1;
    7 static volatile const signed short int _X2x7KVs_1;
    8 static volatile const signed short int _X2x8KVs_1;
     1volatile const signed short int __x1__CVs_1;
     2static volatile const signed short int __x2__CVs_1;
     3static volatile const signed short int __x3__CVs_1;
     4static volatile const signed short int __x4__CVs_1;
     5static volatile const signed short int __x5__CVs_1;
     6static volatile const signed short int __x6__CVs_1;
     7static volatile const signed short int __x7__CVs_1;
     8static volatile const signed short int __x8__CVs_1;
    99struct __anonymous0 {
    10     signed int _X1ii_1;
    11 };
    12 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    13 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    14 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    15 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    16 static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1);
    17 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    18     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
    19 }
    20 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    21     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
    22 }
    23 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    24     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
    25 }
    26 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    27     struct __anonymous0 _X4_retS12__anonymous0_1;
    28     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
    29     ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    30     return _X4_retS12__anonymous0_1;
    31 }
    32 static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1){
    33     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
    34 }
    35 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
     10    signed int __i__i_1;
     11};
     12static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     14static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     15static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     16static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1);
     17static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     18    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ?{} */);
     19}
     20static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     21    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
     22}
     23static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     24    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ^?{} */);
     25}
     26static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     27    struct __anonymous0 ___ret__13s__anonymous0_1;
     28    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     29    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
     30    return ___ret__13s__anonymous0_1;
     31}
     32static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1){
     33    ((void)((*___dst__13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
     34}
     35volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
    3636struct __anonymous1 {
    37     signed int _X1ii_1;
    38 };
    39 static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1);
    40 static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1);
    41 static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1);
    42 static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1);
    43 static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1);
    44 static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    45     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
    46 }
    47 static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    48     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
    49 }
    50 static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    51     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
    52 }
    53 static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    54     struct __anonymous1 _X4_retS12__anonymous1_1;
    55     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
    56     ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
    57     return _X4_retS12__anonymous1_1;
    58 }
    59 static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1){
    60     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
    61 }
    62 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
     37    signed int __i__i_1;
     38};
     39static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
     40static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
     41static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
     42static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
     43static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1);
     44static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
     45    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ?{} */);
     46}
     47static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     48    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
     49}
     50static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
     51    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ^?{} */);
     52}
     53static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     54    struct __anonymous1 ___ret__13s__anonymous1_1;
     55    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     56    ((void)___constructor__F_13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__13s__anonymous1_1)));
     57    return ___ret__13s__anonymous1_1;
     58}
     59static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1){
     60    ((void)((*___dst__13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
     61}
     62volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
    6363struct __anonymous2 {
    64     signed int _X1ii_1;
    65 };
    66 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    67 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    68 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    69 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    70 static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1);
    71 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    72     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
    73 }
    74 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    75     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
    76 }
    77 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    78     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
    79 }
    80 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    81     struct __anonymous2 _X4_retS12__anonymous2_1;
    82     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
    83     ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    84     return _X4_retS12__anonymous2_1;
    85 }
    86 static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1){
    87     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
    88 }
    89 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
     64    signed int __i__i_1;
     65};
     66static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     67static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     68static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     69static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     70static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1);
     71static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     72    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ?{} */);
     73}
     74static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     75    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
     76}
     77static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     78    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ^?{} */);
     79}
     80static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     81    struct __anonymous2 ___ret__13s__anonymous2_1;
     82    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     83    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__anonymous2_1)));
     84    return ___ret__13s__anonymous2_1;
     85}
     86static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1){
     87    ((void)((*___dst__13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
     88}
     89volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
    9090struct __anonymous3 {
    91     signed int _X1ii_1;
    92 };
    93 static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1);
    94 static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1);
    95 static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1);
    96 static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1);
    97 static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1);
    98 static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    99     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
    100 }
    101 static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    102     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
    103 }
    104 static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    105     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
    106 }
    107 static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    108     struct __anonymous3 _X4_retS12__anonymous3_1;
    109     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
    110     ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
    111     return _X4_retS12__anonymous3_1;
    112 }
    113 static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1){
    114     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
    115 }
    116 static volatile const struct __anonymous3 _X3x13KVS12__anonymous3_1;
     91    signed int __i__i_1;
     92};
     93static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
     94static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
     95static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
     96static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
     97static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1);
     98static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
     99    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ?{} */);
     100}
     101static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     102    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
     103}
     104static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
     105    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ^?{} */);
     106}
     107static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     108    struct __anonymous3 ___ret__13s__anonymous3_1;
     109    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     110    ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__13s__anonymous3_1)));
     111    return ___ret__13s__anonymous3_1;
     112}
     113static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1){
     114    ((void)((*___dst__13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
     115}
     116static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
    117117struct __anonymous4 {
    118     signed int _X1ii_1;
    119 };
    120 static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1);
    121 static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1);
    122 static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1);
    123 static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1);
    124 static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1);
    125 static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    126     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
    127 }
    128 static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    129     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
    130 }
    131 static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    132     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
    133 }
    134 static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    135     struct __anonymous4 _X4_retS12__anonymous4_1;
    136     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
    137     ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
    138     return _X4_retS12__anonymous4_1;
    139 }
    140 static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1){
    141     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
    142 }
    143 static volatile const struct __anonymous4 _X3x14KVS12__anonymous4_1;
     118    signed int __i__i_1;
     119};
     120static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
     121static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
     122static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
     123static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
     124static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1);
     125static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
     126    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ?{} */);
     127}
     128static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     129    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
     130}
     131static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
     132    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ^?{} */);
     133}
     134static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     135    struct __anonymous4 ___ret__13s__anonymous4_1;
     136    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     137    ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__13s__anonymous4_1)));
     138    return ___ret__13s__anonymous4_1;
     139}
     140static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1){
     141    ((void)((*___dst__13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
     142}
     143static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
    144144struct __anonymous5 {
    145     signed int _X1ii_1;
    146 };
    147 static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1);
    148 static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1);
    149 static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1);
    150 static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1);
    151 static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1);
    152 static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    153     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
    154 }
    155 static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    156     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
    157 }
    158 static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    159     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
    160 }
    161 static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    162     struct __anonymous5 _X4_retS12__anonymous5_1;
    163     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
    164     ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
    165     return _X4_retS12__anonymous5_1;
    166 }
    167 static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1){
    168     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
    169 }
    170 static volatile const struct __anonymous5 _X3x15KVS12__anonymous5_1;
     145    signed int __i__i_1;
     146};
     147static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
     148static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
     149static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
     150static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
     151static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1);
     152static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
     153    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ?{} */);
     154}
     155static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     156    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
     157}
     158static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
     159    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ^?{} */);
     160}
     161static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     162    struct __anonymous5 ___ret__13s__anonymous5_1;
     163    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     164    ((void)___constructor__F_13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__13s__anonymous5_1)));
     165    return ___ret__13s__anonymous5_1;
     166}
     167static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1){
     168    ((void)((*___dst__13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
     169}
     170static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
    171171struct __anonymous6 {
    172     signed int _X1ii_1;
    173 };
    174 static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1);
    175 static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1);
    176 static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1);
    177 static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1);
    178 static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1);
    179 static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    180     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
    181 }
    182 static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    183     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
    184 }
    185 static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    186     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
    187 }
    188 static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    189     struct __anonymous6 _X4_retS12__anonymous6_1;
    190     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
    191     ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
    192     return _X4_retS12__anonymous6_1;
    193 }
    194 static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1){
    195     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
    196 }
    197 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
     172    signed int __i__i_1;
     173};
     174static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
     175static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
     176static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
     177static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
     178static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1);
     179static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
     180    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ?{} */);
     181}
     182static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     183    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
     184}
     185static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
     186    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ^?{} */);
     187}
     188static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     189    struct __anonymous6 ___ret__13s__anonymous6_1;
     190    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     191    ((void)___constructor__F_13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__13s__anonymous6_1)));
     192    return ___ret__13s__anonymous6_1;
     193}
     194static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1){
     195    ((void)((*___dst__13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
     196}
     197static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
    198198struct __anonymous7 {
    199     signed int _X1ii_1;
    200 };
    201 static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
    202 static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
    203 static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
    204 static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
    205 static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
    206 static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    207     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
    208 }
    209 static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    210     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
    211 }
    212 static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    213     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
    214 }
    215 static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    216     struct __anonymous7 _X4_retS12__anonymous7_1;
    217     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
    218     ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
    219     return _X4_retS12__anonymous7_1;
    220 }
    221 static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
    222     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
    223 }
    224 static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
    225 volatile const signed short int _X3x20KVs_1;
    226 static volatile const signed short int _X3x21KVs_1;
    227 static volatile const signed short int _X3x22KVs_1;
    228 static volatile const signed short int _X3x23KVs_1;
    229 static volatile const signed short int _X3x24KVs_1;
    230 static volatile const signed short int _X3x25KVs_1;
    231 static volatile const signed short int _X3x26KVs_1;
    232 static volatile const signed short int _X3x27KVs_1;
     199    signed int __i__i_1;
     200};
     201static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
     202static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
     203static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
     204static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
     205static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1);
     206static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
     207    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ?{} */);
     208}
     209static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     210    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
     211}
     212static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
     213    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ^?{} */);
     214}
     215static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     216    struct __anonymous7 ___ret__13s__anonymous7_1;
     217    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     218    ((void)___constructor__F_13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__13s__anonymous7_1)));
     219    return ___ret__13s__anonymous7_1;
     220}
     221static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1){
     222    ((void)((*___dst__13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
     223}
     224static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
     225volatile const signed short int __x20__CVs_1;
     226static volatile const signed short int __x21__CVs_1;
     227static volatile const signed short int __x22__CVs_1;
     228static volatile const signed short int __x23__CVs_1;
     229static volatile const signed short int __x24__CVs_1;
     230static volatile const signed short int __x25__CVs_1;
     231static volatile const signed short int __x26__CVs_1;
     232static volatile const signed short int __x27__CVs_1;
    233233struct __anonymous8 {
    234     signed short int _X1is_1;
    235 };
    236 static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1);
    237 static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1);
    238 static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1);
    239 static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1);
    240 static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1);
    241 static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    242     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
    243 }
    244 static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    245     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
    246 }
    247 static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    248     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
    249 }
    250 static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    251     struct __anonymous8 _X4_retS12__anonymous8_1;
    252     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
    253     ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
    254     return _X4_retS12__anonymous8_1;
    255 }
    256 static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1){
    257     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
    258 }
    259 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
     234    signed short int __i__s_1;
     235};
     236static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
     237static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
     238static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
     239static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
     240static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1);
     241static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
     242    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ?{} */);
     243}
     244static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     245    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
     246}
     247static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
     248    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ^?{} */);
     249}
     250static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     251    struct __anonymous8 ___ret__13s__anonymous8_1;
     252    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     253    ((void)___constructor__F_13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__13s__anonymous8_1)));
     254    return ___ret__13s__anonymous8_1;
     255}
     256static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1){
     257    ((void)((*___dst__13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
     258}
     259volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
    260260struct __anonymous9 {
    261     signed short int _X1is_1;
    262 };
    263 static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1);
    264 static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1);
    265 static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1);
    266 static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1);
    267 static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1);
    268 static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    269     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
    270 }
    271 static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    272     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
    273 }
    274 static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    275     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
    276 }
    277 static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    278     struct __anonymous9 _X4_retS12__anonymous9_1;
    279     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
    280     ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
    281     return _X4_retS12__anonymous9_1;
    282 }
    283 static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1){
    284     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
    285 }
    286 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
     261    signed short int __i__s_1;
     262};
     263static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
     264static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
     265static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
     266static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
     267static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1);
     268static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
     269    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ?{} */);
     270}
     271static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     272    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
     273}
     274static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
     275    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ^?{} */);
     276}
     277static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     278    struct __anonymous9 ___ret__13s__anonymous9_1;
     279    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     280    ((void)___constructor__F_13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__13s__anonymous9_1)));
     281    return ___ret__13s__anonymous9_1;
     282}
     283static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1){
     284    ((void)((*___dst__13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
     285}
     286volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
    287287struct __anonymous10 {
    288     signed short int _X1is_1;
    289 };
    290 static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1);
    291 static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1);
    292 static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1);
    293 static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1);
    294 static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1);
    295 static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    296     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
    297 }
    298 static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    299     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
    300 }
    301 static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    302     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
    303 }
    304 static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    305     struct __anonymous10 _X4_retS13__anonymous10_1;
    306     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
    307     ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
    308     return _X4_retS13__anonymous10_1;
    309 }
    310 static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1){
    311     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
    312 }
    313 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
     288    signed short int __i__s_1;
     289};
     290static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
     291static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
     292static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
     293static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
     294static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1);
     295static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
     296    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ?{} */);
     297}
     298static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     299    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
     300}
     301static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
     302    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ^?{} */);
     303}
     304static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     305    struct __anonymous10 ___ret__14s__anonymous10_1;
     306    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     307    ((void)___constructor__F_14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__14s__anonymous10_1)));
     308    return ___ret__14s__anonymous10_1;
     309}
     310static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1){
     311    ((void)((*___dst__14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
     312}
     313volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
    314314struct __anonymous11 {
    315     signed short int _X1is_1;
    316 };
    317 static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1);
    318 static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1);
    319 static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1);
    320 static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1);
    321 static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1);
    322 static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    323     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
    324 }
    325 static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    326     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
    327 }
    328 static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    329     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
    330 }
    331 static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    332     struct __anonymous11 _X4_retS13__anonymous11_1;
    333     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
    334     ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
    335     return _X4_retS13__anonymous11_1;
    336 }
    337 static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1){
    338     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
    339 }
    340 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
     315    signed short int __i__s_1;
     316};
     317static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
     318static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
     319static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
     320static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
     321static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1);
     322static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
     323    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ?{} */);
     324}
     325static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     326    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
     327}
     328static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
     329    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ^?{} */);
     330}
     331static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     332    struct __anonymous11 ___ret__14s__anonymous11_1;
     333    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     334    ((void)___constructor__F_14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__14s__anonymous11_1)));
     335    return ___ret__14s__anonymous11_1;
     336}
     337static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1){
     338    ((void)((*___dst__14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
     339}
     340static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
    341341struct __anonymous12 {
    342     signed short int _X1is_1;
    343 };
    344 static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1);
    345 static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1);
    346 static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1);
    347 static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1);
    348 static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1);
    349 static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    350     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
    351 }
    352 static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    353     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
    354 }
    355 static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    356     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
    357 }
    358 static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    359     struct __anonymous12 _X4_retS13__anonymous12_1;
    360     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
    361     ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
    362     return _X4_retS13__anonymous12_1;
    363 }
    364 static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1){
    365     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
    366 }
    367 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
     342    signed short int __i__s_1;
     343};
     344static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
     345static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
     346static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
     347static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
     348static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1);
     349static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
     350    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ?{} */);
     351}
     352static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     353    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
     354}
     355static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
     356    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ^?{} */);
     357}
     358static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     359    struct __anonymous12 ___ret__14s__anonymous12_1;
     360    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     361    ((void)___constructor__F_14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__14s__anonymous12_1)));
     362    return ___ret__14s__anonymous12_1;
     363}
     364static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1){
     365    ((void)((*___dst__14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
     366}
     367static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
    368368struct __anonymous13 {
    369     signed short int _X1is_1;
    370 };
    371 static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1);
    372 static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1);
    373 static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1);
    374 static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1);
    375 static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1);
    376 static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    377     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
    378 }
    379 static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    380     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
    381 }
    382 static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    383     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
    384 }
    385 static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    386     struct __anonymous13 _X4_retS13__anonymous13_1;
    387     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
    388     ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
    389     return _X4_retS13__anonymous13_1;
    390 }
    391 static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1){
    392     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
    393 }
    394 static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
     369    signed short int __i__s_1;
     370};
     371static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
     372static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
     373static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
     374static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
     375static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1);
     376static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
     377    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ?{} */);
     378}
     379static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     380    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
     381}
     382static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
     383    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ^?{} */);
     384}
     385static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     386    struct __anonymous13 ___ret__14s__anonymous13_1;
     387    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     388    ((void)___constructor__F_14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__14s__anonymous13_1)));
     389    return ___ret__14s__anonymous13_1;
     390}
     391static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1){
     392    ((void)((*___dst__14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
     393}
     394static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
    395395struct __anonymous14 {
    396     signed short int _X1is_1;
    397 };
    398 static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
    399 static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
    400 static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
    401 static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
    402 static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
    403 static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    404     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
    405 }
    406 static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    407     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
    408 }
    409 static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    410     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
    411 }
    412 static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    413     struct __anonymous14 _X4_retS13__anonymous14_1;
    414     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
    415     ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
    416     return _X4_retS13__anonymous14_1;
    417 }
    418 static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
    419     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
    420 }
    421 static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
     396    signed short int __i__s_1;
     397};
     398static inline void ___constructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
     399static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
     400static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
     401static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
     402static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1);
     403static inline void ___constructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
     404    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ?{} */);
     405}
     406static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     407    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
     408}
     409static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
     410    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ^?{} */);
     411}
     412static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     413    struct __anonymous14 ___ret__14s__anonymous14_1;
     414    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     415    ((void)___constructor__F_14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__14s__anonymous14_1)));
     416    return ___ret__14s__anonymous14_1;
     417}
     418static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1){
     419    ((void)((*___dst__14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
     420}
     421static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
    422422struct __anonymous15 {
    423     signed short int _X1is_1;
    424 };
    425 static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
    426 static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
    427 static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
    428 static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
    429 static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
    430 static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    431     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
    432 }
    433 static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    434     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
    435 }
    436 static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    437     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
    438 }
    439 static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    440     struct __anonymous15 _X4_retS13__anonymous15_1;
    441     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
    442     ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
    443     return _X4_retS13__anonymous15_1;
    444 }
    445 static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
    446     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
    447 }
    448 static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
    449 static inline volatile const signed int _X3f11Fi___1();
    450 static inline volatile const signed int _X3f12Fi___1();
    451 static inline volatile const signed int _X3f13Fi___1();
    452 static inline volatile const signed int _X3f14Fi___1();
    453 static inline volatile const signed int _X3f15Fi___1();
    454 static inline volatile const signed int _X3f16Fi___1();
    455 static inline volatile const signed int _X3f17Fi___1();
    456 static inline volatile const signed int _X3f18Fi___1();
    457 static inline volatile const signed short int _X3f21Fs___1();
    458 static inline volatile const signed short int _X3f22Fs___1();
    459 static inline volatile const signed short int _X3f23Fs___1();
    460 static inline volatile const signed short int _X3f24Fs___1();
    461 static inline volatile const signed short int _X3f25Fs___1();
    462 static inline volatile const signed short int _X3f26Fs___1();
    463 static inline volatile const signed short int _X3f27Fs___1();
    464 static inline volatile const signed short int _X3f28Fs___1();
     423    signed short int __i__s_1;
     424};
     425static inline void ___constructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
     426static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
     427static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
     428static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
     429static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1);
     430static inline void ___constructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
     431    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ?{} */);
     432}
     433static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     434    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
     435}
     436static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
     437    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ^?{} */);
     438}
     439static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     440    struct __anonymous15 ___ret__14s__anonymous15_1;
     441    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     442    ((void)___constructor__F_14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__14s__anonymous15_1)));
     443    return ___ret__14s__anonymous15_1;
     444}
     445static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1){
     446    ((void)((*___dst__14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
     447}
     448static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
     449static inline volatile const signed int __f11__Fi___1();
     450static inline volatile const signed int __f12__Fi___1();
     451static inline volatile const signed int __f13__Fi___1();
     452static inline volatile const signed int __f14__Fi___1();
     453static inline volatile const signed int __f15__Fi___1();
     454static inline volatile const signed int __f16__Fi___1();
     455static inline volatile const signed int __f17__Fi___1();
     456static inline volatile const signed int __f18__Fi___1();
     457static inline volatile const signed short int __f21__Fs___1();
     458static inline volatile const signed short int __f22__Fs___1();
     459static inline volatile const signed short int __f23__Fs___1();
     460static inline volatile const signed short int __f24__Fs___1();
     461static inline volatile const signed short int __f25__Fs___1();
     462static inline volatile const signed short int __f26__Fs___1();
     463static inline volatile const signed short int __f27__Fs___1();
     464static inline volatile const signed short int __f28__Fs___1();
    465465struct __anonymous16 {
    466     signed int _X1ii_1;
    467 };
    468 static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1);
    469 static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1);
    470 static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1);
    471 static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1);
    472 static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1);
    473 static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    474     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
    475 }
    476 static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    477     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
    478 }
    479 static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    480     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
    481 }
    482 static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    483     struct __anonymous16 _X4_retS13__anonymous16_1;
    484     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
    485     ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
    486     return _X4_retS13__anonymous16_1;
    487 }
    488 static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1){
    489     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
    490 }
    491 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
     466    signed int __i__i_1;
     467};
     468static inline void ___constructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
     469static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
     470static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
     471static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
     472static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1);
     473static inline void ___constructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
     474    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ?{} */);
     475}
     476static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     477    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
     478}
     479static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
     480    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ^?{} */);
     481}
     482static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     483    struct __anonymous16 ___ret__14s__anonymous16_1;
     484    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     485    ((void)___constructor__F_14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__14s__anonymous16_1)));
     486    return ___ret__14s__anonymous16_1;
     487}
     488static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1){
     489    ((void)((*___dst__14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
     490}
     491static inline volatile const struct __anonymous16 __f31__F14s__anonymous16___1();
    492492struct __anonymous17 {
    493     signed int _X1ii_1;
    494 };
    495 static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1);
    496 static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1);
    497 static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1);
    498 static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1);
    499 static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1);
    500 static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    501     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
    502 }
    503 static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    504     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
    505 }
    506 static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    507     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
    508 }
    509 static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    510     struct __anonymous17 _X4_retS13__anonymous17_1;
    511     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
    512     ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
    513     return _X4_retS13__anonymous17_1;
    514 }
    515 static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1){
    516     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
    517 }
    518 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
     493    signed int __i__i_1;
     494};
     495static inline void ___constructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
     496static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
     497static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
     498static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
     499static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1);
     500static inline void ___constructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
     501    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ?{} */);
     502}
     503static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     504    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
     505}
     506static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
     507    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ^?{} */);
     508}
     509static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     510    struct __anonymous17 ___ret__14s__anonymous17_1;
     511    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     512    ((void)___constructor__F_14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__14s__anonymous17_1)));
     513    return ___ret__14s__anonymous17_1;
     514}
     515static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1){
     516    ((void)((*___dst__14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
     517}
     518static inline volatile const struct __anonymous17 __f32__F14s__anonymous17___1();
    519519struct __anonymous18 {
    520     signed int _X1ii_1;
    521 };
    522 static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1);
    523 static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1);
    524 static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1);
    525 static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1);
    526 static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1);
    527 static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    528     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
    529 }
    530 static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    531     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
    532 }
    533 static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    534     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
    535 }
    536 static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    537     struct __anonymous18 _X4_retS13__anonymous18_1;
    538     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
    539     ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
    540     return _X4_retS13__anonymous18_1;
    541 }
    542 static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1){
    543     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
    544 }
    545 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
     520    signed int __i__i_1;
     521};
     522static inline void ___constructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
     523static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
     524static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
     525static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
     526static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1);
     527static inline void ___constructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
     528    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ?{} */);
     529}
     530static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     531    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
     532}
     533static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
     534    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ^?{} */);
     535}
     536static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     537    struct __anonymous18 ___ret__14s__anonymous18_1;
     538    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     539    ((void)___constructor__F_14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__14s__anonymous18_1)));
     540    return ___ret__14s__anonymous18_1;
     541}
     542static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1){
     543    ((void)((*___dst__14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
     544}
     545static inline volatile const struct __anonymous18 __f33__F14s__anonymous18___1();
    546546struct __anonymous19 {
    547     signed int _X1ii_1;
    548 };
    549 static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1);
    550 static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1);
    551 static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1);
    552 static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1);
    553 static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1);
    554 static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    555     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
    556 }
    557 static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    558     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
    559 }
    560 static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    561     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
    562 }
    563 static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    564     struct __anonymous19 _X4_retS13__anonymous19_1;
    565     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
    566     ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
    567     return _X4_retS13__anonymous19_1;
    568 }
    569 static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1){
    570     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
    571 }
    572 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
     547    signed int __i__i_1;
     548};
     549static inline void ___constructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
     550static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
     551static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
     552static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
     553static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1);
     554static inline void ___constructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
     555    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ?{} */);
     556}
     557static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     558    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
     559}
     560static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
     561    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ^?{} */);
     562}
     563static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     564    struct __anonymous19 ___ret__14s__anonymous19_1;
     565    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     566    ((void)___constructor__F_14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__14s__anonymous19_1)));
     567    return ___ret__14s__anonymous19_1;
     568}
     569static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1){
     570    ((void)((*___dst__14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
     571}
     572static inline volatile const struct __anonymous19 __f34__F14s__anonymous19___1();
    573573struct __anonymous20 {
    574     signed int _X1ii_1;
    575 };
    576 static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1);
    577 static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1);
    578 static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1);
    579 static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1);
    580 static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1);
    581 static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    582     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
    583 }
    584 static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    585     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
    586 }
    587 static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    588     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
    589 }
    590 static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    591     struct __anonymous20 _X4_retS13__anonymous20_1;
    592     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
    593     ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
    594     return _X4_retS13__anonymous20_1;
    595 }
    596 static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1){
    597     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
    598 }
    599 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
     574    signed int __i__i_1;
     575};
     576static inline void ___constructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
     577static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
     578static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
     579static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
     580static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1);
     581static inline void ___constructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
     582    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ?{} */);
     583}
     584static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     585    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
     586}
     587static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
     588    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ^?{} */);
     589}
     590static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     591    struct __anonymous20 ___ret__14s__anonymous20_1;
     592    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     593    ((void)___constructor__F_14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__14s__anonymous20_1)));
     594    return ___ret__14s__anonymous20_1;
     595}
     596static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1){
     597    ((void)((*___dst__14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
     598}
     599static inline volatile const struct __anonymous20 __f35__F14s__anonymous20___1();
    600600struct __anonymous21 {
    601     signed int _X1ii_1;
    602 };
    603 static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1);
    604 static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1);
    605 static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1);
    606 static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1);
    607 static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1);
    608 static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    609     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
    610 }
    611 static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    612     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
    613 }
    614 static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    615     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
    616 }
    617 static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    618     struct __anonymous21 _X4_retS13__anonymous21_1;
    619     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
    620     ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
    621     return _X4_retS13__anonymous21_1;
    622 }
    623 static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1){
    624     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
    625 }
    626 static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
     601    signed int __i__i_1;
     602};
     603static inline void ___constructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
     604static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
     605static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
     606static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
     607static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1);
     608static inline void ___constructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
     609    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ?{} */);
     610}
     611static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     612    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
     613}
     614static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
     615    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ^?{} */);
     616}
     617static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     618    struct __anonymous21 ___ret__14s__anonymous21_1;
     619    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     620    ((void)___constructor__F_14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__14s__anonymous21_1)));
     621    return ___ret__14s__anonymous21_1;
     622}
     623static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1){
     624    ((void)((*___dst__14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
     625}
     626static inline volatile const struct __anonymous21 __f36__F14s__anonymous21___1();
    627627struct __anonymous22 {
    628     signed int _X1ii_1;
    629 };
    630 static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
    631 static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
    632 static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
    633 static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
    634 static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
    635 static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    636     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
    637 }
    638 static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    639     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
    640 }
    641 static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    642     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
    643 }
    644 static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    645     struct __anonymous22 _X4_retS13__anonymous22_1;
    646     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
    647     ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
    648     return _X4_retS13__anonymous22_1;
    649 }
    650 static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
    651     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
    652 }
    653 static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
     628    signed int __i__i_1;
     629};
     630static inline void ___constructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
     631static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
     632static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
     633static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
     634static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1);
     635static inline void ___constructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
     636    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ?{} */);
     637}
     638static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     639    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
     640}
     641static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
     642    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ^?{} */);
     643}
     644static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     645    struct __anonymous22 ___ret__14s__anonymous22_1;
     646    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     647    ((void)___constructor__F_14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__14s__anonymous22_1)));
     648    return ___ret__14s__anonymous22_1;
     649}
     650static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1){
     651    ((void)((*___dst__14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
     652}
     653static inline volatile const struct __anonymous22 __f37__F14s__anonymous22___1();
    654654struct __anonymous23 {
    655     signed int _X1ii_1;
    656 };
    657 static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
    658 static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
    659 static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
    660 static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
    661 static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
    662 static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    663     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
    664 }
    665 static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    666     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
    667 }
    668 static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    669     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
    670 }
    671 static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    672     struct __anonymous23 _X4_retS13__anonymous23_1;
    673     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
    674     ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
    675     return _X4_retS13__anonymous23_1;
    676 }
    677 static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
    678     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
    679 }
    680 static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
    681 static inline volatile const signed short int _X3f41Fs___1();
    682 static inline volatile const signed short int _X3f42Fs___1();
    683 static inline volatile const signed short int _X3f43Fs___1();
    684 static inline volatile const signed short int _X3f44Fs___1();
    685 static inline volatile const signed short int _X3f45Fs___1();
    686 static inline volatile const signed short int _X3f46Fs___1();
    687 static inline volatile const signed short int _X3f47Fs___1();
    688 static inline volatile const signed short int _X3f48Fs___1();
    689 signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
    690     __attribute__ ((unused)) signed int _X12_retval_maini_1;
    691     ((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
    692     return _X12_retval_maini_1;
    693     ((void)(_X12_retval_maini_1=0) /* ?{} */);
    694     return _X12_retval_maini_1;
    695 }
    696 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return _X4mainFi_iPPKc__1((signed int )argc, (const char **)argv); }
     655    signed int __i__i_1;
     656};
     657static inline void ___constructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
     658static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
     659static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
     660static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
     661static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1);
     662static inline void ___constructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
     663    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ?{} */);
     664}
     665static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     666    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
     667}
     668static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
     669    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ^?{} */);
     670}
     671static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     672    struct __anonymous23 ___ret__14s__anonymous23_1;
     673    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     674    ((void)___constructor__F_14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__14s__anonymous23_1)));
     675    return ___ret__14s__anonymous23_1;
     676}
     677static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1){
     678    ((void)((*___dst__14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
     679}
     680static inline volatile const struct __anonymous23 __f38__F14s__anonymous23___1();
     681static inline volatile const signed short int __f41__Fs___1();
     682static inline volatile const signed short int __f42__Fs___1();
     683static inline volatile const signed short int __f43__Fs___1();
     684static inline volatile const signed short int __f44__Fs___1();
     685static inline volatile const signed short int __f45__Fs___1();
     686static inline volatile const signed short int __f46__Fs___1();
     687static inline volatile const signed short int __f47__Fs___1();
     688static inline volatile const signed short int __f48__Fs___1();
     689signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     690    __attribute__ ((unused)) signed int ___retval_main__i_1;
     691    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     692    return ___retval_main__i_1;
     693    ((void)(___retval_main__i_1=0) /* ?{} */);
     694    return ___retval_main__i_1;
     695}
     696static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    697697static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    698 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    699     __attribute__ ((unused)) signed int _X12_retval_maini_1;
     698signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     699    __attribute__ ((unused)) signed int ___retval_main__i_1;
    700700    signed int _tmp_cp_ret2;
    701     ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret2)) /* ?{} */);
     701    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret2=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret2)) /* ?{} */);
    702702    ((void)(_tmp_cp_ret2) /* ^?{} */);
    703     return _X12_retval_maini_1;
    704 }
     703    return ___retval_main__i_1;
     704}

  • tests/.expect/declarationSpecifier.x86.txt

    r6d44da1 r341bb80  
    1 volatile const signed short int _X2x1KVs_1;
    2 static volatile const signed short int _X2x2KVs_1;
    3 static volatile const signed short int _X2x3KVs_1;
    4 static volatile const signed short int _X2x4KVs_1;
    5 static volatile const signed short int _X2x5KVs_1;
    6 static volatile const signed short int _X2x6KVs_1;
    7 static volatile const signed short int _X2x7KVs_1;
    8 static volatile const signed short int _X2x8KVs_1;
     1volatile const signed short int __x1__CVs_1;
     2static volatile const signed short int __x2__CVs_1;
     3static volatile const signed short int __x3__CVs_1;
     4static volatile const signed short int __x4__CVs_1;
     5static volatile const signed short int __x5__CVs_1;
     6static volatile const signed short int __x6__CVs_1;
     7static volatile const signed short int __x7__CVs_1;
     8static volatile const signed short int __x8__CVs_1;
    99struct __anonymous0 {
    10     signed int _X1ii_1;
    11 };
    12 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    13 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    14 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
    15 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
    16 static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1);
    17 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    18     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
    19 }
    20 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    21     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
    22 }
    23 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    24     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
    25 }
    26 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    27     struct __anonymous0 _X4_retS12__anonymous0_1;
    28     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
    29     ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    30     return _X4_retS12__anonymous0_1;
    31 }
    32 static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1){
    33     ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
    34 }
    35 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
     10    signed int __i__i_1;
     11};
     12static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     14static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     15static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     16static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1);
     17static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     18    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ?{} */);
     19}
     20static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     21    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
     22}
     23static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     24    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ^?{} */);
     25}
     26static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     27    struct __anonymous0 ___ret__13s__anonymous0_1;
     28    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     29    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
     30    return ___ret__13s__anonymous0_1;
     31}
     32static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1){
     33    ((void)((*___dst__13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
     34}
     35volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
    3636struct __anonymous1 {
    37     signed int _X1ii_1;
    38 };
    39 static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1);
    40 static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1);
    41 static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1);
    42 static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1);
    43 static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1);
    44 static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    45     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
    46 }
    47 static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    48     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
    49 }
    50 static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    51     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
    52 }
    53 static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    54     struct __anonymous1 _X4_retS12__anonymous1_1;
    55     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
    56     ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
    57     return _X4_retS12__anonymous1_1;
    58 }
    59 static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1){
    60     ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
    61 }
    62 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
     37    signed int __i__i_1;
     38};
     39static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
     40static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
     41static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
     42static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
     43static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1);
     44static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
     45    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ?{} */);
     46}
     47static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     48    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
     49}
     50static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
     51    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ^?{} */);
     52}
     53static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     54    struct __anonymous1 ___ret__13s__anonymous1_1;
     55    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     56    ((void)___constructor__F_13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__13s__anonymous1_1)));
     57    return ___ret__13s__anonymous1_1;
     58}
     59static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1){
     60    ((void)((*___dst__13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
     61}
     62volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
    6363struct __anonymous2 {
    64     signed int _X1ii_1;
    65 };
    66 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    67 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    68 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
    69 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
    70 static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1);
    71 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    72     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
    73 }
    74 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    75     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
    76 }
    77 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    78     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
    79 }
    80 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    81     struct __anonymous2 _X4_retS12__anonymous2_1;
    82     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
    83     ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    84     return _X4_retS12__anonymous2_1;
    85 }
    86 static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1){
    87     ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
    88 }
    89 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
     64    signed int __i__i_1;
     65};
     66static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     67static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     68static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     69static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     70static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1);
     71static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     72    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ?{} */);
     73}
     74static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     75    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
     76}
     77static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     78    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ^?{} */);
     79}
     80static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     81    struct __anonymous2 ___ret__13s__anonymous2_1;
     82    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     83    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__anonymous2_1)));
     84    return ___ret__13s__anonymous2_1;
     85}
     86static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1){
     87    ((void)((*___dst__13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
     88}
     89volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
    9090struct __anonymous3 {
    91     signed int _X1ii_1;
    92 };
    93 static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1);
    94 static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1);
    95 static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1);
    96 static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1);
    97 static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1);
    98 static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    99     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
    100 }
    101 static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    102     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
    103 }
    104 static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    105     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
    106 }
    107 static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    108     struct __anonymous3 _X4_retS12__anonymous3_1;
    109     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
    110     ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
    111     return _X4_retS12__anonymous3_1;
    112 }
    113 static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1){
    114     ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
    115 }
    116 static volatile const struct __anonymous3 _X3x13KVS12__anonymous3_1;
     91    signed int __i__i_1;
     92};
     93static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
     94static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
     95static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
     96static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
     97static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1);
     98static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
     99    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ?{} */);
     100}
     101static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     102    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
     103}
     104static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
     105    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ^?{} */);
     106}
     107static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     108    struct __anonymous3 ___ret__13s__anonymous3_1;
     109    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     110    ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__13s__anonymous3_1)));
     111    return ___ret__13s__anonymous3_1;
     112}
     113static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1){
     114    ((void)((*___dst__13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
     115}
     116static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
    117117struct __anonymous4 {
    118     signed int _X1ii_1;
    119 };
    120 static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1);
    121 static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1);
    122 static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1);
    123 static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1);
    124 static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1);
    125 static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    126     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
    127 }
    128 static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    129     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
    130 }
    131 static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    132     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
    133 }
    134 static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    135     struct __anonymous4 _X4_retS12__anonymous4_1;
    136     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
    137     ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
    138     return _X4_retS12__anonymous4_1;
    139 }
    140 static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1){
    141     ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
    142 }
    143 static volatile const struct __anonymous4 _X3x14KVS12__anonymous4_1;
     118    signed int __i__i_1;
     119};
     120static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
     121static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
     122static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
     123static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
     124static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1);
     125static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
     126    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ?{} */);
     127}
     128static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     129    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
     130}
     131static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
     132    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ^?{} */);
     133}
     134static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     135    struct __anonymous4 ___ret__13s__anonymous4_1;
     136    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     137    ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__13s__anonymous4_1)));
     138    return ___ret__13s__anonymous4_1;
     139}
     140static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1){
     141    ((void)((*___dst__13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
     142}
     143static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
    144144struct __anonymous5 {
    145     signed int _X1ii_1;
    146 };
    147 static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1);
    148 static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1);
    149 static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1);
    150 static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1);
    151 static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1);
    152 static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    153     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
    154 }
    155 static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    156     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
    157 }
    158 static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    159     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
    160 }
    161 static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    162     struct __anonymous5 _X4_retS12__anonymous5_1;
    163     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
    164     ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
    165     return _X4_retS12__anonymous5_1;
    166 }
    167 static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1){
    168     ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
    169 }
    170 static volatile const struct __anonymous5 _X3x15KVS12__anonymous5_1;
     145    signed int __i__i_1;
     146};
     147static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
     148static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
     149static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
     150static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
     151static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1);
     152static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
     153    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ?{} */);
     154}
     155static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     156    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
     157}
     158static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
     159    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ^?{} */);
     160}
     161static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     162    struct __anonymous5 ___ret__13s__anonymous5_1;
     163    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     164    ((void)___constructor__F_13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__13s__anonymous5_1)));
     165    return ___ret__13s__anonymous5_1;
     166}
     167static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1){
     168    ((void)((*___dst__13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
     169}
     170static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
    171171struct __anonymous6 {
    172     signed int _X1ii_1;
    173 };
    174 static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1);
    175 static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1);
    176 static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1);
    177 static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1);
    178 static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1);
    179 static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    180     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
    181 }
    182 static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    183     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
    184 }
    185 static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    186     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
    187 }
    188 static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    189     struct __anonymous6 _X4_retS12__anonymous6_1;
    190     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
    191     ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
    192     return _X4_retS12__anonymous6_1;
    193 }
    194 static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1){
    195     ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
    196 }
    197 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
     172    signed int __i__i_1;
     173};
     174static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
     175static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
     176static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
     177static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
     178static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1);
     179static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
     180    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ?{} */);
     181}
     182static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     183    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
     184}
     185static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
     186    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ^?{} */);
     187}
     188static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     189    struct __anonymous6 ___ret__13s__anonymous6_1;
     190    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     191    ((void)___constructor__F_13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__13s__anonymous6_1)));
     192    return ___ret__13s__anonymous6_1;
     193}
     194static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1){
     195    ((void)((*___dst__13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
     196}
     197static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
    198198struct __anonymous7 {
    199     signed int _X1ii_1;
    200 };
    201 static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
    202 static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
    203 static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
    204 static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
    205 static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
    206 static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    207     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
    208 }
    209 static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    210     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
    211 }
    212 static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    213     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
    214 }
    215 static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    216     struct __anonymous7 _X4_retS12__anonymous7_1;
    217     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
    218     ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
    219     return _X4_retS12__anonymous7_1;
    220 }
    221 static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
    222     ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
    223 }
    224 static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
    225 volatile const signed short int _X3x20KVs_1;
    226 static volatile const signed short int _X3x21KVs_1;
    227 static volatile const signed short int _X3x22KVs_1;
    228 static volatile const signed short int _X3x23KVs_1;
    229 static volatile const signed short int _X3x24KVs_1;
    230 static volatile const signed short int _X3x25KVs_1;
    231 static volatile const signed short int _X3x26KVs_1;
    232 static volatile const signed short int _X3x27KVs_1;
     199    signed int __i__i_1;
     200};
     201static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
     202static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
     203static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
     204static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
     205static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1);
     206static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
     207    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ?{} */);
     208}
     209static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     210    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
     211}
     212static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
     213    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ^?{} */);
     214}
     215static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     216    struct __anonymous7 ___ret__13s__anonymous7_1;
     217    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     218    ((void)___constructor__F_13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__13s__anonymous7_1)));
     219    return ___ret__13s__anonymous7_1;
     220}
     221static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1){
     222    ((void)((*___dst__13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
     223}
     224static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
     225volatile const signed short int __x20__CVs_1;
     226static volatile const signed short int __x21__CVs_1;
     227static volatile const signed short int __x22__CVs_1;
     228static volatile const signed short int __x23__CVs_1;
     229static volatile const signed short int __x24__CVs_1;
     230static volatile const signed short int __x25__CVs_1;
     231static volatile const signed short int __x26__CVs_1;
     232static volatile const signed short int __x27__CVs_1;
    233233struct __anonymous8 {
    234     signed short int _X1is_1;
    235 };
    236 static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1);
    237 static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1);
    238 static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1);
    239 static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1);
    240 static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1);
    241 static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    242     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
    243 }
    244 static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    245     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
    246 }
    247 static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    248     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
    249 }
    250 static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    251     struct __anonymous8 _X4_retS12__anonymous8_1;
    252     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
    253     ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
    254     return _X4_retS12__anonymous8_1;
    255 }
    256 static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1){
    257     ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
    258 }
    259 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
     234    signed short int __i__s_1;
     235};
     236static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
     237static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
     238static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
     239static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
     240static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1);
     241static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
     242    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ?{} */);
     243}
     244static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     245    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
     246}
     247static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
     248    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ^?{} */);
     249}
     250static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     251    struct __anonymous8 ___ret__13s__anonymous8_1;
     252    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     253    ((void)___constructor__F_13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__13s__anonymous8_1)));
     254    return ___ret__13s__anonymous8_1;
     255}
     256static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1){
     257    ((void)((*___dst__13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
     258}
     259volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
    260260struct __anonymous9 {
    261     signed short int _X1is_1;
    262 };
    263 static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1);
    264 static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1);
    265 static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1);
    266 static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1);
    267 static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1);
    268 static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    269     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
    270 }
    271 static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    272     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
    273 }
    274 static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    275     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
    276 }
    277 static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    278     struct __anonymous9 _X4_retS12__anonymous9_1;
    279     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
    280     ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
    281     return _X4_retS12__anonymous9_1;
    282 }
    283 static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1){
    284     ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
    285 }
    286 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
     261    signed short int __i__s_1;
     262};
     263static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
     264static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
     265static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
     266static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
     267static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1);
     268static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
     269    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ?{} */);
     270}
     271static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     272    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
     273}
     274static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
     275    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ^?{} */);
     276}
     277static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     278    struct __anonymous9 ___ret__13s__anonymous9_1;
     279    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     280    ((void)___constructor__F_13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__13s__anonymous9_1)));
     281    return ___ret__13s__anonymous9_1;
     282}
     283static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1){
     284    ((void)((*___dst__13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
     285}
     286volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
    287287struct __anonymous10 {
    288     signed short int _X1is_1;
    289 };
    290 static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1);
    291 static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1);
    292 static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1);
    293 static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1);
    294 static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1);
    295 static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    296     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
    297 }
    298 static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    299     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
    300 }
    301 static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    302     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
    303 }
    304 static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    305     struct __anonymous10 _X4_retS13__anonymous10_1;
    306     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
    307     ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
    308     return _X4_retS13__anonymous10_1;
    309 }
    310 static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1){
    311     ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
    312 }
    313 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
     288    signed short int __i__s_1;
     289};
     290static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
     291static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
     292static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
     293static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
     294static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1);
     295static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
     296    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ?{} */);
     297}
     298static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     299    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
     300}
     301static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
     302    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ^?{} */);
     303}
     304static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     305    struct __anonymous10 ___ret__14s__anonymous10_1;
     306    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     307    ((void)___constructor__F_14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__14s__anonymous10_1)));
     308    return ___ret__14s__anonymous10_1;
     309}
     310static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1){
     311    ((void)((*___dst__14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
     312}
     313volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
    314314struct __anonymous11 {
    315     signed short int _X1is_1;
    316 };
    317 static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1);
    318 static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1);
    319 static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1);
    320 static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1);
    321 static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1);
    322 static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    323     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
    324 }
    325 static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    326     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
    327 }
    328 static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    329     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
    330 }
    331 static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    332     struct __anonymous11 _X4_retS13__anonymous11_1;
    333     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
    334     ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
    335     return _X4_retS13__anonymous11_1;
    336 }
    337 static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1){
    338     ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
    339 }
    340 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
     315    signed short int __i__s_1;
     316};
     317static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
     318static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
     319static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
     320static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
     321static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1);
     322static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
     323    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ?{} */);
     324}
     325static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     326    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
     327}
     328static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
     329    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ^?{} */);
     330}
     331static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     332    struct __anonymous11 ___ret__14s__anonymous11_1;
     333    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     334    ((void)___constructor__F_14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__14s__anonymous11_1)));
     335    return ___ret__14s__anonymous11_1;
     336}
     337static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1){
     338    ((void)((*___dst__14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
     339}
     340static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
    341341struct __anonymous12 {
    342     signed short int _X1is_1;
    343 };
    344 static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1);
    345 static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1);
    346 static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1);
    347 static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1);
    348 static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1);
    349 static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    350     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
    351 }
    352 static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    353     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
    354 }
    355 static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    356     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
    357 }
    358 static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    359     struct __anonymous12 _X4_retS13__anonymous12_1;
    360     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
    361     ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
    362     return _X4_retS13__anonymous12_1;
    363 }
    364 static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1){
    365     ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
    366 }
    367 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
     342    signed short int __i__s_1;
     343};
     344static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
     345static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
     346static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
     347static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
     348static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1);
     349static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
     350    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ?{} */);
     351}
     352static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     353    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
     354}
     355static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
     356    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ^?{} */);
     357}
     358static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     359    struct __anonymous12 ___ret__14s__anonymous12_1;
     360    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     361    ((void)___constructor__F_14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__14s__anonymous12_1)));
     362    return ___ret__14s__anonymous12_1;
     363}
     364static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1){
     365    ((void)((*___dst__14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
     366}
     367static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
    368368struct __anonymous13 {
    369     signed short int _X1is_1;
    370 };
    371 static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1);
    372 static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1);
    373 static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1);
    374 static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1);
    375 static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1);
    376 static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    377     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
    378 }
    379 static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    380     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
    381 }
    382 static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    383     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
    384 }
    385 static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    386     struct __anonymous13 _X4_retS13__anonymous13_1;
    387     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
    388     ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
    389     return _X4_retS13__anonymous13_1;
    390 }
    391 static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1){
    392     ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
    393 }
    394 static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
     369    signed short int __i__s_1;
     370};
     371static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
     372static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
     373static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
     374static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
     375static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1);
     376static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
     377    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ?{} */);
     378}
     379static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     380    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
     381}
     382static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
     383    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ^?{} */);
     384}
     385static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     386    struct __anonymous13 ___ret__14s__anonymous13_1;
     387    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     388    ((void)___constructor__F_14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__14s__anonymous13_1)));
     389    return ___ret__14s__anonymous13_1;
     390}
     391static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1){
     392    ((void)((*___dst__14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
     393}
     394static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
    395395struct __anonymous14 {
    396     signed short int _X1is_1;
    397 };
    398 static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
    399 static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
    400 static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
    401 static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
    402 static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
    403 static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    404     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
    405 }
    406 static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    407     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
    408 }
    409 static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    410     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
    411 }
    412 static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    413     struct __anonymous14 _X4_retS13__anonymous14_1;
    414     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
    415     ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
    416     return _X4_retS13__anonymous14_1;
    417 }
    418 static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
    419     ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
    420 }
    421 static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
     396    signed short int __i__s_1;
     397};
     398static inline void ___constructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
     399static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
     400static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
     401static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
     402static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1);
     403static inline void ___constructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
     404    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ?{} */);
     405}
     406static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     407    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
     408}
     409static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
     410    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ^?{} */);
     411}
     412static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     413    struct __anonymous14 ___ret__14s__anonymous14_1;
     414    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     415    ((void)___constructor__F_14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__14s__anonymous14_1)));
     416    return ___ret__14s__anonymous14_1;
     417}
     418static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1){
     419    ((void)((*___dst__14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
     420}
     421static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
    422422struct __anonymous15 {
    423     signed short int _X1is_1;
    424 };
    425 static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
    426 static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
    427 static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
    428 static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
    429 static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
    430 static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    431     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
    432 }
    433 static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    434     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
    435 }
    436 static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    437     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
    438 }
    439 static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    440     struct __anonymous15 _X4_retS13__anonymous15_1;
    441     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
    442     ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
    443     return _X4_retS13__anonymous15_1;
    444 }
    445 static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
    446     ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
    447 }
    448 static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
    449 static inline volatile const signed int _X3f11Fi___1();
    450 static inline volatile const signed int _X3f12Fi___1();
    451 static inline volatile const signed int _X3f13Fi___1();
    452 static inline volatile const signed int _X3f14Fi___1();
    453 static inline volatile const signed int _X3f15Fi___1();
    454 static inline volatile const signed int _X3f16Fi___1();
    455 static inline volatile const signed int _X3f17Fi___1();
    456 static inline volatile const signed int _X3f18Fi___1();
    457 static inline volatile const signed short int _X3f21Fs___1();
    458 static inline volatile const signed short int _X3f22Fs___1();
    459 static inline volatile const signed short int _X3f23Fs___1();
    460 static inline volatile const signed short int _X3f24Fs___1();
    461 static inline volatile const signed short int _X3f25Fs___1();
    462 static inline volatile const signed short int _X3f26Fs___1();
    463 static inline volatile const signed short int _X3f27Fs___1();
    464 static inline volatile const signed short int _X3f28Fs___1();
     423    signed short int __i__s_1;
     424};
     425static inline void ___constructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
     426static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
     427static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
     428static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
     429static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1);
     430static inline void ___constructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
     431    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ?{} */);
     432}
     433static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     434    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
     435}
     436static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
     437    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ^?{} */);
     438}
     439static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     440    struct __anonymous15 ___ret__14s__anonymous15_1;
     441    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     442    ((void)___constructor__F_14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__14s__anonymous15_1)));
     443    return ___ret__14s__anonymous15_1;
     444}
     445static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1){
     446    ((void)((*___dst__14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
     447}
     448static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
     449static inline volatile const signed int __f11__Fi___1();
     450static inline volatile const signed int __f12__Fi___1();
     451static inline volatile const signed int __f13__Fi___1();
     452static inline volatile const signed int __f14__Fi___1();
     453static inline volatile const signed int __f15__Fi___1();
     454static inline volatile const signed int __f16__Fi___1();
     455static inline volatile const signed int __f17__Fi___1();
     456static inline volatile const signed int __f18__Fi___1();
     457static inline volatile const signed short int __f21__Fs___1();
     458static inline volatile const signed short int __f22__Fs___1();
     459static inline volatile const signed short int __f23__Fs___1();
     460static inline volatile const signed short int __f24__Fs___1();
     461static inline volatile const signed short int __f25__Fs___1();
     462static inline volatile const signed short int __f26__Fs___1();
     463static inline volatile const signed short int __f27__Fs___1();
     464static inline volatile const signed short int __f28__Fs___1();
    465465struct __anonymous16 {
    466     signed int _X1ii_1;
    467 };
    468 static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1);
    469 static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1);
    470 static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1);
    471 static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1);
    472 static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1);
    473 static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    474     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
    475 }
    476 static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    477     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
    478 }
    479 static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    480     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
    481 }
    482 static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    483     struct __anonymous16 _X4_retS13__anonymous16_1;
    484     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
    485     ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
    486     return _X4_retS13__anonymous16_1;
    487 }
    488 static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1){
    489     ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
    490 }
    491 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
     466    signed int __i__i_1;
     467};
     468static inline void ___constructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
     469static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
     470static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
     471static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
     472static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1);
     473static inline void ___constructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
     474    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ?{} */);
     475}
     476static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     477    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
     478}
     479static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
     480    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ^?{} */);
     481}
     482static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     483    struct __anonymous16 ___ret__14s__anonymous16_1;
     484    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     485    ((void)___constructor__F_14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__14s__anonymous16_1)));
     486    return ___ret__14s__anonymous16_1;
     487}
     488static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1){
     489    ((void)((*___dst__14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
     490}
     491static inline volatile const struct __anonymous16 __f31__F14s__anonymous16___1();
    492492struct __anonymous17 {
    493     signed int _X1ii_1;
    494 };
    495 static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1);
    496 static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1);
    497 static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1);
    498 static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1);
    499 static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1);
    500 static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    501     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
    502 }
    503 static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    504     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
    505 }
    506 static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    507     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
    508 }
    509 static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    510     struct __anonymous17 _X4_retS13__anonymous17_1;
    511     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
    512     ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
    513     return _X4_retS13__anonymous17_1;
    514 }
    515 static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1){
    516     ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
    517 }
    518 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
     493    signed int __i__i_1;
     494};
     495static inline void ___constructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
     496static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
     497static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
     498static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
     499static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1);
     500static inline void ___constructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
     501    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ?{} */);
     502}
     503static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     504    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
     505}
     506static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
     507    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ^?{} */);
     508}
     509static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     510    struct __anonymous17 ___ret__14s__anonymous17_1;
     511    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     512    ((void)___constructor__F_14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__14s__anonymous17_1)));
     513    return ___ret__14s__anonymous17_1;
     514}
     515static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1){
     516    ((void)((*___dst__14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
     517}
     518static inline volatile const struct __anonymous17 __f32__F14s__anonymous17___1();
    519519struct __anonymous18 {
    520     signed int _X1ii_1;
    521 };
    522 static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1);
    523 static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1);
    524 static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1);
    525 static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1);
    526 static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1);
    527 static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    528     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
    529 }
    530 static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    531     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
    532 }
    533 static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    534     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
    535 }
    536 static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    537     struct __anonymous18 _X4_retS13__anonymous18_1;
    538     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
    539     ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
    540     return _X4_retS13__anonymous18_1;
    541 }
    542 static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1){
    543     ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
    544 }
    545 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
     520    signed int __i__i_1;
     521};
     522static inline void ___constructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
     523static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
     524static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
     525static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
     526static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1);
     527static inline void ___constructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
     528    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ?{} */);
     529}
     530static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     531    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
     532}
     533static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
     534    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ^?{} */);
     535}
     536static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     537    struct __anonymous18 ___ret__14s__anonymous18_1;
     538    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     539    ((void)___constructor__F_14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__14s__anonymous18_1)));
     540    return ___ret__14s__anonymous18_1;
     541}
     542static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1){
     543    ((void)((*___dst__14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
     544}
     545static inline volatile const struct __anonymous18 __f33__F14s__anonymous18___1();
    546546struct __anonymous19 {
    547     signed int _X1ii_1;
    548 };
    549 static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1);
    550 static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1);
    551 static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1);
    552 static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1);
    553 static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1);
    554 static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    555     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
    556 }
    557 static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    558     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
    559 }
    560 static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    561     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
    562 }
    563 static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    564     struct __anonymous19 _X4_retS13__anonymous19_1;
    565     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
    566     ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
    567     return _X4_retS13__anonymous19_1;
    568 }
    569 static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1){
    570     ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
    571 }
    572 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
     547    signed int __i__i_1;
     548};
     549static inline void ___constructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
     550static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
     551static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
     552static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
     553static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1);
     554static inline void ___constructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
     555    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ?{} */);
     556}
     557static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     558    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
     559}
     560static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
     561    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ^?{} */);
     562}
     563static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     564    struct __anonymous19 ___ret__14s__anonymous19_1;
     565    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     566    ((void)___constructor__F_14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__14s__anonymous19_1)));
     567    return ___ret__14s__anonymous19_1;
     568}
     569static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1){
     570    ((void)((*___dst__14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
     571}
     572static inline volatile const struct __anonymous19 __f34__F14s__anonymous19___1();
    573573struct __anonymous20 {
    574     signed int _X1ii_1;
    575 };
    576 static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1);
    577 static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1);
    578 static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1);
    579 static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1);
    580 static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1);
    581 static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    582     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
    583 }
    584 static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    585     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
    586 }
    587 static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    588     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
    589 }
    590 static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    591     struct __anonymous20 _X4_retS13__anonymous20_1;
    592     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
    593     ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
    594     return _X4_retS13__anonymous20_1;
    595 }
    596 static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1){
    597     ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
    598 }
    599 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
     574    signed int __i__i_1;
     575};
     576static inline void ___constructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
     577static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
     578static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
     579static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
     580static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1);
     581static inline void ___constructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
     582    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ?{} */);
     583}
     584static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     585    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
     586}
     587static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
     588    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ^?{} */);
     589}
     590static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     591    struct __anonymous20 ___ret__14s__anonymous20_1;
     592    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     593    ((void)___constructor__F_14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__14s__anonymous20_1)));
     594    return ___ret__14s__anonymous20_1;
     595}
     596static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1){
     597    ((void)((*___dst__14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
     598}
     599static inline volatile const struct __anonymous20 __f35__F14s__anonymous20___1();
    600600struct __anonymous21 {
    601     signed int _X1ii_1;
    602 };
    603 static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1);
    604 static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1);
    605 static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1);
    606 static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1);
    607 static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1);
    608 static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    609     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
    610 }
    611 static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    612     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
    613 }
    614 static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    615     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
    616 }
    617 static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    618     struct __anonymous21 _X4_retS13__anonymous21_1;
    619     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
    620     ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
    621     return _X4_retS13__anonymous21_1;
    622 }
    623 static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1){
    624     ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
    625 }
    626 static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
     601    signed int __i__i_1;
     602};
     603static inline void ___constructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
     604static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
     605static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
     606static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
     607static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1);
     608static inline void ___constructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
     609    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ?{} */);
     610}
     611static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     612    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
     613}
     614static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
     615    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ^?{} */);
     616}
     617static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     618    struct __anonymous21 ___ret__14s__anonymous21_1;
     619    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     620    ((void)___constructor__F_14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__14s__anonymous21_1)));
     621    return ___ret__14s__anonymous21_1;
     622}
     623static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1){
     624    ((void)((*___dst__14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
     625}
     626static inline volatile const struct __anonymous21 __f36__F14s__anonymous21___1();
    627627struct __anonymous22 {
    628     signed int _X1ii_1;
    629 };
    630 static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
    631 static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
    632 static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
    633 static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
    634 static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
    635 static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    636     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
    637 }
    638 static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    639     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
    640 }
    641 static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    642     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
    643 }
    644 static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    645     struct __anonymous22 _X4_retS13__anonymous22_1;
    646     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
    647     ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
    648     return _X4_retS13__anonymous22_1;
    649 }
    650 static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
    651     ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
    652 }
    653 static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
     628    signed int __i__i_1;
     629};
     630static inline void ___constructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
     631static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
     632static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
     633static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
     634static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1);
     635static inline void ___constructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
     636    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ?{} */);
     637}
     638static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     639    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
     640}
     641static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
     642    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ^?{} */);
     643}
     644static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     645    struct __anonymous22 ___ret__14s__anonymous22_1;
     646    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     647    ((void)___constructor__F_14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__14s__anonymous22_1)));
     648    return ___ret__14s__anonymous22_1;
     649}
     650static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1){
     651    ((void)((*___dst__14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
     652}
     653static inline volatile const struct __anonymous22 __f37__F14s__anonymous22___1();
    654654struct __anonymous23 {
    655     signed int _X1ii_1;
    656 };
    657 static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
    658 static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
    659 static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
    660 static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
    661 static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
    662 static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    663     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
    664 }
    665 static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    666     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
    667 }
    668 static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    669     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
    670 }
    671 static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    672     struct __anonymous23 _X4_retS13__anonymous23_1;
    673     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
    674     ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
    675     return _X4_retS13__anonymous23_1;
    676 }
    677 static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
    678     ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
    679 }
    680 static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
    681 static inline volatile const signed short int _X3f41Fs___1();
    682 static inline volatile const signed short int _X3f42Fs___1();
    683 static inline volatile const signed short int _X3f43Fs___1();
    684 static inline volatile const signed short int _X3f44Fs___1();
    685 static inline volatile const signed short int _X3f45Fs___1();
    686 static inline volatile const signed short int _X3f46Fs___1();
    687 static inline volatile const signed short int _X3f47Fs___1();
    688 static inline volatile const signed short int _X3f48Fs___1();
    689 signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
    690     __attribute__ ((unused)) signed int _X12_retval_maini_1;
    691     ((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
    692     return _X12_retval_maini_1;
    693     ((void)(_X12_retval_maini_1=0) /* ?{} */);
    694     return _X12_retval_maini_1;
    695 }
    696 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return _X4mainFi_iPPKc__1((signed int )argc, (const char **)argv); }
     655    signed int __i__i_1;
     656};
     657static inline void ___constructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
     658static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
     659static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
     660static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
     661static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1);
     662static inline void ___constructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
     663    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ?{} */);
     664}
     665static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     666    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
     667}
     668static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
     669    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ^?{} */);
     670}
     671static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     672    struct __anonymous23 ___ret__14s__anonymous23_1;
     673    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     674    ((void)___constructor__F_14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__14s__anonymous23_1)));
     675    return ___ret__14s__anonymous23_1;
     676}
     677static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1){
     678    ((void)((*___dst__14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
     679}
     680static inline volatile const struct __anonymous23 __f38__F14s__anonymous23___1();
     681static inline volatile const signed short int __f41__Fs___1();
     682static inline volatile const signed short int __f42__Fs___1();
     683static inline volatile const signed short int __f43__Fs___1();
     684static inline volatile const signed short int __f44__Fs___1();
     685static inline volatile const signed short int __f45__Fs___1();
     686static inline volatile const signed short int __f46__Fs___1();
     687static inline volatile const signed short int __f47__Fs___1();
     688static inline volatile const signed short int __f48__Fs___1();
     689signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     690    __attribute__ ((unused)) signed int ___retval_main__i_1;
     691    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     692    return ___retval_main__i_1;
     693    ((void)(___retval_main__i_1=0) /* ?{} */);
     694    return ___retval_main__i_1;
     695}
     696static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    697697static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    698 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    699     __attribute__ ((unused)) signed int _X12_retval_maini_1;
     698signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     699    __attribute__ ((unused)) signed int ___retval_main__i_1;
    700700    signed int _tmp_cp_ret2;
    701     ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret2)) /* ?{} */);
     701    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret2=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret2)) /* ?{} */);
    702702    ((void)(_tmp_cp_ret2) /* ^?{} */);
    703     return _X12_retval_maini_1;
    704 }
     703    return ___retval_main__i_1;
     704}

  • tests/.expect/extension.x64.txt

    r6d44da1 r341bb80  
    1 __extension__ signed int _X1ai_1;
    2 __extension__ signed int _X1bi_1;
    3 __extension__ signed int _X1ci_1;
     1__extension__ signed int __a__i_1;
     2__extension__ signed int __b__i_1;
     3__extension__ signed int __c__i_1;
    44__extension__ struct S {
    5     __extension__ signed int _X1ai_1;
    6     __extension__ signed int _X1bi_1;
    7     __extension__ signed int _X1ci_1;
     5    __extension__ signed int __a__i_1;
     6    __extension__ signed int __b__i_1;
     7    __extension__ signed int __c__i_1;
    88};
    9 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    10 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    11 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    12 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    13 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1);
    14 static inline void _X12_constructorFv_S1Sii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1);
    15 static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1);
    16 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    17     ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
    18     ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    19     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    20 }
    21 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    22     ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
    23     ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
    24     ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
    25 }
    26 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    27     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
    28     ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
    29     ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
    30 }
    31 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    32     struct S _X4_retS1S_1;
    33     ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
    34     ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
    35     ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
    36     ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    37     return _X4_retS1S_1;
    38 }
    39 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1){
    40     ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    41     ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    42     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    43 }
    44 static inline void _X12_constructorFv_S1Sii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1){
    45     ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    46     ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    47     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    48 }
    49 static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
    50     ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    51     ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    52     ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
     9static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     10static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     11static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     12static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     13static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1);
     14static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1);
     15static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
     16static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     17    ((void)((*___dst__2sS_1).__a__i_1) /* ?{} */);
     18    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
     19    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
     20}
     21static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     22    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1) /* ?{} */);
     23    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1) /* ?{} */);
     24    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1) /* ?{} */);
     25}
     26static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     27    ((void)((*___dst__2sS_1).__c__i_1) /* ^?{} */);
     28    ((void)((*___dst__2sS_1).__b__i_1) /* ^?{} */);
     29    ((void)((*___dst__2sS_1).__a__i_1) /* ^?{} */);
     30}
     31static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     32    struct S ___ret__2sS_1;
     33    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
     34    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     35    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     36    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     37    return ___ret__2sS_1;
     38}
     39static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1){
     40    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     41    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
     42    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
     43}
     44static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1){
     45    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     46    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     47    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
     48}
     49static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     50    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     51    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     52    ((void)((*___dst__2sS_1).__c__i_1=__c__i_1) /* ?{} */);
    5353}
    5454__extension__ union U {
    55     __extension__ signed int _X1ai_1;
    56     __extension__ signed int _X1bi_1;
    57     __extension__ signed int _X1ci_1;
     55    __extension__ signed int __a__i_1;
     56    __extension__ signed int __b__i_1;
     57    __extension__ signed int __c__i_1;
    5858};
    59 static inline void _X12_constructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1);
    60 static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1);
    61 static inline void _X11_destructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1);
    62 static inline union U _X16_operator_assignFU1U_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1);
    63 static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1);
    64 static inline void _X12_constructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
    65 }
    66 static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    67     ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    68 }
    69 static inline void _X11_destructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
    70 }
    71 static inline union U _X16_operator_assignFU1U_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    72     union U _X4_retU1U_1;
    73     ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    74     ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
    75     return _X4_retU1U_1;
    76 }
    77 static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1){
    78     ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
     59static inline void ___constructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
     60static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
     61static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
     62static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
     63static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1);
     64static inline void ___constructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
     65}
     66static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1){
     67    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     68}
     69static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
     70}
     71static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1){
     72    union U ___ret__2uU_1;
     73    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     74    ((void)___constructor__F_2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__2uU_1)));
     75    return ___ret__2uU_1;
     76}
     77static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1){
     78    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
    7979}
    8080__extension__ enum E {
    81     _X1RKM1E_1,
    82     _X1GKM1E_1,
    83     _X1BKM1E_1,
     81    __R__C2eE_1,
     82    __G__C2eE_1,
     83    __B__C2eE_1,
    8484};
    85 __extension__ signed int _X1fFi___1();
     85__extension__ signed int __f__Fi___1();
    8686__extension__ signed int i;
    8787__extension__ signed int j;
    88 __extension__ signed int _X4fredFi_i__1(signed int _X1pi_1){
    89     __attribute__ ((unused)) signed int _X12_retval_fredi_1;
     88__extension__ signed int __fred__Fi_i__1(signed int __p__i_1){
     89    __attribute__ ((unused)) signed int ___retval_fred__i_1;
    9090    __extension__ struct S {
    91         __extension__ signed int _X1ai_2;
    92         __extension__ signed int _X1bi_2;
    93         __extension__ signed int _X1ci_2;
    94         __extension__ signed int *_X1xPi_2;
    95         __extension__ signed int *_X1yPi_2;
    96         __extension__ signed int *_X1zPi_2;
     91        __extension__ signed int __a__i_2;
     92        __extension__ signed int __b__i_2;
     93        __extension__ signed int __c__i_2;
     94        __extension__ signed int *__x__Pi_2;
     95        __extension__ signed int *__y__Pi_2;
     96        __extension__ signed int *__z__Pi_2;
    9797    };
    98     inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    99         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    100         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    101         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    102         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    103         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    104         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    105     }
    106     inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    107         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    108         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    109         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    110         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
    111         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
    112         ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
    113     }
    114     inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    115         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
    116         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
    117         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
    118         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    119         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    120         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    121     }
    122     inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    123         struct S _X4_retS1S_2;
    124         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    125         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    126         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    127         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
    128         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
    129         ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
    130         ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    131         return _X4_retS1S_2;
    132     }
    133     inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    134         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    135         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    136         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    137         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    138         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    139         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    140     }
    141     inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    142         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    143         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    144         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    145         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    146         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    147         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    148     }
    149     inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    150         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    151         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    152         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    153         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    154         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    155         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    156     }
    157     inline void _X12_constructorFv_S1SiiiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2){
    158         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    159         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    160         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    161         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    162         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    163         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    164     }
    165     inline void _X12_constructorFv_S1SiiiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2){
    166         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    167         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    168         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    169         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    170         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    171         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    172     }
    173     inline void _X12_constructorFv_S1SiiiPiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2, signed int *_X1zPi_2){
    174         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    175         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    176         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    177         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    178         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    179         ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
    180     }
    181     signed int _X1ii_2 = (__extension__ _X1ai_1+__extension__ 3);
     98    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     99        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
     100        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     101        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
     102        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     103        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     104        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     105    }
     106    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     107        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
     108        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
     109        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
     110        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
     111        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
     112        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
     113    }
     114    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     115        ((void)((*___dst__2sS_2).__z__Pi_2) /* ^?{} */);
     116        ((void)((*___dst__2sS_2).__y__Pi_2) /* ^?{} */);
     117        ((void)((*___dst__2sS_2).__x__Pi_2) /* ^?{} */);
     118        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
     119        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
     120        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
     121    }
     122    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     123        struct S ___ret__2sS_2;
     124        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
     125        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
     126        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
     127        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
     128        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
     129        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
     130        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_2)));
     131        return ___ret__2sS_2;
     132    }
     133    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
     134        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     135        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     136        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
     137        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     138        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     139        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     140    }
     141    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
     142        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     143        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     144        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
     145        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     146        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     147        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     148    }
     149    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     150        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     151        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     152        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     153        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     154        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     155        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     156    }
     157    inline void ___constructor__F_2sSiiiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
     158        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     159        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     160        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     161        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
     162        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     163        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     164    }
     165    inline void ___constructor__F_2sSiiiPiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2){
     166        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     167        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     168        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     169        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
     170        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
     171        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     172    }
     173    inline void ___constructor__F_2sSiiiPiPiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2, signed int *__z__Pi_2){
     174        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     175        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     176        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     177        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
     178        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
     179        ((void)((*___dst__2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
     180    }
     181    signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);
    182182    ((void)__extension__ 3);
    183     ((void)__extension__ _X1ai_1);
    184     __extension__ signed int _X1ai_2;
    185     __extension__ signed int _X1bi_2;
    186     __extension__ signed int _X1ci_2;
    187     ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
     183    ((void)__extension__ __a__i_1);
     184    __extension__ signed int __a__i_2;
     185    __extension__ signed int __b__i_2;
     186    __extension__ signed int __c__i_2;
     187    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    188188    signed int _tmp_cp_ret2;
    189     ((void)(((void)(_tmp_cp_ret2=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret2));
     189    ((void)(((void)(_tmp_cp_ret2=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret2));
    190190    ((void)(_tmp_cp_ret2) /* ^?{} */);
    191     __extension__ signed int _X4maryFi_i__2(signed int _X1pi_2){
    192         __attribute__ ((unused)) signed int _X12_retval_maryi_2;
     191    __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){
     192        __attribute__ ((unused)) signed int ___retval_mary__i_2;
    193193    }
    194194    ((void)__extension__ sizeof(3));
    195195    ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
    196     ((void)__extension__ __alignof__(__extension__ _X1ai_2));
    197     ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
    198     ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
    199     ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    200     ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    201 }
     196    ((void)__extension__ __alignof__(__extension__ __a__i_2));
     197    ((void)((__extension__ __a__i_2!=((signed int )0)) || (((__extension__ __b__i_2!=((signed int )0)) && (__extension__ __c__i_2!=((signed int )0)))!=((signed int )0))));
     198    ((void)(((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0)) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     199    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     200    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     201}

  • tests/.expect/extension.x86.txt

    r6d44da1 r341bb80  
    1 __extension__ signed int _X1ai_1;
    2 __extension__ signed int _X1bi_1;
    3 __extension__ signed int _X1ci_1;
     1__extension__ signed int __a__i_1;
     2__extension__ signed int __b__i_1;
     3__extension__ signed int __c__i_1;
    44__extension__ struct S {
    5     __extension__ signed int _X1ai_1;
    6     __extension__ signed int _X1bi_1;
    7     __extension__ signed int _X1ci_1;
     5    __extension__ signed int __a__i_1;
     6    __extension__ signed int __b__i_1;
     7    __extension__ signed int __c__i_1;
    88};
    9 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    10 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    11 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    12 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    13 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1);
    14 static inline void _X12_constructorFv_S1Sii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1);
    15 static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1);
    16 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    17     ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
    18     ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    19     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    20 }
    21 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    22     ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
    23     ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
    24     ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
    25 }
    26 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    27     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
    28     ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
    29     ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
    30 }
    31 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    32     struct S _X4_retS1S_1;
    33     ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
    34     ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
    35     ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
    36     ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    37     return _X4_retS1S_1;
    38 }
    39 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1){
    40     ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    41     ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    42     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    43 }
    44 static inline void _X12_constructorFv_S1Sii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1){
    45     ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    46     ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    47     ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    48 }
    49 static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
    50     ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    51     ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    52     ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
     9static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     10static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     11static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     12static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     13static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1);
     14static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1);
     15static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
     16static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     17    ((void)((*___dst__2sS_1).__a__i_1) /* ?{} */);
     18    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
     19    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
     20}
     21static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     22    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1) /* ?{} */);
     23    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1) /* ?{} */);
     24    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1) /* ?{} */);
     25}
     26static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     27    ((void)((*___dst__2sS_1).__c__i_1) /* ^?{} */);
     28    ((void)((*___dst__2sS_1).__b__i_1) /* ^?{} */);
     29    ((void)((*___dst__2sS_1).__a__i_1) /* ^?{} */);
     30}
     31static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     32    struct S ___ret__2sS_1;
     33    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
     34    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     35    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     36    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     37    return ___ret__2sS_1;
     38}
     39static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1){
     40    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     41    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
     42    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
     43}
     44static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1){
     45    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     46    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     47    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
     48}
     49static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
     50    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     51    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     52    ((void)((*___dst__2sS_1).__c__i_1=__c__i_1) /* ?{} */);
    5353}
    5454__extension__ union U {
    55     __extension__ signed int _X1ai_1;
    56     __extension__ signed int _X1bi_1;
    57     __extension__ signed int _X1ci_1;
     55    __extension__ signed int __a__i_1;
     56    __extension__ signed int __b__i_1;
     57    __extension__ signed int __c__i_1;
    5858};
    59 static inline void _X12_constructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1);
    60 static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1);
    61 static inline void _X11_destructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1);
    62 static inline union U _X16_operator_assignFU1U_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1);
    63 static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1);
    64 static inline void _X12_constructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
    65 }
    66 static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    67     ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    68 }
    69 static inline void _X11_destructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
    70 }
    71 static inline union U _X16_operator_assignFU1U_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    72     union U _X4_retU1U_1;
    73     ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    74     ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
    75     return _X4_retU1U_1;
    76 }
    77 static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1){
    78     ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
     59static inline void ___constructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
     60static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
     61static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
     62static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
     63static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1);
     64static inline void ___constructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
     65}
     66static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1){
     67    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     68}
     69static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
     70}
     71static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1){
     72    union U ___ret__2uU_1;
     73    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     74    ((void)___constructor__F_2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__2uU_1)));
     75    return ___ret__2uU_1;
     76}
     77static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1){
     78    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
    7979}
    8080__extension__ enum E {
    81     _X1RKM1E_1,
    82     _X1GKM1E_1,
    83     _X1BKM1E_1,
     81    __R__C2eE_1,
     82    __G__C2eE_1,
     83    __B__C2eE_1,
    8484};
    85 __extension__ signed int _X1fFi___1();
     85__extension__ signed int __f__Fi___1();
    8686__extension__ signed int i;
    8787__extension__ signed int j;
    88 __extension__ signed int _X4fredFi_i__1(signed int _X1pi_1){
    89     __attribute__ ((unused)) signed int _X12_retval_fredi_1;
     88__extension__ signed int __fred__Fi_i__1(signed int __p__i_1){
     89    __attribute__ ((unused)) signed int ___retval_fred__i_1;
    9090    __extension__ struct S {
    91         __extension__ signed int _X1ai_2;
    92         __extension__ signed int _X1bi_2;
    93         __extension__ signed int _X1ci_2;
    94         __extension__ signed int *_X1xPi_2;
    95         __extension__ signed int *_X1yPi_2;
    96         __extension__ signed int *_X1zPi_2;
     91        __extension__ signed int __a__i_2;
     92        __extension__ signed int __b__i_2;
     93        __extension__ signed int __c__i_2;
     94        __extension__ signed int *__x__Pi_2;
     95        __extension__ signed int *__y__Pi_2;
     96        __extension__ signed int *__z__Pi_2;
    9797    };
    98     inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    99         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    100         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    101         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    102         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    103         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    104         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    105     }
    106     inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    107         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    108         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    109         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    110         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
    111         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
    112         ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
    113     }
    114     inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    115         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
    116         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
    117         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
    118         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    119         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    120         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    121     }
    122     inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    123         struct S _X4_retS1S_2;
    124         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    125         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    126         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    127         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
    128         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
    129         ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
    130         ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    131         return _X4_retS1S_2;
    132     }
    133     inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    134         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    135         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    136         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    137         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    138         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    139         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    140     }
    141     inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    142         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    143         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    144         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    145         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    146         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    147         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    148     }
    149     inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    150         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    151         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    152         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    153         ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    154         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    155         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    156     }
    157     inline void _X12_constructorFv_S1SiiiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2){
    158         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    159         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    160         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    161         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    162         ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    163         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    164     }
    165     inline void _X12_constructorFv_S1SiiiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2){
    166         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    167         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    168         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    169         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    170         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    171         ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    172     }
    173     inline void _X12_constructorFv_S1SiiiPiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2, signed int *_X1zPi_2){
    174         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    175         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    176         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    177         ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    178         ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    179         ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
    180     }
    181     signed int _X1ii_2 = (__extension__ _X1ai_1+__extension__ 3);
     98    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     99        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
     100        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     101        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
     102        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     103        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     104        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     105    }
     106    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     107        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
     108        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
     109        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
     110        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
     111        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
     112        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
     113    }
     114    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     115        ((void)((*___dst__2sS_2).__z__Pi_2) /* ^?{} */);
     116        ((void)((*___dst__2sS_2).__y__Pi_2) /* ^?{} */);
     117        ((void)((*___dst__2sS_2).__x__Pi_2) /* ^?{} */);
     118        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
     119        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
     120        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
     121    }
     122    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     123        struct S ___ret__2sS_2;
     124        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
     125        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
     126        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
     127        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
     128        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
     129        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
     130        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_2)));
     131        return ___ret__2sS_2;
     132    }
     133    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
     134        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     135        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     136        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
     137        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     138        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     139        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     140    }
     141    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
     142        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     143        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     144        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
     145        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     146        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     147        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     148    }
     149    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     150        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     151        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     152        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     153        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
     154        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     155        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     156    }
     157    inline void ___constructor__F_2sSiiiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
     158        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     159        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     160        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     161        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
     162        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
     163        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     164    }
     165    inline void ___constructor__F_2sSiiiPiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2){
     166        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     167        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     168        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     169        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
     170        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
     171        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
     172    }
     173    inline void ___constructor__F_2sSiiiPiPiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2, signed int *__z__Pi_2){
     174        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     175        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     176        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
     177        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
     178        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
     179        ((void)((*___dst__2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
     180    }
     181    signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);
    182182    ((void)__extension__ 3);
    183     ((void)__extension__ _X1ai_1);
    184     __extension__ signed int _X1ai_2;
    185     __extension__ signed int _X1bi_2;
    186     __extension__ signed int _X1ci_2;
    187     ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
     183    ((void)__extension__ __a__i_1);
     184    __extension__ signed int __a__i_2;
     185    __extension__ signed int __b__i_2;
     186    __extension__ signed int __c__i_2;
     187    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
    188188    signed int _tmp_cp_ret2;
    189     ((void)(((void)(_tmp_cp_ret2=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret2));
     189    ((void)(((void)(_tmp_cp_ret2=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret2));
    190190    ((void)(_tmp_cp_ret2) /* ^?{} */);
    191     __extension__ signed int _X4maryFi_i__2(signed int _X1pi_2){
    192         __attribute__ ((unused)) signed int _X12_retval_maryi_2;
     191    __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){
     192        __attribute__ ((unused)) signed int ___retval_mary__i_2;
    193193    }
    194194    ((void)__extension__ sizeof(3));
    195195    ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
    196     ((void)__extension__ __alignof__(__extension__ _X1ai_2));
    197     ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
    198     ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
    199     ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    200     ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    201 }
     196    ((void)__extension__ __alignof__(__extension__ __a__i_2));
     197    ((void)((__extension__ __a__i_2!=((signed int )0)) || (((__extension__ __b__i_2!=((signed int )0)) && (__extension__ __c__i_2!=((signed int )0)))!=((signed int )0))));
     198    ((void)(((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0)) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     199    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     200    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     201}

  • tests/.expect/forctrl.txt

    r6d44da1 r341bb80  
    22empty
    33empty
    4 
    5 A
    6 A A
    7 A A A A A A A A A A
    8 B B B B B
    9 C C C C C
    10 D D D D D
    11 E E E E E
     4X X X X X X X X X X
     5Y Y Y Y Y
     6Z Z Z Z Z
    1270 1 2 3 4 5 6 7 8 9
    1380 1 2 3 4 5 6 7 8 9
    14 1 3 5 7 9
    15 10 8 6 4 2
    1690.5 1.5 2.5 3.5 4.5
    17 5.5 4.5 3.5 2.5 1.5
    18102 4 6 8 10
    19 10 8 6 4 2
     112 4 6 8 10
    20123 6 9
    2113(0 0)(1 1)(2 2)(3 3)(4 4)(5 5)(6 6)(7 7)(8 8)(9 9)

  • tests/.expect/functions.x64.txt

    r6d44da1 r341bb80  
    1 void _X1hFv___1(void){
    2 }
    3 signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
    4     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    5     ((void)(*_X1gFv___1)());
    6     ((void)_X1gFv___1());
    7     ((void)(_X1gFv___1=_X1hFv___1));
    8 }
    9 signed int _X2f1Fi___1(){
    10     __attribute__ ((unused)) signed int _X10_retval_f1i_1;
    11 }
    12 signed int _X2f2Fi___1(){
    13     __attribute__ ((unused)) signed int _X10_retval_f2i_1;
    14 }
    15 signed int (*_X2f3FFi_____1())(){
    16     __attribute__ ((unused)) signed int (*_X10_retval_f3Fi___1)();
    17 }
    18 signed int *_X2f4FPi___1(){
    19     __attribute__ ((unused)) signed int *_X10_retval_f4Pi_1;
    20 }
    21 signed int (*_X2f5FFi_____1())(){
    22     __attribute__ ((unused)) signed int (*_X10_retval_f5Fi___1)();
    23 }
    24 signed int *_X2f6FPi___1(){
    25     __attribute__ ((unused)) signed int *_X10_retval_f6Pi_1;
    26 }
    27 signed int *_X2f7FPi___1(){
    28     __attribute__ ((unused)) signed int *_X10_retval_f7Pi_1;
    29 }
    30 signed int **_X2f8FPPi___1(){
    31     __attribute__ ((unused)) signed int **_X10_retval_f8PPi_1;
    32 }
    33 signed int *const *_X2f9FPKPi___1(){
    34     __attribute__ ((unused)) signed int *const *_X10_retval_f9PKPi_1;
    35 }
    36 signed int (*_X3f10FPA0i___1())[]{
    37     __attribute__ ((unused)) signed int (*_X11_retval_f10PA0i_1)[];
    38 }
    39 signed int (*_X3f11FPA0A0i___1())[][((unsigned long int )3)]{
    40     __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned long int )3)];
    41 }
    42 signed int (*_X3f12FPA0A0i___1())[][((unsigned long int )3)]{
    43     __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )3)];
    44 }
    45 signed int _X4fII1Fi_i__1(signed int _X1ii_1){
    46     __attribute__ ((unused)) signed int _X12_retval_fII1i_1;
    47 }
    48 const signed int _X4fII2Fi_i__1(signed int _X1ii_1){
    49     __attribute__ ((unused)) const signed int _X12_retval_fII2Ki_1;
    50 }
    51 extern signed int _X4fII3Fi_i__1(signed int _X1ii_1){
    52     __attribute__ ((unused)) signed int _X12_retval_fII3i_1;
    53 }
    54 extern const signed int _X4fII4Fi_i__1(signed int _X1ii_1){
    55     __attribute__ ((unused)) const signed int _X12_retval_fII4Ki_1;
    56 }
    57 signed int *_X4fII5FPi___1(){
    58     __attribute__ ((unused)) signed int *_X12_retval_fII5Pi_1;
    59 }
    60 signed int *const _X4fII6FPi___1(){
    61     __attribute__ ((unused)) signed int *const _X12_retval_fII6KPi_1;
    62 }
    63 const signed long int *_X4fII7FPKl___1(){
    64     __attribute__ ((unused)) const signed long int *_X12_retval_fII7PKl_1;
    65 }
    66 static const signed long int *_X4fII8FPKl___1(){
    67     __attribute__ ((unused)) const signed long int *_X12_retval_fII8PKl_1;
    68 }
    69 static const signed long int *_X4fII9FPKl___1(){
    70     __attribute__ ((unused)) const signed long int *_X12_retval_fII9PKl_1;
    71 }
    72 signed int _X3fO1Fi_i__1(signed int _X1ii_1){
    73     __attribute__ ((unused)) signed int _X11_retval_fO1i_1;
    74 }
    75 signed int _X3fO2Fi_i__1(signed int _X1ii_1){
    76     __attribute__ ((unused)) signed int _X11_retval_fO2i_1;
    77 }
    78 const signed int _X3fO3Fi_i__1(signed int _X1ii_1){
    79     __attribute__ ((unused)) const signed int _X11_retval_fO3Ki_1;
    80 }
    81 extern signed int _X3fO4Fi_i__1(signed int _X1ii_1){
    82     __attribute__ ((unused)) signed int _X11_retval_fO4i_1;
    83 }
    84 extern const signed int _X3fO5Fi_i__1(signed int _X1ii_1){
    85     __attribute__ ((unused)) const signed int _X11_retval_fO5Ki_1;
    86 }
    87 signed int _X1fFi___1(void);
    88 signed int _X1fFi_i__1(signed int __anonymous_object6);
    89 signed int _X1fFi___1(void){
    90     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    91 }
    92 signed int _X1fFi_i__1(signed int __anonymous_object7){
    93     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    94 }
    95 signed int _X1fFi___1(void);
     1void __h__F___1(void){
     2}
     3signed int __f__Fi_Fi__Fi_i_Fi__Fi_i_F____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*__g__F___1)(void)){
     4    __attribute__ ((unused)) signed int ___retval_f__i_1;
     5    ((void)(*__g__F___1)());
     6    ((void)__g__F___1());
     7    ((void)(__g__F___1=__h__F___1));
     8}
     9signed int __f1__Fi___1(){
     10    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     11}
     12signed int __f2__Fi___1(){
     13    __attribute__ ((unused)) signed int ___retval_f2__i_1;
     14}
     15signed int (*__f3__FFi_____1())(){
     16    __attribute__ ((unused)) signed int (*___retval_f3__Fi___1)();
     17}
     18signed int *__f4__FPi___1(){
     19    __attribute__ ((unused)) signed int *___retval_f4__Pi_1;
     20}
     21signed int (*__f5__FFi_____1())(){
     22    __attribute__ ((unused)) signed int (*___retval_f5__Fi___1)();
     23}
     24signed int *__f6__FPi___1(){
     25    __attribute__ ((unused)) signed int *___retval_f6__Pi_1;
     26}
     27signed int *__f7__FPi___1(){
     28    __attribute__ ((unused)) signed int *___retval_f7__Pi_1;
     29}
     30signed int **__f8__FPPi___1(){
     31    __attribute__ ((unused)) signed int **___retval_f8__PPi_1;
     32}
     33signed int *const *__f9__FPCPi___1(){
     34    __attribute__ ((unused)) signed int *const *___retval_f9__PCPi_1;
     35}
     36signed int (*__f10__FPA0i___1())[]{
     37    __attribute__ ((unused)) signed int (*___retval_f10__PA0i_1)[];
     38}
     39signed int (*__f11__FPA0A0i___1())[][((unsigned long int )3)]{
     40    __attribute__ ((unused)) signed int (*___retval_f11__PA0A0i_1)[][((unsigned long int )3)];
     41}
     42signed int (*__f12__FPA0A0i___1())[][((unsigned long int )3)]{
     43    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned long int )3)];
     44}
     45signed int __fII1__Fi_i__1(signed int __i__i_1){
     46    __attribute__ ((unused)) signed int ___retval_fII1__i_1;
     47}
     48const signed int __fII2__Fi_i__1(signed int __i__i_1){
     49    __attribute__ ((unused)) const signed int ___retval_fII2__Ci_1;
     50}
     51extern signed int __fII3__Fi_i__1(signed int __i__i_1){
     52    __attribute__ ((unused)) signed int ___retval_fII3__i_1;
     53}
     54extern const signed int __fII4__Fi_i__1(signed int __i__i_1){
     55    __attribute__ ((unused)) const signed int ___retval_fII4__Ci_1;
     56}
     57signed int *__fII5__FPi___1(){
     58    __attribute__ ((unused)) signed int *___retval_fII5__Pi_1;
     59}
     60signed int *const __fII6__FPi___1(){
     61    __attribute__ ((unused)) signed int *const ___retval_fII6__CPi_1;
     62}
     63const signed long int *__fII7__FPCl___1(){
     64    __attribute__ ((unused)) const signed long int *___retval_fII7__PCl_1;
     65}
     66static const signed long int *__fII8__FPCl___1(){
     67    __attribute__ ((unused)) const signed long int *___retval_fII8__PCl_1;
     68}
     69static const signed long int *__fII9__FPCl___1(){
     70    __attribute__ ((unused)) const signed long int *___retval_fII9__PCl_1;
     71}
     72signed int __fO1__Fi_i__1(signed int __i__i_1){
     73    __attribute__ ((unused)) signed int ___retval_fO1__i_1;
     74}
     75signed int __fO2__Fi_i__1(signed int __i__i_1){
     76    __attribute__ ((unused)) signed int ___retval_fO2__i_1;
     77}
     78const signed int __fO3__Fi_i__1(signed int __i__i_1){
     79    __attribute__ ((unused)) const signed int ___retval_fO3__Ci_1;
     80}
     81extern signed int __fO4__Fi_i__1(signed int __i__i_1){
     82    __attribute__ ((unused)) signed int ___retval_fO4__i_1;
     83}
     84extern const signed int __fO5__Fi_i__1(signed int __i__i_1){
     85    __attribute__ ((unused)) const signed int ___retval_fO5__Ci_1;
     86}
     87signed int __f__Fi___1(void);
     88signed int __f__Fi_i__1(signed int __anonymous_object6);
     89signed int __f__Fi___1(void){
     90    __attribute__ ((unused)) signed int ___retval_f__i_1;
     91}
     92signed int __f__Fi_i__1(signed int __anonymous_object7){
     93    __attribute__ ((unused)) signed int ___retval_f__i_1;
     94}
     95signed int __f__Fi___1(void);
    9696struct _tuple2_ {
    9797};
    98 static inline void _layoutof__tuple2_(unsigned long int *_sizeof__tuple2_, unsigned long int *_alignof__tuple2_, unsigned long int *_offsetof__tuple2_, unsigned long int _sizeof_Y15tuple_param_2_0, unsigned long int _alignof_Y15tuple_param_2_0, unsigned long int _sizeof_Y15tuple_param_2_1, unsigned long int _alignof_Y15tuple_param_2_1){
     98static inline void _layoutof__tuple2_(unsigned long int *_sizeof__tuple2_, unsigned long int *_alignof__tuple2_, unsigned long int *_offsetof__tuple2_, unsigned long int _sizeof_16ttuple_param_2_0, unsigned long int _alignof_16ttuple_param_2_0, unsigned long int _sizeof_16ttuple_param_2_1, unsigned long int _alignof_16ttuple_param_2_1){
    9999    ((void)((*_sizeof__tuple2_)=0));
    100100    ((void)((*_alignof__tuple2_)=1));
    101101    ((void)(_offsetof__tuple2_[0]=(*_sizeof__tuple2_)));
    102     ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_0));
    103     if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_0) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_0));
    104 
    105     if ( ((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)) ) ((void)((*_sizeof__tuple2_)+=(_alignof_Y15tuple_param_2_1-((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)))));
     102    ((void)((*_sizeof__tuple2_)+=_sizeof_16ttuple_param_2_0));
     103    if ( ((*_alignof__tuple2_)<_alignof_16ttuple_param_2_0) ) ((void)((*_alignof__tuple2_)=_alignof_16ttuple_param_2_0));
     104
     105    if ( ((*_sizeof__tuple2_)&(_alignof_16ttuple_param_2_1-1)) ) ((void)((*_sizeof__tuple2_)+=(_alignof_16ttuple_param_2_1-((*_sizeof__tuple2_)&(_alignof_16ttuple_param_2_1-1)))));
    106106
    107107    ((void)(_offsetof__tuple2_[1]=(*_sizeof__tuple2_)));
    108     ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_1));
    109     if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_1) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_1));
     108    ((void)((*_sizeof__tuple2_)+=_sizeof_16ttuple_param_2_1));
     109    if ( ((*_alignof__tuple2_)<_alignof_16ttuple_param_2_1) ) ((void)((*_alignof__tuple2_)=_alignof_16ttuple_param_2_1));
    110110
    111111    if ( ((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)) ) ((void)((*_sizeof__tuple2_)+=((*_alignof__tuple2_)-((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)))));
    … …  
    116116    signed int field_1;
    117117};
    118 struct _conc__tuple2_0 _X1fFT2ii___1(void);
    119 struct _conc__tuple2_0 _X1fFT2ii_ii__1(signed int __anonymous_object8, signed int _X1xi_1);
    120 struct _conc__tuple2_0 _X1fFT2ii___1(void){
    121     __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
    122 }
    123 struct _conc__tuple2_0 _X1fFT2ii_ii__1(signed int __anonymous_object9, signed int _X1xi_1){
    124     __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
     118struct _conc__tuple2_0 __f__FTii____1(void);
     119struct _conc__tuple2_0 __f__FTii__ii__1(signed int __anonymous_object8, signed int __x__i_1);
     120struct _conc__tuple2_0 __f__FTii____1(void){
     121    __attribute__ ((unused)) struct _conc__tuple2_0 ___retval_f__Tii__1 = {  };
     122}
     123struct _conc__tuple2_0 __f__FTii__ii__1(signed int __anonymous_object9, signed int __x__i_1){
     124    __attribute__ ((unused)) struct _conc__tuple2_0 ___retval_f__Tii__1 = {  };
    125125}
    126126struct _tuple3_ {
    127127};
    128 static inline void _layoutof__tuple3_(unsigned long int *_sizeof__tuple3_, unsigned long int *_alignof__tuple3_, unsigned long int *_offsetof__tuple3_, unsigned long int _sizeof_Y15tuple_param_3_0, unsigned long int _alignof_Y15tuple_param_3_0, unsigned long int _sizeof_Y15tuple_param_3_1, unsigned long int _alignof_Y15tuple_param_3_1, unsigned long int _sizeof_Y15tuple_param_3_2, unsigned long int _alignof_Y15tuple_param_3_2){
     128static inline void _layoutof__tuple3_(unsigned long int *_sizeof__tuple3_, unsigned long int *_alignof__tuple3_, unsigned long int *_offsetof__tuple3_, unsigned long int _sizeof_16ttuple_param_3_0, unsigned long int _alignof_16ttuple_param_3_0, unsigned long int _sizeof_16ttuple_param_3_1, unsigned long int _alignof_16ttuple_param_3_1, unsigned long int _sizeof_16ttuple_param_3_2, unsigned long int _alignof_16ttuple_param_3_2){
    129129    ((void)((*_sizeof__tuple3_)=0));
    130130    ((void)((*_alignof__tuple3_)=1));
    131131    ((void)(_offsetof__tuple3_[0]=(*_sizeof__tuple3_)));
    132     ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_0));
    133     if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_0) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_0));
    134 
    135     if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_1-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)))));
     132    ((void)((*_sizeof__tuple3_)+=_sizeof_16ttuple_param_3_0));
     133    if ( ((*_alignof__tuple3_)<_alignof_16ttuple_param_3_0) ) ((void)((*_alignof__tuple3_)=_alignof_16ttuple_param_3_0));
     134
     135    if ( ((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_1-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_16ttuple_param_3_1-((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_1-1)))));
    136136
    137137    ((void)(_offsetof__tuple3_[1]=(*_sizeof__tuple3_)));
    138     ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_1));
    139     if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_1) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_1));
    140 
    141     if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_2-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)))));
     138    ((void)((*_sizeof__tuple3_)+=_sizeof_16ttuple_param_3_1));
     139    if ( ((*_alignof__tuple3_)<_alignof_16ttuple_param_3_1) ) ((void)((*_alignof__tuple3_)=_alignof_16ttuple_param_3_1));
     140
     141    if ( ((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_2-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_16ttuple_param_3_2-((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_2-1)))));
    142142
    143143    ((void)(_offsetof__tuple3_[2]=(*_sizeof__tuple3_)));
    144     ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_2));
    145     if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_2) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_2));
     144    ((void)((*_sizeof__tuple3_)+=_sizeof_16ttuple_param_3_2));
     145    if ( ((*_alignof__tuple3_)<_alignof_16ttuple_param_3_2) ) ((void)((*_alignof__tuple3_)=_alignof_16ttuple_param_3_2));
    146146
    147147    if ( ((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)) ) ((void)((*_sizeof__tuple3_)+=((*_alignof__tuple3_)-((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)))));
    … …  
    153153    signed int field_2;
    154154};
    155 struct _conc__tuple3_1 _X1fFT3iii___1(void);
    156 struct _conc__tuple3_1 _X1fFT3iii_iii__1(signed int __anonymous_object10, signed int _X1xi_1, signed int __anonymous_object11);
    157 struct _conc__tuple3_1 _X1fFT3iii___1(void){
    158     __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
    159 }
    160 struct _conc__tuple3_1 _X1fFT3iii_iii__1(signed int __anonymous_object12, signed int _X1xi_1, signed int __anonymous_object13){
    161     __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
     155struct _conc__tuple3_1 __f__FTiii____1(void);
     156struct _conc__tuple3_1 __f__FTiii__iii__1(signed int __anonymous_object10, signed int __x__i_1, signed int __anonymous_object11);
     157struct _conc__tuple3_1 __f__FTiii____1(void){
     158    __attribute__ ((unused)) struct _conc__tuple3_1 ___retval_f__Tiii__1 = {  };
     159}
     160struct _conc__tuple3_1 __f__FTiii__iii__1(signed int __anonymous_object12, signed int __x__i_1, signed int __anonymous_object13){
     161    __attribute__ ((unused)) struct _conc__tuple3_1 ___retval_f__Tiii__1 = {  };
    162162}
    163163struct _conc__tuple3_2 {
    … …  
    166166    signed int *field_2;
    167167};
    168 struct _conc__tuple3_2 _X1fFT3iiPi___1(void);
    169 struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(signed int __anonymous_object14, signed int _X1xi_1, signed int *_X1yPi_1);
    170 struct _conc__tuple3_2 _X1fFT3iiPi___1(void){
    171     __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
    172 }
    173 struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(signed int __anonymous_object15, signed int _X1xi_1, signed int *_X1yPi_1){
    174     __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
    175 }
    176 signed int _X3f11Fi_i__1(signed int __anonymous_object16);
    177 signed int _X3f12Fi___1(void);
    178 const double _X4bar1Fd___1();
    179 const double _X4bar2Fd_i__1(signed int __anonymous_object17);
    180 const double _X4bar3Fd_d__1(double __anonymous_object18);
    181 const double _X3fooFd___1(void);
    182 const double _X3fooFd_i__1(signed int __anonymous_object19);
    183 const double _X3fooFd_d__1(double __anonymous_object20){
    184     __attribute__ ((unused)) const double _X11_retval_fooKd_1;
    185     ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
    186     return _X11_retval_fooKd_1;
     168struct _conc__tuple3_2 __f__FTiiPi____1(void);
     169struct _conc__tuple3_2 __f__FTiiPi__iiPi__1(signed int __anonymous_object14, signed int __x__i_1, signed int *__y__Pi_1);
     170struct _conc__tuple3_2 __f__FTiiPi____1(void){
     171    __attribute__ ((unused)) struct _conc__tuple3_2 ___retval_f__TiiPi__1 = {  };
     172}
     173struct _conc__tuple3_2 __f__FTiiPi__iiPi__1(signed int __anonymous_object15, signed int __x__i_1, signed int *__y__Pi_1){
     174    __attribute__ ((unused)) struct _conc__tuple3_2 ___retval_f__TiiPi__1 = {  };
     175}
     176signed int __f11__Fi_i__1(signed int __anonymous_object16);
     177signed int __f12__Fi___1(void);
     178const double __bar1__Fd___1();
     179const double __bar2__Fd_i__1(signed int __anonymous_object17);
     180const double __bar3__Fd_d__1(double __anonymous_object18);
     181const double __foo__Fd___1(void);
     182const double __foo__Fd_i__1(signed int __anonymous_object19);
     183const double __foo__Fd_d__1(double __anonymous_object20){
     184    __attribute__ ((unused)) const double ___retval_foo__Cd_1;
     185    ((void)((*((double *)(&___retval_foo__Cd_1)))=3.0) /* ?{} */);
     186    return ___retval_foo__Cd_1;
    187187}
    188188struct S {
    189     signed int _X1ii_1;
    190 };
    191 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    192 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    193 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    194 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    195 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    196 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    197     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    198 }
    199 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    200     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    201 }
    202 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    203     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    204 }
    205 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    206     struct S _X4_retS1S_1;
    207     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    208     ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    209     return _X4_retS1S_1;
    210 }
    211 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    212     ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    213 }
    214 struct S _X3rtnFS1S_i__1(signed int __anonymous_object21){
    215     __attribute__ ((unused)) struct S _X11_retval_rtnS1S_1;
    216 }
    217 signed int _X1fFi_Fi_ii_Fi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int _X1pi_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
    218     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    219     signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
    220     signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
    221     signed int (*(*_X1pPA0Fi_i__2)[])(signed int __anonymous_object26);
    222 }
    223 static const signed int *_X2f1FPKi___1(){
    224     __attribute__ ((unused)) const signed int *_X10_retval_f1PKi_1;
    225 }
    226 static const signed int *_X2f2FPKi___1(void){
    227     __attribute__ ((unused)) const signed int *_X10_retval_f2PKi_1;
    228 }
    229 static inline signed int *const _X2f3FPi___1(void){
    230     __attribute__ ((unused)) signed int *const _X10_retval_f3KPi_1;
     189    signed int __i__i_1;
     190};
     191static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     192static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     193static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     194static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     195static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
     196static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     197    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
     198}
     199static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     200    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
     201}
     202static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     203    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
     204}
     205static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     206    struct S ___ret__2sS_1;
     207    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     208    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     209    return ___ret__2sS_1;
     210}
     211static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
     212    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
     213}
     214struct S __rtn__F2sS_i__1(signed int __anonymous_object21){
     215    __attribute__ ((unused)) struct S ___retval_rtn__2sS_1;
     216}
     217signed int __f__Fi_Fi_ii_Fi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int __p__i_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
     218    __attribute__ ((unused)) signed int ___retval_f__i_1;
     219    signed int (*(*__pc__PA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
     220    signed int (*(*__p__PA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
     221    signed int (*(*__p__PA0Fi_i__2)[])(signed int __anonymous_object26);
     222}
     223static const signed int *__f1__FPCi___1(){
     224    __attribute__ ((unused)) const signed int *___retval_f1__PCi_1;
     225}
     226static const signed int *__f2__FPCi___1(void){
     227    __attribute__ ((unused)) const signed int *___retval_f2__PCi_1;
     228}
     229static inline signed int *const __f3__FPi___1(void){
     230    __attribute__ ((unused)) signed int *const ___retval_f3__CPi_1;
    231231}
    232232struct _conc__tuple2_3 {
    … …  
    234234    signed int field_1;
    235235};
    236 static inline const struct _conc__tuple2_3 _X2f4FT2Pii___1(void){
    237     __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f4KT2Pii_1;
    238 }
    239 static const struct _conc__tuple2_3 _X2f5FT2PiKi___1(void){
    240     __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f5KT2PiKi_1;
    241 }
    242 signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned long int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned long int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned long int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned long int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned long int )10)]);
    243 signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned long int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned long int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned long int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned long int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned long int )10)]){
    244     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    245 }
    246 signed int _X1fFi_Pii__1(signed int *_X1fPi_1, signed int _X1ti_1){
    247     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    248     signed int _X1Ti_2;
    249 }
     236static inline const struct _conc__tuple2_3 __f4__FTPii____1(void){
     237    __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f4__CTPii__1;
     238}
     239static const struct _conc__tuple2_3 __f5__FTPiCi____1(void){
     240    __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f5__CTPiCi__1;
     241}
     242signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned long int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned long int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned long int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned long int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned long int )10)]);
     243signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned long int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned long int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned long int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned long int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned long int )10)]){
     244    __attribute__ ((unused)) signed int ___retval_f__i_1;
     245}
     246signed int __f__Fi_Pii__1(signed int *__f__Pi_1, signed int __t__i_1){
     247    __attribute__ ((unused)) signed int ___retval_f__i_1;
     248    signed int __T__i_2;
     249}

  • tests/.expect/functions.x86.txt

    r6d44da1 r341bb80  
    1 void _X1hFv___1(void){
    2 }
    3 signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
    4     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    5     ((void)(*_X1gFv___1)());
    6     ((void)_X1gFv___1());
    7     ((void)(_X1gFv___1=_X1hFv___1));
    8 }
    9 signed int _X2f1Fi___1(){
    10     __attribute__ ((unused)) signed int _X10_retval_f1i_1;
    11 }
    12 signed int _X2f2Fi___1(){
    13     __attribute__ ((unused)) signed int _X10_retval_f2i_1;
    14 }
    15 signed int (*_X2f3FFi_____1())(){
    16     __attribute__ ((unused)) signed int (*_X10_retval_f3Fi___1)();
    17 }
    18 signed int *_X2f4FPi___1(){
    19     __attribute__ ((unused)) signed int *_X10_retval_f4Pi_1;
    20 }
    21 signed int (*_X2f5FFi_____1())(){
    22     __attribute__ ((unused)) signed int (*_X10_retval_f5Fi___1)();
    23 }
    24 signed int *_X2f6FPi___1(){
    25     __attribute__ ((unused)) signed int *_X10_retval_f6Pi_1;
    26 }
    27 signed int *_X2f7FPi___1(){
    28     __attribute__ ((unused)) signed int *_X10_retval_f7Pi_1;
    29 }
    30 signed int **_X2f8FPPi___1(){
    31     __attribute__ ((unused)) signed int **_X10_retval_f8PPi_1;
    32 }
    33 signed int *const *_X2f9FPKPi___1(){
    34     __attribute__ ((unused)) signed int *const *_X10_retval_f9PKPi_1;
    35 }
    36 signed int (*_X3f10FPA0i___1())[]{
    37     __attribute__ ((unused)) signed int (*_X11_retval_f10PA0i_1)[];
    38 }
    39 signed int (*_X3f11FPA0A0i___1())[][((unsigned int )3)]{
    40     __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned int )3)];
    41 }
    42 signed int (*_X3f12FPA0A0i___1())[][((unsigned int )3)]{
    43     __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned int )3)];
    44 }
    45 signed int _X4fII1Fi_i__1(signed int _X1ii_1){
    46     __attribute__ ((unused)) signed int _X12_retval_fII1i_1;
    47 }
    48 const signed int _X4fII2Fi_i__1(signed int _X1ii_1){
    49     __attribute__ ((unused)) const signed int _X12_retval_fII2Ki_1;
    50 }
    51 extern signed int _X4fII3Fi_i__1(signed int _X1ii_1){
    52     __attribute__ ((unused)) signed int _X12_retval_fII3i_1;
    53 }
    54 extern const signed int _X4fII4Fi_i__1(signed int _X1ii_1){
    55     __attribute__ ((unused)) const signed int _X12_retval_fII4Ki_1;
    56 }
    57 signed int *_X4fII5FPi___1(){
    58     __attribute__ ((unused)) signed int *_X12_retval_fII5Pi_1;
    59 }
    60 signed int *const _X4fII6FPi___1(){
    61     __attribute__ ((unused)) signed int *const _X12_retval_fII6KPi_1;
    62 }
    63 const signed long int *_X4fII7FPKl___1(){
    64     __attribute__ ((unused)) const signed long int *_X12_retval_fII7PKl_1;
    65 }
    66 static const signed long int *_X4fII8FPKl___1(){
    67     __attribute__ ((unused)) const signed long int *_X12_retval_fII8PKl_1;
    68 }
    69 static const signed long int *_X4fII9FPKl___1(){
    70     __attribute__ ((unused)) const signed long int *_X12_retval_fII9PKl_1;
    71 }
    72 signed int _X3fO1Fi_i__1(signed int _X1ii_1){
    73     __attribute__ ((unused)) signed int _X11_retval_fO1i_1;
    74 }
    75 signed int _X3fO2Fi_i__1(signed int _X1ii_1){
    76     __attribute__ ((unused)) signed int _X11_retval_fO2i_1;
    77 }
    78 const signed int _X3fO3Fi_i__1(signed int _X1ii_1){
    79     __attribute__ ((unused)) const signed int _X11_retval_fO3Ki_1;
    80 }
    81 extern signed int _X3fO4Fi_i__1(signed int _X1ii_1){
    82     __attribute__ ((unused)) signed int _X11_retval_fO4i_1;
    83 }
    84 extern const signed int _X3fO5Fi_i__1(signed int _X1ii_1){
    85     __attribute__ ((unused)) const signed int _X11_retval_fO5Ki_1;
    86 }
    87 signed int _X1fFi___1(void);
    88 signed int _X1fFi_i__1(signed int __anonymous_object6);
    89 signed int _X1fFi___1(void){
    90     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    91 }
    92 signed int _X1fFi_i__1(signed int __anonymous_object7){
    93     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    94 }
    95 signed int _X1fFi___1(void);
     1void __h__F___1(void){
     2}
     3signed int __f__Fi_Fi__Fi_i_Fi__Fi_i_F____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*__g__F___1)(void)){
     4    __attribute__ ((unused)) signed int ___retval_f__i_1;
     5    ((void)(*__g__F___1)());
     6    ((void)__g__F___1());
     7    ((void)(__g__F___1=__h__F___1));
     8}
     9signed int __f1__Fi___1(){
     10    __attribute__ ((unused)) signed int ___retval_f1__i_1;
     11}
     12signed int __f2__Fi___1(){
     13    __attribute__ ((unused)) signed int ___retval_f2__i_1;
     14}
     15signed int (*__f3__FFi_____1())(){
     16    __attribute__ ((unused)) signed int (*___retval_f3__Fi___1)();
     17}
     18signed int *__f4__FPi___1(){
     19    __attribute__ ((unused)) signed int *___retval_f4__Pi_1;
     20}
     21signed int (*__f5__FFi_____1())(){
     22    __attribute__ ((unused)) signed int (*___retval_f5__Fi___1)();
     23}
     24signed int *__f6__FPi___1(){
     25    __attribute__ ((unused)) signed int *___retval_f6__Pi_1;
     26}
     27signed int *__f7__FPi___1(){
     28    __attribute__ ((unused)) signed int *___retval_f7__Pi_1;
     29}
     30signed int **__f8__FPPi___1(){
     31    __attribute__ ((unused)) signed int **___retval_f8__PPi_1;
     32}
     33signed int *const *__f9__FPCPi___1(){
     34    __attribute__ ((unused)) signed int *const *___retval_f9__PCPi_1;
     35}
     36signed int (*__f10__FPA0i___1())[]{
     37    __attribute__ ((unused)) signed int (*___retval_f10__PA0i_1)[];
     38}
     39signed int (*__f11__FPA0A0i___1())[][((unsigned int )3)]{
     40    __attribute__ ((unused)) signed int (*___retval_f11__PA0A0i_1)[][((unsigned int )3)];
     41}
     42signed int (*__f12__FPA0A0i___1())[][((unsigned int )3)]{
     43    __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned int )3)];
     44}
     45signed int __fII1__Fi_i__1(signed int __i__i_1){
     46    __attribute__ ((unused)) signed int ___retval_fII1__i_1;
     47}
     48const signed int __fII2__Fi_i__1(signed int __i__i_1){
     49    __attribute__ ((unused)) const signed int ___retval_fII2__Ci_1;
     50}
     51extern signed int __fII3__Fi_i__1(signed int __i__i_1){
     52    __attribute__ ((unused)) signed int ___retval_fII3__i_1;
     53}
     54extern const signed int __fII4__Fi_i__1(signed int __i__i_1){
     55    __attribute__ ((unused)) const signed int ___retval_fII4__Ci_1;
     56}
     57signed int *__fII5__FPi___1(){
     58    __attribute__ ((unused)) signed int *___retval_fII5__Pi_1;
     59}
     60signed int *const __fII6__FPi___1(){
     61    __attribute__ ((unused)) signed int *const ___retval_fII6__CPi_1;
     62}
     63const signed long int *__fII7__FPCl___1(){
     64    __attribute__ ((unused)) const signed long int *___retval_fII7__PCl_1;
     65}
     66static const signed long int *__fII8__FPCl___1(){
     67    __attribute__ ((unused)) const signed long int *___retval_fII8__PCl_1;
     68}
     69static const signed long int *__fII9__FPCl___1(){
     70    __attribute__ ((unused)) const signed long int *___retval_fII9__PCl_1;
     71}
     72signed int __fO1__Fi_i__1(signed int __i__i_1){
     73    __attribute__ ((unused)) signed int ___retval_fO1__i_1;
     74}
     75signed int __fO2__Fi_i__1(signed int __i__i_1){
     76    __attribute__ ((unused)) signed int ___retval_fO2__i_1;
     77}
     78const signed int __fO3__Fi_i__1(signed int __i__i_1){
     79    __attribute__ ((unused)) const signed int ___retval_fO3__Ci_1;
     80}
     81extern signed int __fO4__Fi_i__1(signed int __i__i_1){
     82    __attribute__ ((unused)) signed int ___retval_fO4__i_1;
     83}
     84extern const signed int __fO5__Fi_i__1(signed int __i__i_1){
     85    __attribute__ ((unused)) const signed int ___retval_fO5__Ci_1;
     86}
     87signed int __f__Fi___1(void);
     88signed int __f__Fi_i__1(signed int __anonymous_object6);
     89signed int __f__Fi___1(void){
     90    __attribute__ ((unused)) signed int ___retval_f__i_1;
     91}
     92signed int __f__Fi_i__1(signed int __anonymous_object7){
     93    __attribute__ ((unused)) signed int ___retval_f__i_1;
     94}
     95signed int __f__Fi___1(void);
    9696struct _tuple2_ {
    9797};
    98 static inline void _layoutof__tuple2_(unsigned long int *_sizeof__tuple2_, unsigned long int *_alignof__tuple2_, unsigned long int *_offsetof__tuple2_, unsigned long int _sizeof_Y15tuple_param_2_0, unsigned long int _alignof_Y15tuple_param_2_0, unsigned long int _sizeof_Y15tuple_param_2_1, unsigned long int _alignof_Y15tuple_param_2_1){
     98static inline void _layoutof__tuple2_(unsigned long int *_sizeof__tuple2_, unsigned long int *_alignof__tuple2_, unsigned long int *_offsetof__tuple2_, unsigned long int _sizeof_16ttuple_param_2_0, unsigned long int _alignof_16ttuple_param_2_0, unsigned long int _sizeof_16ttuple_param_2_1, unsigned long int _alignof_16ttuple_param_2_1){
    9999    ((void)((*_sizeof__tuple2_)=0));
    100100    ((void)((*_alignof__tuple2_)=1));
    101101    ((void)(_offsetof__tuple2_[0]=(*_sizeof__tuple2_)));
    102     ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_0));
    103     if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_0) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_0));
    104 
    105     if ( ((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)) ) ((void)((*_sizeof__tuple2_)+=(_alignof_Y15tuple_param_2_1-((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)))));
     102    ((void)((*_sizeof__tuple2_)+=_sizeof_16ttuple_param_2_0));
     103    if ( ((*_alignof__tuple2_)<_alignof_16ttuple_param_2_0) ) ((void)((*_alignof__tuple2_)=_alignof_16ttuple_param_2_0));
     104
     105    if ( ((*_sizeof__tuple2_)&(_alignof_16ttuple_param_2_1-1)) ) ((void)((*_sizeof__tuple2_)+=(_alignof_16ttuple_param_2_1-((*_sizeof__tuple2_)&(_alignof_16ttuple_param_2_1-1)))));
    106106
    107107    ((void)(_offsetof__tuple2_[1]=(*_sizeof__tuple2_)));
    108     ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_1));
    109     if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_1) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_1));
     108    ((void)((*_sizeof__tuple2_)+=_sizeof_16ttuple_param_2_1));
     109    if ( ((*_alignof__tuple2_)<_alignof_16ttuple_param_2_1) ) ((void)((*_alignof__tuple2_)=_alignof_16ttuple_param_2_1));
    110110
    111111    if ( ((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)) ) ((void)((*_sizeof__tuple2_)+=((*_alignof__tuple2_)-((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)))));
    … …  
    116116    signed int field_1;
    117117};
    118 struct _conc__tuple2_0 _X1fFT2ii___1(void);
    119 struct _conc__tuple2_0 _X1fFT2ii_ii__1(signed int __anonymous_object8, signed int _X1xi_1);
    120 struct _conc__tuple2_0 _X1fFT2ii___1(void){
    121     __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
    122 }
    123 struct _conc__tuple2_0 _X1fFT2ii_ii__1(signed int __anonymous_object9, signed int _X1xi_1){
    124     __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
     118struct _conc__tuple2_0 __f__FTii____1(void);
     119struct _conc__tuple2_0 __f__FTii__ii__1(signed int __anonymous_object8, signed int __x__i_1);
     120struct _conc__tuple2_0 __f__FTii____1(void){
     121    __attribute__ ((unused)) struct _conc__tuple2_0 ___retval_f__Tii__1 = {  };
     122}
     123struct _conc__tuple2_0 __f__FTii__ii__1(signed int __anonymous_object9, signed int __x__i_1){
     124    __attribute__ ((unused)) struct _conc__tuple2_0 ___retval_f__Tii__1 = {  };
    125125}
    126126struct _tuple3_ {
    127127};
    128 static inline void _layoutof__tuple3_(unsigned long int *_sizeof__tuple3_, unsigned long int *_alignof__tuple3_, unsigned long int *_offsetof__tuple3_, unsigned long int _sizeof_Y15tuple_param_3_0, unsigned long int _alignof_Y15tuple_param_3_0, unsigned long int _sizeof_Y15tuple_param_3_1, unsigned long int _alignof_Y15tuple_param_3_1, unsigned long int _sizeof_Y15tuple_param_3_2, unsigned long int _alignof_Y15tuple_param_3_2){
     128static inline void _layoutof__tuple3_(unsigned long int *_sizeof__tuple3_, unsigned long int *_alignof__tuple3_, unsigned long int *_offsetof__tuple3_, unsigned long int _sizeof_16ttuple_param_3_0, unsigned long int _alignof_16ttuple_param_3_0, unsigned long int _sizeof_16ttuple_param_3_1, unsigned long int _alignof_16ttuple_param_3_1, unsigned long int _sizeof_16ttuple_param_3_2, unsigned long int _alignof_16ttuple_param_3_2){
    129129    ((void)((*_sizeof__tuple3_)=0));
    130130    ((void)((*_alignof__tuple3_)=1));
    131131    ((void)(_offsetof__tuple3_[0]=(*_sizeof__tuple3_)));
    132     ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_0));
    133     if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_0) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_0));
    134 
    135     if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_1-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)))));
     132    ((void)((*_sizeof__tuple3_)+=_sizeof_16ttuple_param_3_0));
     133    if ( ((*_alignof__tuple3_)<_alignof_16ttuple_param_3_0) ) ((void)((*_alignof__tuple3_)=_alignof_16ttuple_param_3_0));
     134
     135    if ( ((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_1-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_16ttuple_param_3_1-((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_1-1)))));
    136136
    137137    ((void)(_offsetof__tuple3_[1]=(*_sizeof__tuple3_)));
    138     ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_1));
    139     if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_1) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_1));
    140 
    141     if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_2-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)))));
     138    ((void)((*_sizeof__tuple3_)+=_sizeof_16ttuple_param_3_1));
     139    if ( ((*_alignof__tuple3_)<_alignof_16ttuple_param_3_1) ) ((void)((*_alignof__tuple3_)=_alignof_16ttuple_param_3_1));
     140
     141    if ( ((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_2-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_16ttuple_param_3_2-((*_sizeof__tuple3_)&(_alignof_16ttuple_param_3_2-1)))));
    142142
    143143    ((void)(_offsetof__tuple3_[2]=(*_sizeof__tuple3_)));
    144     ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_2));
    145     if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_2) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_2));
     144    ((void)((*_sizeof__tuple3_)+=_sizeof_16ttuple_param_3_2));
     145    if ( ((*_alignof__tuple3_)<_alignof_16ttuple_param_3_2) ) ((void)((*_alignof__tuple3_)=_alignof_16ttuple_param_3_2));
    146146
    147147    if ( ((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)) ) ((void)((*_sizeof__tuple3_)+=((*_alignof__tuple3_)-((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)))));
    … …  
    153153    signed int field_2;
    154154};
    155 struct _conc__tuple3_1 _X1fFT3iii___1(void);
    156 struct _conc__tuple3_1 _X1fFT3iii_iii__1(signed int __anonymous_object10, signed int _X1xi_1, signed int __anonymous_object11);
    157 struct _conc__tuple3_1 _X1fFT3iii___1(void){
    158     __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
    159 }
    160 struct _conc__tuple3_1 _X1fFT3iii_iii__1(signed int __anonymous_object12, signed int _X1xi_1, signed int __anonymous_object13){
    161     __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
     155struct _conc__tuple3_1 __f__FTiii____1(void);
     156struct _conc__tuple3_1 __f__FTiii__iii__1(signed int __anonymous_object10, signed int __x__i_1, signed int __anonymous_object11);
     157struct _conc__tuple3_1 __f__FTiii____1(void){
     158    __attribute__ ((unused)) struct _conc__tuple3_1 ___retval_f__Tiii__1 = {  };
     159}
     160struct _conc__tuple3_1 __f__FTiii__iii__1(signed int __anonymous_object12, signed int __x__i_1, signed int __anonymous_object13){
     161    __attribute__ ((unused)) struct _conc__tuple3_1 ___retval_f__Tiii__1 = {  };
    162162}
    163163struct _conc__tuple3_2 {
    … …  
    166166    signed int *field_2;
    167167};
    168 struct _conc__tuple3_2 _X1fFT3iiPi___1(void);
    169 struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(signed int __anonymous_object14, signed int _X1xi_1, signed int *_X1yPi_1);
    170 struct _conc__tuple3_2 _X1fFT3iiPi___1(void){
    171     __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
    172 }
    173 struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(signed int __anonymous_object15, signed int _X1xi_1, signed int *_X1yPi_1){
    174     __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
    175 }
    176 signed int _X3f11Fi_i__1(signed int __anonymous_object16);
    177 signed int _X3f12Fi___1(void);
    178 const double _X4bar1Fd___1();
    179 const double _X4bar2Fd_i__1(signed int __anonymous_object17);
    180 const double _X4bar3Fd_d__1(double __anonymous_object18);
    181 const double _X3fooFd___1(void);
    182 const double _X3fooFd_i__1(signed int __anonymous_object19);
    183 const double _X3fooFd_d__1(double __anonymous_object20){
    184     __attribute__ ((unused)) const double _X11_retval_fooKd_1;
    185     ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
    186     return _X11_retval_fooKd_1;
     168struct _conc__tuple3_2 __f__FTiiPi____1(void);
     169struct _conc__tuple3_2 __f__FTiiPi__iiPi__1(signed int __anonymous_object14, signed int __x__i_1, signed int *__y__Pi_1);
     170struct _conc__tuple3_2 __f__FTiiPi____1(void){
     171    __attribute__ ((unused)) struct _conc__tuple3_2 ___retval_f__TiiPi__1 = {  };
     172}
     173struct _conc__tuple3_2 __f__FTiiPi__iiPi__1(signed int __anonymous_object15, signed int __x__i_1, signed int *__y__Pi_1){
     174    __attribute__ ((unused)) struct _conc__tuple3_2 ___retval_f__TiiPi__1 = {  };
     175}
     176signed int __f11__Fi_i__1(signed int __anonymous_object16);
     177signed int __f12__Fi___1(void);
     178const double __bar1__Fd___1();
     179const double __bar2__Fd_i__1(signed int __anonymous_object17);
     180const double __bar3__Fd_d__1(double __anonymous_object18);
     181const double __foo__Fd___1(void);
     182const double __foo__Fd_i__1(signed int __anonymous_object19);
     183const double __foo__Fd_d__1(double __anonymous_object20){
     184    __attribute__ ((unused)) const double ___retval_foo__Cd_1;
     185    ((void)((*((double *)(&___retval_foo__Cd_1)))=3.0) /* ?{} */);
     186    return ___retval_foo__Cd_1;
    187187}
    188188struct S {
    189     signed int _X1ii_1;
    190 };
    191 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    192 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    193 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
    194 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
    195 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    196 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    197     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    198 }
    199 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    200     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    201 }
    202 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    203     ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    204 }
    205 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    206     struct S _X4_retS1S_1;
    207     ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    208     ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    209     return _X4_retS1S_1;
    210 }
    211 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    212     ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    213 }
    214 struct S _X3rtnFS1S_i__1(signed int __anonymous_object21){
    215     __attribute__ ((unused)) struct S _X11_retval_rtnS1S_1;
    216 }
    217 signed int _X1fFi_Fi_ii_Fi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int _X1pi_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
    218     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    219     signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
    220     signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
    221     signed int (*(*_X1pPA0Fi_i__2)[])(signed int __anonymous_object26);
    222 }
    223 static const signed int *_X2f1FPKi___1(){
    224     __attribute__ ((unused)) const signed int *_X10_retval_f1PKi_1;
    225 }
    226 static const signed int *_X2f2FPKi___1(void){
    227     __attribute__ ((unused)) const signed int *_X10_retval_f2PKi_1;
    228 }
    229 static inline signed int *const _X2f3FPi___1(void){
    230     __attribute__ ((unused)) signed int *const _X10_retval_f3KPi_1;
     189    signed int __i__i_1;
     190};
     191static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     192static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     193static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     194static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     195static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
     196static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     197    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
     198}
     199static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     200    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
     201}
     202static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     203    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
     204}
     205static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     206    struct S ___ret__2sS_1;
     207    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     208    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     209    return ___ret__2sS_1;
     210}
     211static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
     212    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
     213}
     214struct S __rtn__F2sS_i__1(signed int __anonymous_object21){
     215    __attribute__ ((unused)) struct S ___retval_rtn__2sS_1;
     216}
     217signed int __f__Fi_Fi_ii_Fi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int __p__i_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
     218    __attribute__ ((unused)) signed int ___retval_f__i_1;
     219    signed int (*(*__pc__PA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
     220    signed int (*(*__p__PA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
     221    signed int (*(*__p__PA0Fi_i__2)[])(signed int __anonymous_object26);
     222}
     223static const signed int *__f1__FPCi___1(){
     224    __attribute__ ((unused)) const signed int *___retval_f1__PCi_1;
     225}
     226static const signed int *__f2__FPCi___1(void){
     227    __attribute__ ((unused)) const signed int *___retval_f2__PCi_1;
     228}
     229static inline signed int *const __f3__FPi___1(void){
     230    __attribute__ ((unused)) signed int *const ___retval_f3__CPi_1;
    231231}
    232232struct _conc__tuple2_3 {
    … …  
    234234    signed int field_1;
    235235};
    236 static inline const struct _conc__tuple2_3 _X2f4FT2Pii___1(void){
    237     __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f4KT2Pii_1;
    238 }
    239 static const struct _conc__tuple2_3 _X2f5FT2PiKi___1(void){
    240     __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f5KT2PiKi_1;
    241 }
    242 signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned int )10)]);
    243 signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned int )10)]){
    244     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    245 }
    246 signed int _X1fFi_Pii__1(signed int *_X1fPi_1, signed int _X1ti_1){
    247     __attribute__ ((unused)) signed int _X9_retval_fi_1;
    248     signed int _X1Ti_2;
    249 }
     236static inline const struct _conc__tuple2_3 __f4__FTPii____1(void){
     237    __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f4__CTPii__1;
     238}
     239static const struct _conc__tuple2_3 __f5__FTPiCi____1(void){
     240    __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f5__CTPiCi__1;
     241}
     242signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned int )10)]);
     243signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned int )10)]){
     244    __attribute__ ((unused)) signed int ___retval_f__i_1;
     245}
     246signed int __f__Fi_Pii__1(signed int *__f__Pi_1, signed int __t__i_1){
     247    __attribute__ ((unused)) signed int ___retval_f__i_1;
     248    signed int __T__i_2;
     249}

  • tests/.expect/gccExtensions.x64.txt

    r6d44da1 r341bb80  
    1 extern signed int _X1xi_1 asm ( "xx" );
    2 signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
    3     __attribute__ ((unused)) signed int _X12_retval_maini_1;
     1extern signed int __x__i_1 asm ( "xx" );
     2signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     3    __attribute__ ((unused)) signed int ___retval_main__i_1;
    44    asm ( "nop" :  :  :  );
    55    asm ( "nop" :  :  :  );
    66    asm ( "nop" :  :  :  );
    7     static signed int _X1yi_2 asm ( "yy" );
    8     static signed int *_X1zPi_2 asm ( "zz" );
    9     signed int _X3srci_2;
    10     signed int _X3dsti_2;
     7    static signed int __y__i_2 asm ( "yy" );
     8    static signed int *__z__Pi_2 asm ( "zz" );
     9    signed int __src__i_2;
     10    signed int __dst__i_2;
    1111    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
    12     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) :  :  );
    13     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) :  );
    14     asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
    15     L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
    16     double _Complex _X2c1Cd_2;
    17     double _Complex _X2c2Cd_2;
    18     const signed int _X2i1Ki_2;
    19     const signed int _X2i2Ki_2;
    20     const signed int _X2i3Ki_2;
    21     inline signed int _X2f1Fi___2(){
    22         __attribute__ ((unused)) signed int _X10_retval_f1i_2;
     12    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) :  :  );
     13    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
     14    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     15    L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( __src__i_2 ), "r" ( (&__dst__i_2) ) : "r5", "memory" : L1, L2 );
     16    double _Complex __c1__Xd_2;
     17    double _Complex __c2__Xd_2;
     18    const signed int __i1__Ci_2;
     19    const signed int __i2__Ci_2;
     20    const signed int __i3__Ci_2;
     21    inline signed int __f1__Fi___2(){
     22        __attribute__ ((unused)) signed int ___retval_f1__i_2;
    2323    }
    24     inline signed int _X2f2Fi___2(){
    25         __attribute__ ((unused)) signed int _X10_retval_f2i_2;
     24    inline signed int __f2__Fi___2(){
     25        __attribute__ ((unused)) signed int ___retval_f2__i_2;
    2626    }
    27     signed int _X2s1i_2;
    28     signed int _X2s2i_2;
    29     volatile signed int _X2v1Vi_2;
    30     volatile signed int _X2v2Vi_2;
    31     signed int _X2t1i_2;
    32     signed int _X2t2i_2;
    33     __extension__ const signed int _X2exKi_2;
     27    signed int __s1__i_2;
     28    signed int __s2__i_2;
     29    volatile signed int __v1__Vi_2;
     30    volatile signed int __v2__Vi_2;
     31    signed int __t1___2;
     32    signed int __t2___2;
     33    __extension__ const signed int __ex__Ci_2;
    3434    struct S {
    35         __extension__ signed int _X1ai_2;
    36         __extension__ signed int _X1bi_2;
    37         __extension__ signed int _X1ci_2;
     35        __extension__ signed int __a__i_2;
     36        __extension__ signed int __b__i_2;
     37        __extension__ signed int __c__i_2;
    3838    };
    39     inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    40         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    41         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    42         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     39    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     40        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
     41        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     42        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
    4343    }
    44     inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    45         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    46         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    47         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
     44    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     45        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
     46        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
     47        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
    4848    }
    49     inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    50         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    51         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    52         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
     49    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     50        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
     51        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
     52        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
    5353    }
    54     inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    55         struct S _X4_retS1S_2;
    56         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    57         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    58         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    59         ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    60         return _X4_retS1S_2;
     54    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     55        struct S ___ret__2sS_2;
     56        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
     57        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
     58        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
     59        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_2)));
     60        return ___ret__2sS_2;
    6161    }
    62     inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    63         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    64         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    65         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     62    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
     63        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     64        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     65        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
    6666    }
    67     inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    68         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    69         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    70         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     67    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
     68        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     69        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     70        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
    7171    }
    72     inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    73         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    74         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    75         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     72    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     73        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     74        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     75        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
    7676    }
    77     signed int _X1ii_2 = __extension__ 3;
    78     __extension__ signed int _X1ai_2;
    79     __extension__ signed int _X1bi_2;
    80     __extension__ signed int _X1ci_2;
    81     ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    82     ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
    83     ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    84     signed int _X2a1i_2;
    85     const signed int _X2a2Ki_2;
    86     static const signed int _X2a3Ki_2;
    87     static const signed int _X2a4Ki_2;
    88     static const signed int _X2a5Ki_2;
    89     static const signed int _X2a6Ki_2;
    90     static const signed int _X2a7Ki_2;
    91     signed int *_X2p1Pi_2;
    92     signed int *_X2p2Pi_2;
     77    signed int __i__i_2 = __extension__ 3;
     78    __extension__ signed int __a__i_2;
     79    __extension__ signed int __b__i_2;
     80    __extension__ signed int __c__i_2;
     81    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     82    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     83    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     84    signed int __a1__i_2;
     85    const signed int __a2__Ci_2;
     86    static const signed int __a3__Ci_2;
     87    static const signed int __a4__Ci_2;
     88    static const signed int __a5__Ci_2;
     89    static const signed int __a6__Ci_2;
     90    static const signed int __a7__Ci_2;
     91    signed int *__p1__Pi_2;
     92    signed int *__p2__Pi_2;
    9393    struct s1;
    9494    struct s2 {
    95         signed int _X1ii_2;
     95        signed int __i__i_2;
    9696    };
    97     inline void _X12_constructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    98         ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
     97    inline void ___constructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
     98        ((void)((*___dst__3ss2_2).__i__i_2) /* ?{} */);
    9999    }
    100     inline void _X12_constructorFv_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    101         ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
     100    inline void ___constructor__F_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_2){
     101        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2) /* ?{} */);
    102102    }
    103     inline void _X11_destructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    104         ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
     103    inline void ___destructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
     104        ((void)((*___dst__3ss2_2).__i__i_2) /* ^?{} */);
    105105    }
    106     inline struct s2 _X16_operator_assignFS2s2_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    107         struct s2 _X4_retS2s2_2;
    108         ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
    109         ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
    110         return _X4_retS2s2_2;
     106    inline struct s2 ___operator_assign__F3ss2_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_2){
     107        struct s2 ___ret__3ss2_2;
     108        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
     109        ((void)___constructor__F_3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__3ss2_2)));
     110        return ___ret__3ss2_2;
    111111    }
    112     inline void _X12_constructorFv_S2s2i_autogen___2(struct s2 *_X4_dstS2s2_2, signed int _X1ii_2){
    113         ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
     112    inline void ___constructor__F_3ss2i_autogen___2(struct s2 *___dst__3ss2_2, signed int __i__i_2){
     113        ((void)((*___dst__3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
    114114    }
    115115    struct s3 {
    116         signed int _X1ii_2;
     116        signed int __i__i_2;
    117117    };
    118     inline void _X12_constructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    119         ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
     118    inline void ___constructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
     119        ((void)((*___dst__3ss3_2).__i__i_2) /* ?{} */);
    120120    }
    121     inline void _X12_constructorFv_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    122         ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
     121    inline void ___constructor__F_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_2){
     122        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2) /* ?{} */);
    123123    }
    124     inline void _X11_destructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    125         ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
     124    inline void ___destructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
     125        ((void)((*___dst__3ss3_2).__i__i_2) /* ^?{} */);
    126126    }
    127     inline struct s3 _X16_operator_assignFS2s3_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    128         struct s3 _X4_retS2s3_2;
    129         ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
    130         ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
    131         return _X4_retS2s3_2;
     127    inline struct s3 ___operator_assign__F3ss3_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_2){
     128        struct s3 ___ret__3ss3_2;
     129        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
     130        ((void)___constructor__F_3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__3ss3_2)));
     131        return ___ret__3ss3_2;
    132132    }
    133     inline void _X12_constructorFv_S2s3i_autogen___2(struct s3 *_X4_dstS2s3_2, signed int _X1ii_2){
    134         ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     133    inline void ___constructor__F_3ss3i_autogen___2(struct s3 *___dst__3ss3_2, signed int __i__i_2){
     134        ((void)((*___dst__3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
    135135    }
    136     struct s3 _X2x1S2s3_2;
    137     struct s3 _X2y1S2s3_2;
     136    struct s3 __x1__3ss3_2;
     137    struct s3 __y1__3ss3_2;
    138138    struct s4 {
    139         signed int _X1ii_2;
     139        signed int __i__i_2;
    140140    };
    141     inline void _X12_constructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    142         ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
     141    inline void ___constructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
     142        ((void)((*___dst__3ss4_2).__i__i_2) /* ?{} */);
    143143    }
    144     inline void _X12_constructorFv_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    145         ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
     144    inline void ___constructor__F_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_2){
     145        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2) /* ?{} */);
    146146    }
    147     inline void _X11_destructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    148         ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
     147    inline void ___destructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
     148        ((void)((*___dst__3ss4_2).__i__i_2) /* ^?{} */);
    149149    }
    150     inline struct s4 _X16_operator_assignFS2s4_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    151         struct s4 _X4_retS2s4_2;
    152         ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
    153         ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
    154         return _X4_retS2s4_2;
     150    inline struct s4 ___operator_assign__F3ss4_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_2){
     151        struct s4 ___ret__3ss4_2;
     152        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
     153        ((void)___constructor__F_3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__3ss4_2)));
     154        return ___ret__3ss4_2;
    155155    }
    156     inline void _X12_constructorFv_S2s4i_autogen___2(struct s4 *_X4_dstS2s4_2, signed int _X1ii_2){
    157         ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
     156    inline void ___constructor__F_3ss4i_autogen___2(struct s4 *___dst__3ss4_2, signed int __i__i_2){
     157        ((void)((*___dst__3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
    158158    }
    159     struct s4 _X2x2S2s4_2;
    160     struct s4 _X2y2S2s4_2;
    161     signed int _X2m1A0i_2[((unsigned long int )10)];
    162     signed int _X2m2A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
    163     signed int _X2m3A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
    164     ((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
    165     return _X12_retval_maini_1;
    166     ((void)(_X12_retval_maini_1=0) /* ?{} */);
    167     return _X12_retval_maini_1;
     159    struct s4 __x2__3ss4_2;
     160    struct s4 __y2__3ss4_2;
     161    signed int __m1__A0i_2[((unsigned long int )10)];
     162    signed int __m2__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     163    signed int __m3__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     164    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     165    return ___retval_main__i_1;
     166    ((void)(___retval_main__i_1=0) /* ?{} */);
     167    return ___retval_main__i_1;
    168168}
    169 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return _X4mainFi_iPPKc__1((signed int )argc, (const char **)argv); }
     169static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    170170static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    171 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    172     __attribute__ ((unused)) signed int _X12_retval_maini_1;
     171signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     172    __attribute__ ((unused)) signed int ___retval_main__i_1;
    173173    signed int _tmp_cp_ret2;
    174     ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret2)) /* ?{} */);
     174    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret2=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret2)) /* ?{} */);
    175175    ((void)(_tmp_cp_ret2) /* ^?{} */);
    176     return _X12_retval_maini_1;
     176    return ___retval_main__i_1;
    177177}

  • tests/.expect/gccExtensions.x86.txt

    r6d44da1 r341bb80  
    1 extern signed int _X1xi_1 asm ( "xx" );
    2 signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
    3     __attribute__ ((unused)) signed int _X12_retval_maini_1;
     1extern signed int __x__i_1 asm ( "xx" );
     2signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     3    __attribute__ ((unused)) signed int ___retval_main__i_1;
    44    asm ( "nop" :  :  :  );
    55    asm ( "nop" :  :  :  );
    66    asm ( "nop" :  :  :  );
    7     static signed int _X1yi_2 asm ( "yy" );
    8     static signed int *_X1zPi_2 asm ( "zz" );
    9     signed int _X3srci_2;
    10     signed int _X3dsti_2;
     7    static signed int __y__i_2 asm ( "yy" );
     8    static signed int *__z__Pi_2 asm ( "zz" );
     9    signed int __src__i_2;
     10    signed int __dst__i_2;
    1111    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
    12     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) :  :  );
    13     asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) :  );
    14     asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
    15     L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
    16     double _Complex _X2c1Cd_2;
    17     double _Complex _X2c2Cd_2;
    18     const signed int _X2i1Ki_2;
    19     const signed int _X2i2Ki_2;
    20     const signed int _X2i3Ki_2;
    21     inline signed int _X2f1Fi___2(){
    22         __attribute__ ((unused)) signed int _X10_retval_f1i_2;
     12    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) :  :  );
     13    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
     14    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     15    L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( __src__i_2 ), "r" ( (&__dst__i_2) ) : "r5", "memory" : L1, L2 );
     16    double _Complex __c1__Xd_2;
     17    double _Complex __c2__Xd_2;
     18    const signed int __i1__Ci_2;
     19    const signed int __i2__Ci_2;
     20    const signed int __i3__Ci_2;
     21    inline signed int __f1__Fi___2(){
     22        __attribute__ ((unused)) signed int ___retval_f1__i_2;
    2323    }
    24     inline signed int _X2f2Fi___2(){
    25         __attribute__ ((unused)) signed int _X10_retval_f2i_2;
     24    inline signed int __f2__Fi___2(){
     25        __attribute__ ((unused)) signed int ___retval_f2__i_2;
    2626    }
    27     signed int _X2s1i_2;
    28     signed int _X2s2i_2;
    29     volatile signed int _X2v1Vi_2;
    30     volatile signed int _X2v2Vi_2;
    31     signed int _X2t1i_2;
    32     signed int _X2t2i_2;
    33     __extension__ const signed int _X2exKi_2;
     27    signed int __s1__i_2;
     28    signed int __s2__i_2;
     29    volatile signed int __v1__Vi_2;
     30    volatile signed int __v2__Vi_2;
     31    signed int __t1___2;
     32    signed int __t2___2;
     33    __extension__ const signed int __ex__Ci_2;
    3434    struct S {
    35         __extension__ signed int _X1ai_2;
    36         __extension__ signed int _X1bi_2;
    37         __extension__ signed int _X1ci_2;
     35        __extension__ signed int __a__i_2;
     36        __extension__ signed int __b__i_2;
     37        __extension__ signed int __c__i_2;
    3838    };
    39     inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    40         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    41         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    42         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     39    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     40        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
     41        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     42        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
    4343    }
    44     inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    45         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    46         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    47         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
     44    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     45        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
     46        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
     47        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
    4848    }
    49     inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    50         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    51         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    52         ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
     49    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
     50        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
     51        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
     52        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
    5353    }
    54     inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    55         struct S _X4_retS1S_2;
    56         ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    57         ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    58         ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    59         ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    60         return _X4_retS1S_2;
     54    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
     55        struct S ___ret__2sS_2;
     56        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
     57        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
     58        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
     59        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_2)));
     60        return ___ret__2sS_2;
    6161    }
    62     inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    63         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    64         ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    65         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     62    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
     63        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     64        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
     65        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
    6666    }
    67     inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    68         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    69         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    70         ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     67    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
     68        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     69        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     70        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
    7171    }
    72     inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    73         ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    74         ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    75         ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     72    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     73        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
     74        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
     75        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
    7676    }
    77     signed int _X1ii_2 = __extension__ 3;
    78     __extension__ signed int _X1ai_2;
    79     __extension__ signed int _X1bi_2;
    80     __extension__ signed int _X1ci_2;
    81     ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    82     ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
    83     ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    84     signed int _X2a1i_2;
    85     const signed int _X2a2Ki_2;
    86     static const signed int _X2a3Ki_2;
    87     static const signed int _X2a4Ki_2;
    88     static const signed int _X2a5Ki_2;
    89     static const signed int _X2a6Ki_2;
    90     static const signed int _X2a7Ki_2;
    91     signed int *_X2p1Pi_2;
    92     signed int *_X2p2Pi_2;
     77    signed int __i__i_2 = __extension__ 3;
     78    __extension__ signed int __a__i_2;
     79    __extension__ signed int __b__i_2;
     80    __extension__ signed int __c__i_2;
     81    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     82    ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     83    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     84    signed int __a1__i_2;
     85    const signed int __a2__Ci_2;
     86    static const signed int __a3__Ci_2;
     87    static const signed int __a4__Ci_2;
     88    static const signed int __a5__Ci_2;
     89    static const signed int __a6__Ci_2;
     90    static const signed int __a7__Ci_2;
     91    signed int *__p1__Pi_2;
     92    signed int *__p2__Pi_2;
    9393    struct s1;
    9494    struct s2 {
    95         signed int _X1ii_2;
     95        signed int __i__i_2;
    9696    };
    97     inline void _X12_constructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    98         ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
     97    inline void ___constructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
     98        ((void)((*___dst__3ss2_2).__i__i_2) /* ?{} */);
    9999    }
    100     inline void _X12_constructorFv_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    101         ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
     100    inline void ___constructor__F_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_2){
     101        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2) /* ?{} */);
    102102    }
    103     inline void _X11_destructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    104         ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
     103    inline void ___destructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
     104        ((void)((*___dst__3ss2_2).__i__i_2) /* ^?{} */);
    105105    }
    106     inline struct s2 _X16_operator_assignFS2s2_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    107         struct s2 _X4_retS2s2_2;
    108         ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
    109         ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
    110         return _X4_retS2s2_2;
     106    inline struct s2 ___operator_assign__F3ss2_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_2){
     107        struct s2 ___ret__3ss2_2;
     108        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
     109        ((void)___constructor__F_3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__3ss2_2)));
     110        return ___ret__3ss2_2;
    111111    }
    112     inline void _X12_constructorFv_S2s2i_autogen___2(struct s2 *_X4_dstS2s2_2, signed int _X1ii_2){
    113         ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
     112    inline void ___constructor__F_3ss2i_autogen___2(struct s2 *___dst__3ss2_2, signed int __i__i_2){
     113        ((void)((*___dst__3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
    114114    }
    115115    struct s3 {
    116         signed int _X1ii_2;
     116        signed int __i__i_2;
    117117    };
    118     inline void _X12_constructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    119         ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
     118    inline void ___constructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
     119        ((void)((*___dst__3ss3_2).__i__i_2) /* ?{} */);
    120120    }
    121     inline void _X12_constructorFv_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    122         ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
     121    inline void ___constructor__F_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_2){
     122        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2) /* ?{} */);
    123123    }
    124     inline void _X11_destructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    125         ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
     124    inline void ___destructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
     125        ((void)((*___dst__3ss3_2).__i__i_2) /* ^?{} */);
    126126    }
    127     inline struct s3 _X16_operator_assignFS2s3_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    128         struct s3 _X4_retS2s3_2;
    129         ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
    130         ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
    131         return _X4_retS2s3_2;
     127    inline struct s3 ___operator_assign__F3ss3_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_2){
     128        struct s3 ___ret__3ss3_2;
     129        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
     130        ((void)___constructor__F_3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__3ss3_2)));
     131        return ___ret__3ss3_2;
    132132    }
    133     inline void _X12_constructorFv_S2s3i_autogen___2(struct s3 *_X4_dstS2s3_2, signed int _X1ii_2){
    134         ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     133    inline void ___constructor__F_3ss3i_autogen___2(struct s3 *___dst__3ss3_2, signed int __i__i_2){
     134        ((void)((*___dst__3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
    135135    }
    136     struct s3 _X2x1S2s3_2;
    137     struct s3 _X2y1S2s3_2;
     136    struct s3 __x1__3ss3_2;
     137    struct s3 __y1__3ss3_2;
    138138    struct s4 {
    139         signed int _X1ii_2;
     139        signed int __i__i_2;
    140140    };
    141     inline void _X12_constructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    142         ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
     141    inline void ___constructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
     142        ((void)((*___dst__3ss4_2).__i__i_2) /* ?{} */);
    143143    }
    144     inline void _X12_constructorFv_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    145         ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
     144    inline void ___constructor__F_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_2){
     145        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2) /* ?{} */);
    146146    }
    147     inline void _X11_destructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    148         ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
     147    inline void ___destructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
     148        ((void)((*___dst__3ss4_2).__i__i_2) /* ^?{} */);
    149149    }
    150     inline struct s4 _X16_operator_assignFS2s4_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    151         struct s4 _X4_retS2s4_2;
    152         ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
    153         ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
    154         return _X4_retS2s4_2;
     150    inline struct s4 ___operator_assign__F3ss4_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_2){
     151        struct s4 ___ret__3ss4_2;
     152        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
     153        ((void)___constructor__F_3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__3ss4_2)));
     154        return ___ret__3ss4_2;
    155155    }
    156     inline void _X12_constructorFv_S2s4i_autogen___2(struct s4 *_X4_dstS2s4_2, signed int _X1ii_2){
    157         ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
     156    inline void ___constructor__F_3ss4i_autogen___2(struct s4 *___dst__3ss4_2, signed int __i__i_2){
     157        ((void)((*___dst__3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
    158158    }
    159     struct s4 _X2x2S2s4_2;
    160     struct s4 _X2y2S2s4_2;
    161     signed int _X2m1A0i_2[((unsigned int )10)];
    162     signed int _X2m2A0A0i_2[((unsigned int )10)][((unsigned int )10)];
    163     signed int _X2m3A0A0i_2[((unsigned int )10)][((unsigned int )10)];
    164     ((void)(_X12_retval_maini_1=((signed int )0)) /* ?{} */);
    165     return _X12_retval_maini_1;
    166     ((void)(_X12_retval_maini_1=0) /* ?{} */);
    167     return _X12_retval_maini_1;
     159    struct s4 __x2__3ss4_2;
     160    struct s4 __y2__3ss4_2;
     161    signed int __m1__A0i_2[((unsigned int )10)];
     162    signed int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     163    signed int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     164    ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     165    return ___retval_main__i_1;
     166    ((void)(___retval_main__i_1=0) /* ?{} */);
     167    return ___retval_main__i_1;
    168168}
    169 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return _X4mainFi_iPPKc__1((signed int )argc, (const char **)argv); }
     169static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    170170static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    171 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    172     __attribute__ ((unused)) signed int _X12_retval_maini_1;
     171signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){
     172    __attribute__ ((unused)) signed int ___retval_main__i_1;
    173173    signed int _tmp_cp_ret2;
    174     ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret2=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret2)) /* ?{} */);
     174    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret2=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret2)) /* ?{} */);
    175175    ((void)(_tmp_cp_ret2) /* ^?{} */);
    176     return _X12_retval_maini_1;
     176    return ___retval_main__i_1;
    177177}

  • tests/Makefile.am

    r6d44da1 r341bb80  
    2323
    2424concurrent=
    25 timeouts=
    2625
    2726TEST_PY = python ${builddir}/test.py
    … …  
    3938CC = @CFACC@
    4039
    41 PRETTY_PATH=cd ${srcdir} &&
    42 
    4340.PHONY: list .validate
    4441.INTERMEDIATE: .validate .validate.c
    … …  
    5148#----------------------------------------------------------------------------------------------------------------
    5249all-local :
    53         @+${TEST_PY} --debug=${debug}  --install=${installed} ${concurrent} ${timeouts} ${quick_test}
     50        @+${TEST_PY} --debug=${debug}  --install=${installed} ${concurrent} ${quick_test}
    5451
    5552all-tests :
    56         @+${TEST_PY} --debug=${debug}  --install=${installed} ${concurrent} ${timeouts} --all # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
     53        @+${TEST_PY} --all --debug=${debug}  --install=${installed} ${concurrent}               # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
    5754
    5855clean-local :
    … …  
    7471# implicit rule so not all test require a rule
    7572% : %.c $(CC)
    76         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     73        $(COMPILE) $(abspath ${<}) -o ${@}
    7774
    7875declarationSpecifier: declarationSpecifier.c $(CC)
    79         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     76        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    8077
    8178gccExtensions : gccExtensions.c $(CC)
    82         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     79        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    8380
    8481extension : extension.c $(CC)
    85         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     82        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    8683
    8784attributes : attributes.c $(CC)
    88         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     85        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    8986
    9087functions: functions.c $(CC)
    91         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     88        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    9289
    9390KRfunctions : KRfunctions.c $(CC)
    94         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     91        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    9592
    9693sched-ext-parse : sched-ext-parse.c $(CC)
    97         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     94        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    9895
    9996gmp : gmp.c $(CC)
    100         $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     97        $(COMPILE) -lgmp $(abspath ${<}) -o ${@}
     98
     99completeTypeError : completeTypeError.c $(CC)
     100        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     101
     102typedefRedef-ERR1: typedefRedef.c $(CC)
     103        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     104
     105alloc-ERROR: alloc.c $(CC)
     106        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     107
     108fallthrough-ERROR: fallthrough.c $(CC)
     109        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     110
     111nested-types-ERR1: nested-types.c $(CC)
     112        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     113
     114nested-types-ERR2: nested-types.c $(CC)
     115        $(COMPILE) -DERR2 $(abspath ${<}) -o ${@}
     116
     117# Constructor/destructor tests
     118raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
     119        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     120
     121raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
     122        $(COMPILE) -DERR2 $(abspath ${<}) -o ${@}
     123
     124raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
     125        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     126
     127raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
     128        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     129
     130# Warnings
     131warnings/self-assignment: warnings/self-assignment.c $(CC)
     132        $(COMPILE) $(abspath ${<}) 2> ${@} -fsyntax-only
    101133
    102134#builtins
    103135builtins/sync: builtins/sync.c $(CC)
    104         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    105 
    106 #------------------------------------------------------------------------------
    107 #To make errors path independent we need to cd into the correct directories
    108 completeTypeError : completeTypeError.c $(CC)
    109         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    110 
    111 typedefRedef-ERR1: typedefRedef.c $(CC)
    112         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    113 
    114 alloc-ERROR: alloc.c $(CC)
    115         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    116 
    117 fallthrough-ERROR: fallthrough.c $(CC)
    118         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    119 
    120 nested-types-ERR1: nested-types.c $(CC)
    121         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    122 
    123 nested-types-ERR2: nested-types.c $(CC)
    124         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    125 
    126 # Constructor/destructor tests
    127 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
    128         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    129 
    130 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
    131         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    132 
    133 raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
    134         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    135 
    136 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
    137         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    138 
    139 # Warnings
    140 warnings/self-assignment: warnings/self-assignment.c $(CC)
    141         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     136        $(COMPILE) $(abspath ${<}) 2> ${@} -fsyntax-only

  • tests/Makefile.in

    r6d44da1 r341bb80  
    307307        -quiet @CFA_FLAGS@ -DIN_DIR="${srcdir}/.in/" ${DEBUG_FLAGS} \
    308308        ${INSTALL_FLAGS} ${ARCH_FLAGS}
    309 PRETTY_PATH = cd ${srcdir} &&
    310309fstream_test_SOURCES = fstream_test.c
    311310avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
    … …  
    639638# implicit rule so not all test require a rule
    640639% : %.c $(CC)
    641         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     640        $(COMPILE) $(abspath ${<}) -o ${@}
    642641
    643642declarationSpecifier: declarationSpecifier.c $(CC)
    644         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     643        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    645644
    646645gccExtensions : gccExtensions.c $(CC)
    647         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     646        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    648647
    649648extension : extension.c $(CC)
    650         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     649        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    651650
    652651attributes : attributes.c $(CC)
    653         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     652        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    654653
    655654functions: functions.c $(CC)
    656         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     655        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    657656
    658657KRfunctions : KRfunctions.c $(CC)
    659         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     658        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    660659
    661660sched-ext-parse : sched-ext-parse.c $(CC)
    662         $(PRETTY_PATH) $(COMPILE) -CFA -XCFA -p $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     661        $(COMPILE) -CFA -XCFA -p $(abspath ${<}) -o ${@}
    663662
    664663gmp : gmp.c $(CC)
    665         $(PRETTY_PATH) $(COMPILE) -lgmp $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
     664        $(COMPILE) -lgmp $(abspath ${<}) -o ${@}
     665
     666completeTypeError : completeTypeError.c $(CC)
     667        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     668
     669typedefRedef-ERR1: typedefRedef.c $(CC)
     670        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     671
     672alloc-ERROR: alloc.c $(CC)
     673        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     674
     675fallthrough-ERROR: fallthrough.c $(CC)
     676        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     677
     678nested-types-ERR1: nested-types.c $(CC)
     679        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     680
     681nested-types-ERR2: nested-types.c $(CC)
     682        $(COMPILE) -DERR2 $(abspath ${<}) -o ${@}
     683
     684# Constructor/destructor tests
     685raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
     686        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     687
     688raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
     689        $(COMPILE) -DERR2 $(abspath ${<}) -o ${@}
     690
     691raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
     692        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     693
     694raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
     695        $(COMPILE) -DERR1 $(abspath ${<}) -o ${@}
     696
     697# Warnings
     698warnings/self-assignment: warnings/self-assignment.c $(CC)
     699        $(COMPILE) $(abspath ${<}) 2> ${@} -fsyntax-only
    666700
    667701#builtins
    668702builtins/sync: builtins/sync.c $(CC)
    669         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
    670 
    671 #------------------------------------------------------------------------------
    672 #To make errors path independent we need to cd into the correct directories
    673 completeTypeError : completeTypeError.c $(CC)
    674         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    675 
    676 typedefRedef-ERR1: typedefRedef.c $(CC)
    677         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    678 
    679 alloc-ERROR: alloc.c $(CC)
    680         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    681 
    682 fallthrough-ERROR: fallthrough.c $(CC)
    683         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    684 
    685 nested-types-ERR1: nested-types.c $(CC)
    686         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    687 
    688 nested-types-ERR2: nested-types.c $(CC)
    689         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    690 
    691 # Constructor/destructor tests
    692 raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c $(CC)
    693         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    694 
    695 raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c $(CC)
    696         $(PRETTY_PATH) $(COMPILE) -DERR2 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    697 
    698 raii/memberCtors-ERR1: raii/memberCtors.c $(CC)
    699         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    700 
    701 raii/ctor-autogen-ERR1: raii/ctor-autogen.c $(CC)
    702         $(PRETTY_PATH) $(COMPILE) -DERR1 $(shell realpath --relative-to=${srcdir} ${<}) -o $(abspath ${@})
    703 
    704 # Warnings
    705 warnings/self-assignment: warnings/self-assignment.c $(CC)
    706         $(PRETTY_PATH) $(COMPILE) $(shell realpath --relative-to=${srcdir} ${<}) 2> $(abspath ${@}) -fsyntax-only
     703        $(COMPILE) $(abspath ${<}) 2> ${@} -fsyntax-only
    707704
    708705# Tell versions [3.59,3.63) of GNU make to not export all variables.

  • tests/coroutine/fibonacci.c

    r6d44da1 r341bb80  
    66//
    77// fibonacci.c -- 3-state finite-state machine
     8
    89//
    910// Author           : Thierry Delisle
    1011// Created On       : Thu Jun  8 07:29:37 2017
    1112// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 18 11:21:58 2018
    13 // Update Count     : 24
     13// Last Modified On : Thu Aug 16 08:18:16 2018
     14// Update Count     : 20
    1415//
    1516
    … …  
    3839int main() {
    3940        Fibonacci f1, f2;
    40         for ( 10 ) {                                                                            // print N Fibonacci values
     41        for ( int i = 1; i <= 10; i += 1 ) {
    4142                sout | next( f1 ) | next( f2 ) | endl;
    4243        } // for

  • tests/coroutine/pingpong.c

    r6d44da1 r341bb80  
    1010// Created On       : Wed Sep 20 11:55:23 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 18 11:31:11 2018
    13 // Update Count     : 28
     12// Last Modified On : Wed Sep 20 13:41:39 2017
     13// Update Count     : 26
    1414//
    1515
    … …  
    3939}
    4040void main( PingPong & pingpong ) {                                              // ping's starter ::main, pong's starter ping
    41         for ( pingpong.N ) {                                                            // N ping-pongs
     41        for ( unsigned int i = 0; i < pingpong.N; i += 1 ) {
    4242                sout | pingpong.name | endl;
    4343                cycle( *pingpong.part );

  • tests/coroutine/prodcons.c

    r6d44da1 r341bb80  
    1010// Created On       : Mon Sep 18 12:23:39 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 18 12:55:10 2018
    13 // Update Count     : 51
     12// Last Modified On : Tue Jan  2 12:17:01 2018
     13// Update Count     : 47
    1414//
    1515
    1616#include <fstream.hfa>
    1717#include <coroutine.hfa>
    18 #include <stdlib.hfa>                                                                   // random
     18#include <stdlib.hfa>                                                                           // random
    1919#include <unistd.h>                                                                             // getpid
    2020
    … …  
    2929void main( Prod & prod ) with( prod ) {                                 // starter ::main
    3030        // 1st resume starts here
    31         for ( i; N ) {                                                                          // N pairs of values
     31        for ( int i = 0; i < N; i += 1 ) {
    3232                int p1 = random( 100 );
    3333                int p2 = random( 100 );

  • tests/forctrl.c

    r6d44da1 r341bb80  
    1010// Created On       : Wed Aug  8 18:32:59 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 30 17:12:12 2018
    13 // Update Count     : 43
     12// Last Modified On : Thu Aug 16 09:25:47 2018
     13// Update Count     : 6
    1414//
    1515
    … …  
    3333        do { sout | "empty"; break; } while (); sout | endl;
    3434        for () { sout | "empty"; break; }               sout | endl;
    35 
    36         for ( 0 ) { sout | "A"; }                               sout | endl;
    37         for ( 1 ) { sout | "A"; }                               sout | endl;
    38         for ( 2 ) { sout | "A"; }                               sout | endl;
    39         for ( 10 ) { sout | "A"; }                              sout | endl;
    40 
    41         for ( 1 ~= 10 ~ 2 ) { sout | "B"; }             sout | endl;
    42         for ( 10 -~= 1 ~ -2 ) { sout | "C"; }   sout | endl;
    43         for ( 0.5 ~ 5.5 ) { sout | "D"; }               sout | endl;
    44         for ( 5.5 -~ 0.5 ) { sout | "E"; }              sout | endl;
    45 
     35        for ( 10 ) { sout | "X"; }                              sout | endl;
     36        for ( 0.5 ~ 5.5 ) { sout | "Y"; }               sout | endl;
     37        for ( 2 ~= 10 ~ 2 ) { sout | "Z"; }             sout | endl;
    4638        for ( i; 10 ) { sout | i; }                             sout | endl;
    4739        for ( j; 10 ) { sout | j; }                             sout | endl;
    48 
    49         for ( i; 1 ~= 10 ~ 2 ) { sout | i; }    sout | endl;
    50         for ( i; 10 -~= 1 ~ -2 ) { sout | i; }  sout | endl;
    5140        for ( i; 0.5 ~ 5.5 ) { sout | i; }              sout | endl;
    52         for ( i; 5.5 -~ 0.5 ) { sout | i; }             sout | endl;
    53 
     41        for ( i; 2 ~= 10 ~ 2 ) { sout | i; }    sout | endl;
    5442        for ( ui; 2u ~= 10u ~ 2u ) { sout | ui; } sout | endl;
    55         for ( ui; 10u -~= 2u ~ -2u ) { sout | ui; } sout | endl;
    56 
    5743        int start = 3, comp = 10, inc = 2;
    5844        for ( i; start ~ comp ~ inc + 1 ) { sout | i; } sout | endl;

  • tests/gmp.c

    r6d44da1 r341bb80  
    1010// Created On       : Tue Apr 19 08:55:51 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 18 12:43:13 2018
    13 // Update Count     : 556
     12// Last Modified On : Thu Sep 28 18:33:51 2017
     13// Update Count     : 555
    1414//
    1515
    … …  
    8989        fn = 1; fn2 = fn1; fn1 = fn;                                            // 2nd case
    9090        sout | 1 | fn | endl;
    91         for ( i; 2u ~= 200 ) {
     91        for ( unsigned int i = 2; i <= 200; i += 1 ) {
    9292                fn = fn1 + fn2; fn2 = fn1; fn1 = fn;                    // general case
    9393                sout | i | fn | endl;
    … …  
    9999        Int fact = 1;                                                                           // 1st case
    100100        sout | (int)0 | fact | endl;
    101         for ( i; 1u ~= 40u ) {
     101        for ( unsigned int i = 1; i <= 40; i += 1 ) {
    102102                fact *= i;                                                                              // general case
    103103                sout | i | fact | endl;

  • tests/test.py

    r6d44da1 r341bb80  
    174174
    175175        if retcode == 0:
    176                 # fixoutput(out_file)
     176                fixoutput(out_file)
    177177                if settings.generating :
    178178                        # if we are ounly generating the output we still need to check that the test actually exists

  • tools/cfa.nanorc

    r6d44da1 r341bb80  
    22## WIP
    33
    4 syntax "cfa" "\.(c|h)fa"
     4syntax "cfa" "\.cfa"
    55
    66# Macros
    … …  
    99# Types
    1010color green "\<(forall|trait|(o|d|f|t)type|mutex|_Bool|volatile|virtual)\>"
    11 color green "\<(float|double|bool|char|int|short|long|enum|void|auto)\>"
    12 color green "\<(static|const|extern|(un)?signed|inline)\>" "\<(sizeof)\>"
     11color green "\<(float|double|bool|char|int|short|long|sizeof|enum|void|auto)\>"
     12color green "\<(static|const|struct|union|typedef|extern|(un)?signed|inline)\>"
    1313color green "\<((s?size)|one|zero|((u_?)?int(8|16|32|64|ptr)))_t\>"
    1414
    … …  
    1919# Control Flow Structures
    2020color brightyellow "\<(if|else|while|do|for|switch|choose|case|default)\>"
    21 color brightyellow "\<(disable|enable|waitfor|when|timeout)\>"
    2221color brightyellow "\<(try|catch(Resume)?|finally)\>"
    2322
    2423# Control Flow Statements
    2524color magenta "\<(goto|return|break|continue|fallthr(u|ough)|throw(Resume)?)\>"
    26 
    27 # Escaped Keywords, now Identifiers.
    28 color white "`\w+`"
    2925
    3026# Operator Names
Note: See TracChangeset for help on using the changeset viewer.