bug-prolog
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: GCC segfault on i686


From: Matthew Carter
Subject: Re: GCC segfault on i686
Date: Thu, 25 Aug 2016 21:10:14 -0400
User-agent: Mutt/1.6.2 (2016-07-01)

Hi again,

It is just the --disable-regs flag needed during the configure step to
solve this issue.

So:

  ./configure --disable-regs && make clean && make

Should do the trick on i686.

-Matt

On Thu, Aug 25, 2016 at 07:49:12PM +0200, Till Hofmann wrote:
> Hi all,
> 
> do you have a suggestion on how to proceed with this bug? Can this be
> fixed on the Prolog side? Should this be reported as GCC bug?
> 
> Kind regards,
> Till
> 
> On 08/19/2016 08:56 AM, Till Hofmann wrote:
> > On 08/19/2016 02:40 AM, Matthew Carter wrote:
> >> I can confirm failure to build with gcc 6.1+ on i686 (using Arch Linux
> >> myself).
> >>
> >> I couldn't get it to build with your configure options however (it still
> >> failed with segfault in the same place).
> > 
> > The configure options were only to produce the more verbose make output
> > and the .i files. The build still fails. Sorry if this wasn't clear.
> > 
> > Kind regards,
> > Till
> > 
> >>
> >> -Matt
> >>
> >> On Thu, Aug 18, 2016 at 12:10:49PM +0200, Till Hofmann wrote:
> >>> Hi all,
> >>>
> >>> I'm currently trying to debug a GCC segfault that occurs when compiling
> >>> EnginePl/machine.c on i686 machines:
> >>>
> >>>> make[1]: Entering directory 
> >>>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl'
> >>>> gplc -c -C '-O3 -fomit-frame-pointer' machine.c
> >>>> machine.c: In function ‘Pl_M_Randomize’:
> >>>> machine.c:386:1: internal compiler error: Segmentation fault
> >>>
> >>> It looks like this is related to using the ebx register; if I remove
> >>> '-ffixed-ebx' from the call to cc1, the segfault disappears.
> >>>
> >>> Looking at the Changelog, it looks like there was a fix for some issue
> >>> related to using ebx in 1.3.1, but the error still occurs on i686.
> >>>
> >>> To reproduce, you need to build gprolog on i686 with GCC 6.1. I could
> >>> reproduce this on multiple machines.
> >>>
> >>> Some additional info:
> >>> gprolog version: 1.4.4
> >>> OS: Fedora 24 (also occurs on Fedora 25 and Fedora Rawhide)
> >>> $ gcc --version
> >>> gcc (GCC) 6.1.1 20160621 (Red Hat 6.1.1-3)
> >>> $ uname -a
> >>> Linux nc10 4.6.5-300.fc24.i686+PAE #1 SMP Thu Jul 28 01:34:46 UTC 2016
> >>> i686 i686 i386 GNU/Linux
> >>>
> >>> I build with "./configure --with-c-flags='-v -save-temps'", I've
> >>> attached the full output from make. I've also attached machine.i.
> >>>
> >>> With older GCC versions (<6), the bug does not occur, so this might well
> >>> be a bug in GCC6.
> >>>
> >>>
> >>> Kind regards
> >>> Till
> >>
> >>> cd EnginePl; make config
> >>> make[1]: Entering directory 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl'
> >>> gcc -march=pentiumpro -m32 -fno-strict-aliasing -v -save-temps  -o 
> >>> pl_config pl_config.c
> >>> Using built-in specs.
> >>> COLLECT_GCC=gcc
> >>> COLLECT_LTO_WRAPPER=/usr/libexec/gcc/i686-redhat-linux/6.1.1/lto-wrapper
> >>> Target: i686-redhat-linux
> >>> Configured with: ../configure --enable-bootstrap 
> >>> --enable-languages=c,c++,objc,obj-c++,fortran,ada,go,lto --prefix=/usr 
> >>> --mandir=/usr/share/man --infodir=/usr/share/info 
> >>> --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-shared 
> >>> --enable-threads=posix --enable-checking=release --enable-multilib 
> >>> --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions 
> >>> --enable-gnu-unique-object --enable-linker-build-id 
> >>> --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array 
> >>> --disable-libgcj --with-isl --enable-libmpx 
> >>> --enable-gnu-indirect-function --with-tune=generic --with-arch=i686 
> >>> --build=i686-redhat-linux
> >>> Thread model: posix
> >>> gcc version 6.1.1 20160621 (Red Hat 6.1.1-3) (GCC) 
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'pl_config'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -E -quiet -v pl_config.c 
> >>> -march=pentiumpro -m32 -fno-strict-aliasing -fpch-preprocess -o 
> >>> pl_config.i
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/include-fixed"
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/../../../../i686-redhat-linux/include"
> >>> #include "..." search starts here:
> >>> #include <...> search starts here:
> >>>  /usr/lib/gcc/i686-redhat-linux/6.1.1/include
> >>>  /usr/local/include
> >>>  /usr/include
> >>> End of search list.
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'pl_config'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -fpreprocessed pl_config.i 
> >>> -quiet -dumpbase pl_config.c -march=pentiumpro -m32 -auxbase pl_config 
> >>> -version -fno-strict-aliasing -o pl_config.s
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> Compiler executable checksum: abceb138af43a78c36c1aaa228f5f92a
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'pl_config'
> >>>  as -v --32 -o pl_config.o pl_config.s
> >>> GNU assembler version 2.26.1 (i686-redhat-linux) using BFD version 
> >>> version 2.26.1-1.fc24
> >>> COMPILER_PATH=/usr/libexec/gcc/i686-redhat-linux/6.1.1/:/usr/libexec/gcc/i686-redhat-linux/6.1.1/:/usr/libexec/gcc/i686-redhat-linux/:/usr/lib/gcc/i686-redhat-linux/6.1.1/:/usr/lib/gcc/i686-redhat-linux/
> >>> LIBRARY_PATH=/usr/lib/gcc/i686-redhat-linux/6.1.1/:/usr/lib/gcc/i686-redhat-linux/6.1.1/../../../:/lib/:/usr/lib/
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'pl_config'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/collect2 -plugin 
> >>> /usr/libexec/gcc/i686-redhat-linux/6.1.1/liblto_plugin.so 
> >>> -plugin-opt=/usr/libexec/gcc/i686-redhat-linux/6.1.1/lto-wrapper 
> >>> -plugin-opt=-fresolution=pl_config.res -plugin-opt=-pass-through=-lgcc 
> >>> -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc 
> >>> -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s 
> >>> --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_i386 
> >>> -dynamic-linker /lib/ld-linux.so.2 -o pl_config 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crt1.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crti.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/crtbegin.o 
> >>> -L/usr/lib/gcc/i686-redhat-linux/6.1.1 
> >>> -L/usr/lib/gcc/i686-redhat-linux/6.1.1/../../.. pl_config.o -lgcc 
> >>> --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s 
> >>> --no-as-needed /usr/lib/gcc/i686-redhat-linux/6.1.1/crtend.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crtn.o
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'pl_config'
> >>> ./pl_config
> >>>
> >>>   -------------------------------
> >>>   --- GNU PROLOG INSTALLATION ---
> >>>   -------------------------------
> >>>
> >>> GNU Prolog version: 1.4.4 (Aug 18 2016)
> >>> Operating system  : linux-gnu
> >>> Processor         : i686
> >>> Size of a WAM word: 32 bits
> >>> C compiler        : gcc
> >>> C flags           : -v -save-temps
> >>> C flags machine   : -march=pentiumpro -m32 -fno-strict-aliasing
> >>> Assembler         : as
> >>> Assembler flags   : --32
> >>> Loader flags      : 
> >>> Loader libraries  : -lm
> >>> Use line editor   : Yes
> >>> Use piped consult : Yes
> >>> Use sockets       : Yes
> >>> Use FD solver     : Yes
> >>> Use fast call     : Yes
> >>> Use machine regs. : Yes
> >>> Used register(s)  : ebx (TR)  
> >>>
> >>>   ------------------------------
> >>>
> >>> (cd ../TopComp; make gplc)
> >>> make[2]: Entering directory 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/TopComp'
> >>> gcc -march=pentiumpro -m32 -fno-strict-aliasing -v -save-temps -o gplc 
> >>> top_comp.c -lm
> >>> Using built-in specs.
> >>> COLLECT_GCC=gcc
> >>> COLLECT_LTO_WRAPPER=/usr/libexec/gcc/i686-redhat-linux/6.1.1/lto-wrapper
> >>> Target: i686-redhat-linux
> >>> Configured with: ../configure --enable-bootstrap 
> >>> --enable-languages=c,c++,objc,obj-c++,fortran,ada,go,lto --prefix=/usr 
> >>> --mandir=/usr/share/man --infodir=/usr/share/info 
> >>> --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-shared 
> >>> --enable-threads=posix --enable-checking=release --enable-multilib 
> >>> --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions 
> >>> --enable-gnu-unique-object --enable-linker-build-id 
> >>> --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array 
> >>> --disable-libgcj --with-isl --enable-libmpx 
> >>> --enable-gnu-indirect-function --with-tune=generic --with-arch=i686 
> >>> --build=i686-redhat-linux
> >>> Thread model: posix
> >>> gcc version 6.1.1 20160621 (Red Hat 6.1.1-3) (GCC) 
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'gplc'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -E -quiet -v top_comp.c 
> >>> -march=pentiumpro -m32 -fno-strict-aliasing -fpch-preprocess -o top_comp.i
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/include-fixed"
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/../../../../i686-redhat-linux/include"
> >>> #include "..." search starts here:
> >>> #include <...> search starts here:
> >>>  /usr/lib/gcc/i686-redhat-linux/6.1.1/include
> >>>  /usr/local/include
> >>>  /usr/include
> >>> End of search list.
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'gplc'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -fpreprocessed top_comp.i 
> >>> -quiet -dumpbase top_comp.c -march=pentiumpro -m32 -auxbase top_comp 
> >>> -version -fno-strict-aliasing -o top_comp.s
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> Compiler executable checksum: abceb138af43a78c36c1aaa228f5f92a
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'gplc'
> >>>  as -v --32 -o top_comp.o top_comp.s
> >>> GNU assembler version 2.26.1 (i686-redhat-linux) using BFD version 
> >>> version 2.26.1-1.fc24
> >>> COMPILER_PATH=/usr/libexec/gcc/i686-redhat-linux/6.1.1/:/usr/libexec/gcc/i686-redhat-linux/6.1.1/:/usr/libexec/gcc/i686-redhat-linux/:/usr/lib/gcc/i686-redhat-linux/6.1.1/:/usr/lib/gcc/i686-redhat-linux/
> >>> LIBRARY_PATH=/usr/lib/gcc/i686-redhat-linux/6.1.1/:/usr/lib/gcc/i686-redhat-linux/6.1.1/../../../:/lib/:/usr/lib/
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'gplc'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/collect2 -plugin 
> >>> /usr/libexec/gcc/i686-redhat-linux/6.1.1/liblto_plugin.so 
> >>> -plugin-opt=/usr/libexec/gcc/i686-redhat-linux/6.1.1/lto-wrapper 
> >>> -plugin-opt=-fresolution=top_comp.res -plugin-opt=-pass-through=-lgcc 
> >>> -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc 
> >>> -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s 
> >>> --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_i386 
> >>> -dynamic-linker /lib/ld-linux.so.2 -o gplc 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crt1.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crti.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/crtbegin.o 
> >>> -L/usr/lib/gcc/i686-redhat-linux/6.1.1 
> >>> -L/usr/lib/gcc/i686-redhat-linux/6.1.1/../../.. top_comp.o -lm -lgcc 
> >>> --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s 
> >>> --no-as-needed /usr/lib/gcc/i686-redhat-linux/6.1.1/crtend.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crtn.o
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'gplc'
> >>> make[2]: Leaving directory 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/TopComp'
> >>> make[1]: Leaving directory 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl'
> >>> . ./SETVARS;for i in EnginePl TopComp Wam2Ma Ma2Asm Linedit BipsPl Pl2Wam 
> >>> Fd2C EngineFD BipsFD;do (cd $i; make) || exit 1; done;\
> >>> (cd TopComp; make top-level) || exit 1;\
> >>> (cd Pl2Wam; make stage2)
> >>> make[1]: Entering directory 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl'
> >>> gcc -march=pentiumpro -m32 -fno-strict-aliasing -v -save-temps  -o 
> >>> cpp_headers cpp_headers.c
> >>> Using built-in specs.
> >>> COLLECT_GCC=gcc
> >>> COLLECT_LTO_WRAPPER=/usr/libexec/gcc/i686-redhat-linux/6.1.1/lto-wrapper
> >>> Target: i686-redhat-linux
> >>> Configured with: ../configure --enable-bootstrap 
> >>> --enable-languages=c,c++,objc,obj-c++,fortran,ada,go,lto --prefix=/usr 
> >>> --mandir=/usr/share/man --infodir=/usr/share/info 
> >>> --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-shared 
> >>> --enable-threads=posix --enable-checking=release --enable-multilib 
> >>> --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions 
> >>> --enable-gnu-unique-object --enable-linker-build-id 
> >>> --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array 
> >>> --disable-libgcj --with-isl --enable-libmpx 
> >>> --enable-gnu-indirect-function --with-tune=generic --with-arch=i686 
> >>> --build=i686-redhat-linux
> >>> Thread model: posix
> >>> gcc version 6.1.1 20160621 (Red Hat 6.1.1-3) (GCC) 
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'cpp_headers'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -E -quiet -v cpp_headers.c 
> >>> -march=pentiumpro -m32 -fno-strict-aliasing -fpch-preprocess -o 
> >>> cpp_headers.i
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/include-fixed"
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/../../../../i686-redhat-linux/include"
> >>> #include "..." search starts here:
> >>> #include <...> search starts here:
> >>>  /usr/lib/gcc/i686-redhat-linux/6.1.1/include
> >>>  /usr/local/include
> >>>  /usr/include
> >>> End of search list.
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'cpp_headers'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -fpreprocessed 
> >>> cpp_headers.i -quiet -dumpbase cpp_headers.c -march=pentiumpro -m32 
> >>> -auxbase cpp_headers -version -fno-strict-aliasing -o cpp_headers.s
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> Compiler executable checksum: abceb138af43a78c36c1aaa228f5f92a
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'cpp_headers'
> >>>  as -v --32 -o cpp_headers.o cpp_headers.s
> >>> GNU assembler version 2.26.1 (i686-redhat-linux) using BFD version 
> >>> version 2.26.1-1.fc24
> >>> COMPILER_PATH=/usr/libexec/gcc/i686-redhat-linux/6.1.1/:/usr/libexec/gcc/i686-redhat-linux/6.1.1/:/usr/libexec/gcc/i686-redhat-linux/:/usr/lib/gcc/i686-redhat-linux/6.1.1/:/usr/lib/gcc/i686-redhat-linux/
> >>> LIBRARY_PATH=/usr/lib/gcc/i686-redhat-linux/6.1.1/:/usr/lib/gcc/i686-redhat-linux/6.1.1/../../../:/lib/:/usr/lib/
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'cpp_headers'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/collect2 -plugin 
> >>> /usr/libexec/gcc/i686-redhat-linux/6.1.1/liblto_plugin.so 
> >>> -plugin-opt=/usr/libexec/gcc/i686-redhat-linux/6.1.1/lto-wrapper 
> >>> -plugin-opt=-fresolution=cpp_headers.res -plugin-opt=-pass-through=-lgcc 
> >>> -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc 
> >>> -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s 
> >>> --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_i386 
> >>> -dynamic-linker /lib/ld-linux.so.2 -o cpp_headers 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crt1.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crti.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/crtbegin.o 
> >>> -L/usr/lib/gcc/i686-redhat-linux/6.1.1 
> >>> -L/usr/lib/gcc/i686-redhat-linux/6.1.1/../../.. cpp_headers.o -lgcc 
> >>> --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s 
> >>> --no-as-needed /usr/lib/gcc/i686-redhat-linux/6.1.1/crtend.o 
> >>> /usr/lib/gcc/i686-redhat-linux/6.1.1/../../../crtn.o
> >>> COLLECT_GCC_OPTIONS='-march=pentiumpro' '-m32' '-fno-strict-aliasing' 
> >>> '-v' '-save-temps' '-o' 'cpp_headers'
> >>> gplc -c -C '-v -save-temps' machine.c
> >>> Using built-in specs.
> >>> COLLECT_GCC=gcc
> >>> Target: i686-redhat-linux
> >>> Configured with: ../configure --enable-bootstrap 
> >>> --enable-languages=c,c++,objc,obj-c++,fortran,ada,go,lto --prefix=/usr 
> >>> --mandir=/usr/share/man --infodir=/usr/share/info 
> >>> --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-shared 
> >>> --enable-threads=posix --enable-checking=release --enable-multilib 
> >>> --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions 
> >>> --enable-gnu-unique-object --enable-linker-build-id 
> >>> --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array 
> >>> --disable-libgcj --with-isl --enable-libmpx 
> >>> --enable-gnu-indirect-function --with-tune=generic --with-arch=i686 
> >>> --build=i686-redhat-linux
> >>> Thread model: posix
> >>> gcc version 6.1.1 20160621 (Red Hat 6.1.1-3) (GCC) 
> >>> COLLECT_GCC_OPTIONS='-v' '-save-temps' '-march=pentiumpro' '-m32' 
> >>> '-fno-strict-aliasing' '-ffixed-ebx' '-c' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsPl' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EngineFD' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsFD' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/Linedit' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/W32GUICons' '-o' 
> >>> 'machine.o'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -E -quiet -v -I 
> >>> /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl -I 
> >>> /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsPl -I 
> >>> /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EngineFD -I 
> >>> /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsFD -I 
> >>> /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/Linedit -I 
> >>> /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/W32GUICons machine.c 
> >>> -march=pentiumpro -m32 -fno-strict-aliasing -ffixed-ebx -fpch-preprocess 
> >>> -o machine.i
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/include-fixed"
> >>> ignoring nonexistent directory 
> >>> "/usr/lib/gcc/i686-redhat-linux/6.1.1/../../../../i686-redhat-linux/include"
> >>> #include "..." search starts here:
> >>> #include <...> search starts here:
> >>>  /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl
> >>>  /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsPl
> >>>  /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EngineFD
> >>>  /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsFD
> >>>  /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/Linedit
> >>>  /home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/W32GUICons
> >>>  /usr/lib/gcc/i686-redhat-linux/6.1.1/include
> >>>  /usr/local/include
> >>>  /usr/include
> >>> End of search list.
> >>> COLLECT_GCC_OPTIONS='-v' '-save-temps' '-march=pentiumpro' '-m32' 
> >>> '-fno-strict-aliasing' '-ffixed-ebx' '-c' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsPl' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EngineFD' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/BipsFD' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/Linedit' '-I' 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/W32GUICons' '-o' 
> >>> 'machine.o'
> >>>  /usr/libexec/gcc/i686-redhat-linux/6.1.1/cc1 -fpreprocessed machine.i 
> >>> -quiet -dumpbase machine.c -march=pentiumpro -m32 -auxbase-strip 
> >>> machine.o -version -fno-strict-aliasing -ffixed-ebx -o machine.s
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> GNU C11 (GCC) version 6.1.1 20160621 (Red Hat 6.1.1-3) (i686-redhat-linux)
> >>>   compiled by GNU C version 6.1.1 20160621 (Red Hat 6.1.1-3), GMP version 
> >>> 6.1.0, MPFR version 3.1.4, MPC version 1.0.2, isl version 0.14 or 0.13
> >>> warning: GMP header version 6.1.0 differs from library version 6.1.1.
> >>> GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
> >>> Compiler executable checksum: abceb138af43a78c36c1aaa228f5f92a
> >>> machine.c: In function ‘Pl_M_Randomize’:
> >>> machine.c:386:1: internal compiler error: Segmentation fault
> >>>  }
> >>>  ^
> >>> Please submit a full bug report,
> >>> with preprocessed source if appropriate.
> >>> See <http://bugzilla.redhat.com/bugzilla> for instructions.
> >>> Preprocessed source stored into /tmp/cccXCAWM.out file, please attach 
> >>> this to your bugreport.
> >>> compilation failed
> >>> Makefile:30: recipe for target 'machine.o' failed
> >>> make[1]: *** [machine.o] Error 1
> >>> make[1]: Leaving directory 
> >>> '/home/till/rpmbuild/SOURCES/gprolog-1.4.4/src/EnginePl'
> >>> Makefile:45: recipe for target 'all' failed
> >>> make: *** [all] Error 1
> >>
> >>> # 1 "machine.c"
> >>> # 1 "<built-in>"
> >>> # 1 "<command-line>"
> >>> # 31 "<command-line>"
> >>> # 1 "/usr/include/stdc-predef.h" 1 3 4
> >>> # 32 "<command-line>" 2
> >>> # 1 "machine.c"
> >>> # 39 "machine.c"
> >>> # 1 "/usr/include/stdio.h" 1 3 4
> >>> # 27 "/usr/include/stdio.h" 3 4
> >>> # 1 "/usr/include/features.h" 1 3 4
> >>> # 368 "/usr/include/features.h" 3 4
> >>> # 1 "/usr/include/sys/cdefs.h" 1 3 4
> >>> # 410 "/usr/include/sys/cdefs.h" 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 411 "/usr/include/sys/cdefs.h" 2 3 4
> >>> # 369 "/usr/include/features.h" 2 3 4
> >>> # 392 "/usr/include/features.h" 3 4
> >>> # 1 "/usr/include/gnu/stubs.h" 1 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/gnu/stubs-32.h" 1 3 4
> >>> # 8 "/usr/include/gnu/stubs.h" 2 3 4
> >>> # 393 "/usr/include/features.h" 2 3 4
> >>> # 28 "/usr/include/stdio.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 216 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 3 4
> >>>
> >>> # 216 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 3 4
> >>> typedef unsigned int size_t;
> >>> # 34 "/usr/include/stdio.h" 2 3 4
> >>>
> >>> # 1 "/usr/include/bits/types.h" 1 3 4
> >>> # 27 "/usr/include/bits/types.h" 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 28 "/usr/include/bits/types.h" 2 3 4
> >>>
> >>>
> >>> typedef unsigned char __u_char;
> >>> typedef unsigned short int __u_short;
> >>> typedef unsigned int __u_int;
> >>> typedef unsigned long int __u_long;
> >>>
> >>>
> >>> typedef signed char __int8_t;
> >>> typedef unsigned char __uint8_t;
> >>> typedef signed short int __int16_t;
> >>> typedef unsigned short int __uint16_t;
> >>> typedef signed int __int32_t;
> >>> typedef unsigned int __uint32_t;
> >>>
> >>>
> >>>
> >>>
> >>> __extension__ typedef signed long long int __int64_t;
> >>> __extension__ typedef unsigned long long int __uint64_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> __extension__ typedef long long int __quad_t;
> >>> __extension__ typedef unsigned long long int __u_quad_t;
> >>> # 121 "/usr/include/bits/types.h" 3 4
> >>> # 1 "/usr/include/bits/typesizes.h" 1 3 4
> >>> # 122 "/usr/include/bits/types.h" 2 3 4
> >>>
> >>>
> >>> __extension__ typedef __u_quad_t __dev_t;
> >>> __extension__ typedef unsigned int __uid_t;
> >>> __extension__ typedef unsigned int __gid_t;
> >>> __extension__ typedef unsigned long int __ino_t;
> >>> __extension__ typedef __u_quad_t __ino64_t;
> >>> __extension__ typedef unsigned int __mode_t;
> >>> __extension__ typedef unsigned int __nlink_t;
> >>> __extension__ typedef long int __off_t;
> >>> __extension__ typedef __quad_t __off64_t;
> >>> __extension__ typedef int __pid_t;
> >>> __extension__ typedef struct { int __val[2]; } __fsid_t;
> >>> __extension__ typedef long int __clock_t;
> >>> __extension__ typedef unsigned long int __rlim_t;
> >>> __extension__ typedef __u_quad_t __rlim64_t;
> >>> __extension__ typedef unsigned int __id_t;
> >>> __extension__ typedef long int __time_t;
> >>> __extension__ typedef unsigned int __useconds_t;
> >>> __extension__ typedef long int __suseconds_t;
> >>>
> >>> __extension__ typedef int __daddr_t;
> >>> __extension__ typedef int __key_t;
> >>>
> >>>
> >>> __extension__ typedef int __clockid_t;
> >>>
> >>>
> >>> __extension__ typedef void * __timer_t;
> >>>
> >>>
> >>> __extension__ typedef long int __blksize_t;
> >>>
> >>>
> >>>
> >>>
> >>> __extension__ typedef long int __blkcnt_t;
> >>> __extension__ typedef __quad_t __blkcnt64_t;
> >>>
> >>>
> >>> __extension__ typedef unsigned long int __fsblkcnt_t;
> >>> __extension__ typedef __u_quad_t __fsblkcnt64_t;
> >>>
> >>>
> >>> __extension__ typedef unsigned long int __fsfilcnt_t;
> >>> __extension__ typedef __u_quad_t __fsfilcnt64_t;
> >>>
> >>>
> >>> __extension__ typedef int __fsword_t;
> >>>
> >>> __extension__ typedef int __ssize_t;
> >>>
> >>>
> >>> __extension__ typedef long int __syscall_slong_t;
> >>>
> >>> __extension__ typedef unsigned long int __syscall_ulong_t;
> >>>
> >>>
> >>>
> >>> typedef __off64_t __loff_t;
> >>> typedef __quad_t *__qaddr_t;
> >>> typedef char *__caddr_t;
> >>>
> >>>
> >>> __extension__ typedef int __intptr_t;
> >>>
> >>>
> >>> __extension__ typedef unsigned int __socklen_t;
> >>> # 36 "/usr/include/stdio.h" 2 3 4
> >>> # 44 "/usr/include/stdio.h" 3 4
> >>> struct _IO_FILE;
> >>>
> >>>
> >>>
> >>> typedef struct _IO_FILE FILE;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 64 "/usr/include/stdio.h" 3 4
> >>> typedef struct _IO_FILE __FILE;
> >>> # 74 "/usr/include/stdio.h" 3 4
> >>> # 1 "/usr/include/libio.h" 1 3 4
> >>> # 31 "/usr/include/libio.h" 3 4
> >>> # 1 "/usr/include/_G_config.h" 1 3 4
> >>> # 15 "/usr/include/_G_config.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 16 "/usr/include/_G_config.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/wchar.h" 1 3 4
> >>> # 82 "/usr/include/wchar.h" 3 4
> >>> typedef struct
> >>> {
> >>>   int __count;
> >>>   union
> >>>   {
> >>>
> >>>     unsigned int __wch;
> >>>
> >>>
> >>>
> >>>     char __wchb[4];
> >>>   } __value;
> >>> } __mbstate_t;
> >>> # 21 "/usr/include/_G_config.h" 2 3 4
> >>> typedef struct
> >>> {
> >>>   __off_t __pos;
> >>>   __mbstate_t __state;
> >>> } _G_fpos_t;
> >>> typedef struct
> >>> {
> >>>   __off64_t __pos;
> >>>   __mbstate_t __state;
> >>> } _G_fpos64_t;
> >>> # 32 "/usr/include/libio.h" 2 3 4
> >>> # 49 "/usr/include/libio.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stdarg.h" 1 3 4
> >>> # 40 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stdarg.h" 3 4
> >>> typedef __builtin_va_list __gnuc_va_list;
> >>> # 50 "/usr/include/libio.h" 2 3 4
> >>> # 144 "/usr/include/libio.h" 3 4
> >>> struct _IO_jump_t; struct _IO_FILE;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef void _IO_lock_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct _IO_marker {
> >>>   struct _IO_marker *_next;
> >>>   struct _IO_FILE *_sbuf;
> >>>
> >>>
> >>>
> >>>   int _pos;
> >>> # 173 "/usr/include/libio.h" 3 4
> >>> };
> >>>
> >>>
> >>> enum __codecvt_result
> >>> {
> >>>   __codecvt_ok,
> >>>   __codecvt_partial,
> >>>   __codecvt_error,
> >>>   __codecvt_noconv
> >>> };
> >>> # 241 "/usr/include/libio.h" 3 4
> >>> struct _IO_FILE {
> >>>   int _flags;
> >>>
> >>>
> >>>
> >>>
> >>>   char* _IO_read_ptr;
> >>>   char* _IO_read_end;
> >>>   char* _IO_read_base;
> >>>   char* _IO_write_base;
> >>>   char* _IO_write_ptr;
> >>>   char* _IO_write_end;
> >>>   char* _IO_buf_base;
> >>>   char* _IO_buf_end;
> >>>
> >>>   char *_IO_save_base;
> >>>   char *_IO_backup_base;
> >>>   char *_IO_save_end;
> >>>
> >>>   struct _IO_marker *_markers;
> >>>
> >>>   struct _IO_FILE *_chain;
> >>>
> >>>   int _fileno;
> >>>
> >>>
> >>>
> >>>   int _flags2;
> >>>
> >>>   __off_t _old_offset;
> >>>
> >>>
> >>>
> >>>   unsigned short _cur_column;
> >>>   signed char _vtable_offset;
> >>>   char _shortbuf[1];
> >>>
> >>>
> >>>
> >>>   _IO_lock_t *_lock;
> >>> # 289 "/usr/include/libio.h" 3 4
> >>>   __off64_t _offset;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   void *__pad1;
> >>>   void *__pad2;
> >>>   void *__pad3;
> >>>   void *__pad4;
> >>>
> >>>   size_t __pad5;
> >>>   int _mode;
> >>>
> >>>   char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof 
> >>> (size_t)];
> >>>
> >>> };
> >>>
> >>>
> >>> typedef struct _IO_FILE _IO_FILE;
> >>>
> >>>
> >>> struct _IO_FILE_plus;
> >>>
> >>> extern struct _IO_FILE_plus _IO_2_1_stdin_;
> >>> extern struct _IO_FILE_plus _IO_2_1_stdout_;
> >>> extern struct _IO_FILE_plus _IO_2_1_stderr_;
> >>> # 333 "/usr/include/libio.h" 3 4
> >>> typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t 
> >>> __nbytes);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
> >>>      size_t __n);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
> >>>
> >>>
> >>> typedef int __io_close_fn (void *__cookie);
> >>> # 385 "/usr/include/libio.h" 3 4
> >>> extern int __underflow (_IO_FILE *);
> >>> extern int __uflow (_IO_FILE *);
> >>> extern int __overflow (_IO_FILE *, int);
> >>> # 429 "/usr/include/libio.h" 3 4
> >>> extern int _IO_getc (_IO_FILE *__fp);
> >>> extern int _IO_putc (int __c, _IO_FILE *__fp);
> >>> extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern int _IO_peekc_locked (_IO_FILE *__fp);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 459 "/usr/include/libio.h" 3 4
> >>> extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
> >>>    __gnuc_va_list, int *__restrict);
> >>> extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
> >>>     __gnuc_va_list);
> >>> extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
> >>> extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
> >>>
> >>> extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
> >>> extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
> >>>
> >>> extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>> # 75 "/usr/include/stdio.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> typedef __gnuc_va_list va_list;
> >>> # 90 "/usr/include/stdio.h" 3 4
> >>> typedef __off_t off_t;
> >>> # 102 "/usr/include/stdio.h" 3 4
> >>> typedef __ssize_t ssize_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef _G_fpos_t fpos_t;
> >>>
> >>>
> >>>
> >>>
> >>> # 164 "/usr/include/stdio.h" 3 4
> >>> # 1 "/usr/include/bits/stdio_lim.h" 1 3 4
> >>> # 165 "/usr/include/stdio.h" 2 3 4
> >>>
> >>>
> >>>
> >>> extern struct _IO_FILE *stdin;
> >>> extern struct _IO_FILE *stdout;
> >>> extern struct _IO_FILE *stderr;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int remove (const char *__filename) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern int rename (const char *__old, const char *__new) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int renameat (int __oldfd, const char *__old, int __newfd,
> >>>        const char *__new) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern FILE *tmpfile (void) ;
> >>> # 209 "/usr/include/stdio.h" 3 4
> >>> extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>> # 227 "/usr/include/stdio.h" 3 4
> >>> extern char *tempnam (const char *__dir, const char *__pfx)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__malloc__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fclose (FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>> extern int fflush (FILE *__stream);
> >>>
> >>> # 252 "/usr/include/stdio.h" 3 4
> >>> extern int fflush_unlocked (FILE *__stream);
> >>> # 266 "/usr/include/stdio.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern FILE *fopen (const char *__restrict __filename,
> >>>       const char *__restrict __modes) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern FILE *freopen (const char *__restrict __filename,
> >>>         const char *__restrict __modes,
> >>>         FILE *__restrict __stream) ;
> >>> # 295 "/usr/include/stdio.h" 3 4
> >>>
> >>> # 306 "/usr/include/stdio.h" 3 4
> >>> extern FILE *fdopen (int __fd, const char *__modes) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) ;
> >>> # 319 "/usr/include/stdio.h" 3 4
> >>> extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
> >>>   __attribute__ ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) 
> >>> __attribute__ ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
> >>>       int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
> >>>          size_t __size) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fprintf (FILE *__restrict __stream,
> >>>       const char *__restrict __format, ...);
> >>>
> >>>
> >>>
> >>>
> >>> extern int printf (const char *__restrict __format, ...);
> >>>
> >>> extern int sprintf (char *__restrict __s,
> >>>       const char *__restrict __format, ...) __attribute__ ((__nothrow__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int vfprintf (FILE *__restrict __s, const char *__restrict 
> >>> __format,
> >>>        __gnuc_va_list __arg);
> >>>
> >>>
> >>>
> >>>
> >>> extern int vprintf (const char *__restrict __format, __gnuc_va_list 
> >>> __arg);
> >>>
> >>> extern int vsprintf (char *__restrict __s, const char *__restrict 
> >>> __format,
> >>>        __gnuc_va_list __arg) __attribute__ ((__nothrow__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int snprintf (char *__restrict __s, size_t __maxlen,
> >>>        const char *__restrict __format, ...)
> >>>      __attribute__ ((__nothrow__)) __attribute__ ((__format__ 
> >>> (__printf__, 3, 4)));
> >>>
> >>> extern int vsnprintf (char *__restrict __s, size_t __maxlen,
> >>>         const char *__restrict __format, __gnuc_va_list __arg)
> >>>      __attribute__ ((__nothrow__)) __attribute__ ((__format__ 
> >>> (__printf__, 3, 0)));
> >>>
> >>> # 412 "/usr/include/stdio.h" 3 4
> >>> extern int vdprintf (int __fd, const char *__restrict __fmt,
> >>>        __gnuc_va_list __arg)
> >>>      __attribute__ ((__format__ (__printf__, 2, 0)));
> >>> extern int dprintf (int __fd, const char *__restrict __fmt, ...)
> >>>      __attribute__ ((__format__ (__printf__, 2, 3)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fscanf (FILE *__restrict __stream,
> >>>      const char *__restrict __format, ...) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int scanf (const char *__restrict __format, ...) ;
> >>>
> >>> extern int sscanf (const char *__restrict __s,
> >>>      const char *__restrict __format, ...) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 443 "/usr/include/stdio.h" 3 4
> >>> extern int fscanf (FILE *__restrict __stream, const char *__restrict 
> >>> __format, ...) __asm__ ("" "__isoc99_fscanf")
> >>>
> >>>                                ;
> >>> extern int scanf (const char *__restrict __format, ...) __asm__ ("" 
> >>> "__isoc99_scanf")
> >>>                               ;
> >>> extern int sscanf (const char *__restrict __s, const char *__restrict 
> >>> __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ 
> >>> , __leaf__))
> >>>
> >>>                       ;
> >>> # 463 "/usr/include/stdio.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
> >>>       __gnuc_va_list __arg)
> >>>      __attribute__ ((__format__ (__scanf__, 2, 0))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
> >>>      __attribute__ ((__format__ (__scanf__, 1, 0))) ;
> >>>
> >>>
> >>> extern int vsscanf (const char *__restrict __s,
> >>>       const char *__restrict __format, __gnuc_va_list __arg)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ 
> >>> (__scanf__, 2, 0)));
> >>> # 494 "/usr/include/stdio.h" 3 4
> >>> extern int vfscanf (FILE *__restrict __s, const char *__restrict 
> >>> __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
> >>>
> >>>
> >>>
> >>>      __attribute__ ((__format__ (__scanf__, 2, 0))) ;
> >>> extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) 
> >>> __asm__ ("" "__isoc99_vscanf")
> >>>
> >>>      __attribute__ ((__format__ (__scanf__, 1, 0))) ;
> >>> extern int vsscanf (const char *__restrict __s, const char *__restrict 
> >>> __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") 
> >>> __attribute__ ((__nothrow__ , __leaf__))
> >>>
> >>>
> >>>
> >>>      __attribute__ ((__format__ (__scanf__, 2, 0)));
> >>> # 522 "/usr/include/stdio.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fgetc (FILE *__stream);
> >>> extern int getc (FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getchar (void);
> >>>
> >>> # 550 "/usr/include/stdio.h" 3 4
> >>> extern int getc_unlocked (FILE *__stream);
> >>> extern int getchar_unlocked (void);
> >>> # 561 "/usr/include/stdio.h" 3 4
> >>> extern int fgetc_unlocked (FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fputc (int __c, FILE *__stream);
> >>> extern int putc (int __c, FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int putchar (int __c);
> >>>
> >>> # 594 "/usr/include/stdio.h" 3 4
> >>> extern int fputc_unlocked (int __c, FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int putc_unlocked (int __c, FILE *__stream);
> >>> extern int putchar_unlocked (int __c);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getw (FILE *__stream);
> >>>
> >>>
> >>> extern int putw (int __w, FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *fgets (char *__restrict __s, int __n, FILE *__restrict 
> >>> __stream)
> >>>      ;
> >>> # 640 "/usr/include/stdio.h" 3 4
> >>>
> >>> # 665 "/usr/include/stdio.h" 3 4
> >>> extern __ssize_t __getdelim (char **__restrict __lineptr,
> >>>           size_t *__restrict __n, int __delimiter,
> >>>           FILE *__restrict __stream) ;
> >>> extern __ssize_t getdelim (char **__restrict __lineptr,
> >>>         size_t *__restrict __n, int __delimiter,
> >>>         FILE *__restrict __stream) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern __ssize_t getline (char **__restrict __lineptr,
> >>>        size_t *__restrict __n,
> >>>        FILE *__restrict __stream) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int puts (const char *__s);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int ungetc (int __c, FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern size_t fread (void *__restrict __ptr, size_t __size,
> >>>        size_t __n, FILE *__restrict __stream) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern size_t fwrite (const void *__restrict __ptr, size_t __size,
> >>>         size_t __n, FILE *__restrict __s);
> >>>
> >>> # 737 "/usr/include/stdio.h" 3 4
> >>> extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
> >>>          size_t __n, FILE *__restrict __stream) ;
> >>> extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t 
> >>> __size,
> >>>           size_t __n, FILE *__restrict __stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fseek (FILE *__stream, long int __off, int __whence);
> >>>
> >>>
> >>>
> >>>
> >>> extern long int ftell (FILE *__stream) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern void rewind (FILE *__stream);
> >>>
> >>> # 773 "/usr/include/stdio.h" 3 4
> >>> extern int fseeko (FILE *__stream, __off_t __off, int __whence);
> >>>
> >>>
> >>>
> >>>
> >>> extern __off_t ftello (FILE *__stream) ;
> >>> # 792 "/usr/include/stdio.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
> >>>
> >>>
> >>>
> >>>
> >>> extern int fsetpos (FILE *__stream, const fpos_t *__pos);
> >>> # 815 "/usr/include/stdio.h" 3 4
> >>>
> >>> # 824 "/usr/include/stdio.h" 3 4
> >>>
> >>>
> >>> extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> ;
> >>>
> >>> extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern void clearerr_unlocked (FILE *__stream) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>> extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void perror (const char *__s);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/sys_errlist.h" 1 3 4
> >>> # 26 "/usr/include/bits/sys_errlist.h" 3 4
> >>> extern int sys_nerr;
> >>> extern const char *const sys_errlist[];
> >>> # 854 "/usr/include/stdio.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>> # 872 "/usr/include/stdio.h" 3 4
> >>> extern FILE *popen (const char *__command, const char *__modes) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int pclose (FILE *__stream);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
> >>> # 912 "/usr/include/stdio.h" 3 4
> >>> extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>> extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 942 "/usr/include/stdio.h" 3 4
> >>>
> >>> # 40 "machine.c" 2
> >>> # 1 "/usr/include/stdlib.h" 1 3 4
> >>> # 32 "/usr/include/stdlib.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 328 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 3 4
> >>> typedef long int wchar_t;
> >>> # 33 "/usr/include/stdlib.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/waitflags.h" 1 3 4
> >>> # 42 "/usr/include/stdlib.h" 2 3 4
> >>> # 1 "/usr/include/bits/waitstatus.h" 1 3 4
> >>> # 64 "/usr/include/bits/waitstatus.h" 3 4
> >>> # 1 "/usr/include/endian.h" 1 3 4
> >>> # 36 "/usr/include/endian.h" 3 4
> >>> # 1 "/usr/include/bits/endian.h" 1 3 4
> >>> # 37 "/usr/include/endian.h" 2 3 4
> >>> # 60 "/usr/include/endian.h" 3 4
> >>> # 1 "/usr/include/bits/byteswap.h" 1 3 4
> >>> # 28 "/usr/include/bits/byteswap.h" 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 29 "/usr/include/bits/byteswap.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/byteswap-16.h" 1 3 4
> >>> # 36 "/usr/include/bits/byteswap.h" 2 3 4
> >>> # 44 "/usr/include/bits/byteswap.h" 3 4
> >>> static __inline unsigned int
> >>> __bswap_32 (unsigned int __bsx)
> >>> {
> >>>   return __builtin_bswap32 (__bsx);
> >>> }
> >>> # 108 "/usr/include/bits/byteswap.h" 3 4
> >>> static __inline __uint64_t
> >>> __bswap_64 (__uint64_t __bsx)
> >>> {
> >>>   return __builtin_bswap64 (__bsx);
> >>> }
> >>> # 61 "/usr/include/endian.h" 2 3 4
> >>> # 65 "/usr/include/bits/waitstatus.h" 2 3 4
> >>>
> >>> union wait
> >>>   {
> >>>     int w_status;
> >>>     struct
> >>>       {
> >>>
> >>>  unsigned int __w_termsig:7;
> >>>  unsigned int __w_coredump:1;
> >>>  unsigned int __w_retcode:8;
> >>>  unsigned int:16;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>       } __wait_terminated;
> >>>     struct
> >>>       {
> >>>
> >>>  unsigned int __w_stopval:8;
> >>>  unsigned int __w_stopsig:8;
> >>>  unsigned int:16;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>       } __wait_stopped;
> >>>   };
> >>> # 43 "/usr/include/stdlib.h" 2 3 4
> >>> # 67 "/usr/include/stdlib.h" 3 4
> >>> typedef union
> >>>   {
> >>>     union wait *__uptr;
> >>>     int *__iptr;
> >>>   } __WAIT_STATUS __attribute__ ((__transparent_union__));
> >>> # 95 "/usr/include/stdlib.h" 3 4
> >>>
> >>>
> >>> typedef struct
> >>>   {
> >>>     int quot;
> >>>     int rem;
> >>>   } div_t;
> >>>
> >>>
> >>>
> >>> typedef struct
> >>>   {
> >>>     long int quot;
> >>>     long int rem;
> >>>   } ldiv_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> __extension__ typedef struct
> >>>   {
> >>>     long long int quot;
> >>>     long long int rem;
> >>>   } lldiv_t;
> >>>
> >>>
> >>> # 139 "/usr/include/stdlib.h" 3 4
> >>> extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern double atof (const char *__nptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>> extern int atoi (const char *__nptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>> extern long int atol (const char *__nptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> __extension__ extern long long int atoll (const char *__nptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern double strtod (const char *__restrict __nptr,
> >>>         char **__restrict __endptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern float strtof (const char *__restrict __nptr,
> >>>        char **__restrict __endptr) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>> extern long double strtold (const char *__restrict __nptr,
> >>>        char **__restrict __endptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern long int strtol (const char *__restrict __nptr,
> >>>    char **__restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>> extern unsigned long int strtoul (const char *__restrict __nptr,
> >>>       char **__restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>> __extension__
> >>> extern long long int strtoq (const char *__restrict __nptr,
> >>>         char **__restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>> __extension__
> >>> extern unsigned long long int strtouq (const char *__restrict __nptr,
> >>>            char **__restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> __extension__
> >>> extern long long int strtoll (const char *__restrict __nptr,
> >>>          char **__restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>> __extension__
> >>> extern unsigned long long int strtoull (const char *__restrict __nptr,
> >>>      char **__restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>> # 305 "/usr/include/stdlib.h" 3 4
> >>> extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> ;
> >>>
> >>>
> >>> extern long int a64l (const char *__s)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/sys/types.h" 1 3 4
> >>> # 27 "/usr/include/sys/types.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __u_char u_char;
> >>> typedef __u_short u_short;
> >>> typedef __u_int u_int;
> >>> typedef __u_long u_long;
> >>> typedef __quad_t quad_t;
> >>> typedef __u_quad_t u_quad_t;
> >>> typedef __fsid_t fsid_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef __loff_t loff_t;
> >>>
> >>>
> >>>
> >>> typedef __ino_t ino_t;
> >>> # 60 "/usr/include/sys/types.h" 3 4
> >>> typedef __dev_t dev_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef __gid_t gid_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef __mode_t mode_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef __nlink_t nlink_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef __uid_t uid_t;
> >>> # 98 "/usr/include/sys/types.h" 3 4
> >>> typedef __pid_t pid_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __id_t id_t;
> >>> # 115 "/usr/include/sys/types.h" 3 4
> >>> typedef __daddr_t daddr_t;
> >>> typedef __caddr_t caddr_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __key_t key_t;
> >>> # 132 "/usr/include/sys/types.h" 3 4
> >>> # 1 "/usr/include/time.h" 1 3 4
> >>> # 57 "/usr/include/time.h" 3 4
> >>>
> >>>
> >>> typedef __clock_t clock_t;
> >>>
> >>>
> >>>
> >>> # 73 "/usr/include/time.h" 3 4
> >>>
> >>>
> >>> typedef __time_t time_t;
> >>>
> >>>
> >>>
> >>> # 91 "/usr/include/time.h" 3 4
> >>> typedef __clockid_t clockid_t;
> >>> # 103 "/usr/include/time.h" 3 4
> >>> typedef __timer_t timer_t;
> >>> # 133 "/usr/include/sys/types.h" 2 3 4
> >>> # 146 "/usr/include/sys/types.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 147 "/usr/include/sys/types.h" 2 3 4
> >>>
> >>>
> >>>
> >>> typedef unsigned long int ulong;
> >>> typedef unsigned short int ushort;
> >>> typedef unsigned int uint;
> >>> # 194 "/usr/include/sys/types.h" 3 4
> >>> typedef int int8_t __attribute__ ((__mode__ (__QI__)));
> >>> typedef int int16_t __attribute__ ((__mode__ (__HI__)));
> >>> typedef int int32_t __attribute__ ((__mode__ (__SI__)));
> >>> typedef int int64_t __attribute__ ((__mode__ (__DI__)));
> >>>
> >>>
> >>> typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
> >>> typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
> >>> typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
> >>> typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
> >>>
> >>> typedef int register_t __attribute__ ((__mode__ (__word__)));
> >>> # 219 "/usr/include/sys/types.h" 3 4
> >>> # 1 "/usr/include/sys/select.h" 1 3 4
> >>> # 30 "/usr/include/sys/select.h" 3 4
> >>> # 1 "/usr/include/bits/select.h" 1 3 4
> >>> # 22 "/usr/include/bits/select.h" 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 23 "/usr/include/bits/select.h" 2 3 4
> >>> # 31 "/usr/include/sys/select.h" 2 3 4
> >>>
> >>>
> >>> # 1 "/usr/include/bits/sigset.h" 1 3 4
> >>> # 22 "/usr/include/bits/sigset.h" 3 4
> >>> typedef int __sig_atomic_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef struct
> >>>   {
> >>>     unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
> >>>   } __sigset_t;
> >>> # 34 "/usr/include/sys/select.h" 2 3 4
> >>>
> >>>
> >>>
> >>> typedef __sigset_t sigset_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/time.h" 1 3 4
> >>> # 120 "/usr/include/time.h" 3 4
> >>> struct timespec
> >>>   {
> >>>     __time_t tv_sec;
> >>>     __syscall_slong_t tv_nsec;
> >>>   };
> >>> # 44 "/usr/include/sys/select.h" 2 3 4
> >>>
> >>> # 1 "/usr/include/bits/time.h" 1 3 4
> >>> # 30 "/usr/include/bits/time.h" 3 4
> >>> struct timeval
> >>>   {
> >>>     __time_t tv_sec;
> >>>     __suseconds_t tv_usec;
> >>>   };
> >>> # 46 "/usr/include/sys/select.h" 2 3 4
> >>>
> >>>
> >>> typedef __suseconds_t suseconds_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef long int __fd_mask;
> >>> # 64 "/usr/include/sys/select.h" 3 4
> >>> typedef struct
> >>>   {
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>     __fd_mask __fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
> >>>
> >>>
> >>>   } fd_set;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __fd_mask fd_mask;
> >>> # 96 "/usr/include/sys/select.h" 3 4
> >>>
> >>> # 106 "/usr/include/sys/select.h" 3 4
> >>> extern int select (int __nfds, fd_set *__restrict __readfds,
> >>>      fd_set *__restrict __writefds,
> >>>      fd_set *__restrict __exceptfds,
> >>>      struct timeval *__restrict __timeout);
> >>> # 118 "/usr/include/sys/select.h" 3 4
> >>> extern int pselect (int __nfds, fd_set *__restrict __readfds,
> >>>       fd_set *__restrict __writefds,
> >>>       fd_set *__restrict __exceptfds,
> >>>       const struct timespec *__restrict __timeout,
> >>>       const __sigset_t *__restrict __sigmask);
> >>> # 131 "/usr/include/sys/select.h" 3 4
> >>>
> >>> # 220 "/usr/include/sys/types.h" 2 3 4
> >>>
> >>>
> >>> # 1 "/usr/include/sys/sysmacros.h" 1 3 4
> >>> # 24 "/usr/include/sys/sysmacros.h" 3 4
> >>>
> >>>
> >>> __extension__
> >>> extern unsigned int gnu_dev_major (unsigned long long int __dev)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> __extension__
> >>> extern unsigned int gnu_dev_minor (unsigned long long int __dev)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> __extension__
> >>> extern unsigned long long int gnu_dev_makedev (unsigned int __major,
> >>>             unsigned int __minor)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> # 58 "/usr/include/sys/sysmacros.h" 3 4
> >>>
> >>> # 223 "/usr/include/sys/types.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __blksize_t blksize_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __blkcnt_t blkcnt_t;
> >>>
> >>>
> >>>
> >>> typedef __fsblkcnt_t fsblkcnt_t;
> >>>
> >>>
> >>>
> >>> typedef __fsfilcnt_t fsfilcnt_t;
> >>> # 270 "/usr/include/sys/types.h" 3 4
> >>> # 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
> >>> # 21 "/usr/include/bits/pthreadtypes.h" 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 22 "/usr/include/bits/pthreadtypes.h" 2 3 4
> >>> # 60 "/usr/include/bits/pthreadtypes.h" 3 4
> >>> typedef unsigned long int pthread_t;
> >>>
> >>>
> >>> union pthread_attr_t
> >>> {
> >>>   char __size[36];
> >>>   long int __align;
> >>> };
> >>>
> >>> typedef union pthread_attr_t pthread_attr_t;
> >>> # 81 "/usr/include/bits/pthreadtypes.h" 3 4
> >>> typedef struct __pthread_internal_slist
> >>> {
> >>>   struct __pthread_internal_slist *__next;
> >>> } __pthread_slist_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef union
> >>> {
> >>>   struct __pthread_mutex_s
> >>>   {
> >>>     int __lock;
> >>>     unsigned int __count;
> >>>     int __owner;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>     int __kind;
> >>> # 111 "/usr/include/bits/pthreadtypes.h" 3 4
> >>>     unsigned int __nusers;
> >>>     __extension__ union
> >>>     {
> >>>       struct
> >>>       {
> >>>  short __espins;
> >>>  short __elision;
> >>>
> >>>
> >>>
> >>>       } __elision_data;
> >>>       __pthread_slist_t __list;
> >>>     };
> >>>
> >>>   } __data;
> >>>   char __size[24];
> >>>   long int __align;
> >>> } pthread_mutex_t;
> >>>
> >>> typedef union
> >>> {
> >>>   char __size[4];
> >>>   int __align;
> >>> } pthread_mutexattr_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef union
> >>> {
> >>>   struct
> >>>   {
> >>>     int __lock;
> >>>     unsigned int __futex;
> >>>     __extension__ unsigned long long int __total_seq;
> >>>     __extension__ unsigned long long int __wakeup_seq;
> >>>     __extension__ unsigned long long int __woken_seq;
> >>>     void *__mutex;
> >>>     unsigned int __nwaiters;
> >>>     unsigned int __broadcast_seq;
> >>>   } __data;
> >>>   char __size[48];
> >>>   __extension__ long long int __align;
> >>> } pthread_cond_t;
> >>>
> >>> typedef union
> >>> {
> >>>   char __size[4];
> >>>   int __align;
> >>> } pthread_condattr_t;
> >>>
> >>>
> >>>
> >>> typedef unsigned int pthread_key_t;
> >>>
> >>>
> >>>
> >>> typedef int pthread_once_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef union
> >>> {
> >>> # 202 "/usr/include/bits/pthreadtypes.h" 3 4
> >>>   struct
> >>>   {
> >>>     int __lock;
> >>>     unsigned int __nr_readers;
> >>>     unsigned int __readers_wakeup;
> >>>     unsigned int __writer_wakeup;
> >>>     unsigned int __nr_readers_queued;
> >>>     unsigned int __nr_writers_queued;
> >>>
> >>>
> >>>     unsigned char __flags;
> >>>     unsigned char __shared;
> >>>     signed char __rwelision;
> >>>
> >>>     unsigned char __pad2;
> >>>     int __writer;
> >>>   } __data;
> >>>
> >>>   char __size[32];
> >>>   long int __align;
> >>> } pthread_rwlock_t;
> >>>
> >>> typedef union
> >>> {
> >>>   char __size[8];
> >>>   long int __align;
> >>> } pthread_rwlockattr_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef volatile int pthread_spinlock_t;
> >>>
> >>>
> >>>
> >>>
> >>> typedef union
> >>> {
> >>>   char __size[20];
> >>>   long int __align;
> >>> } pthread_barrier_t;
> >>>
> >>> typedef union
> >>> {
> >>>   char __size[4];
> >>>   int __align;
> >>> } pthread_barrierattr_t;
> >>> # 271 "/usr/include/sys/types.h" 2 3 4
> >>>
> >>>
> >>>
> >>> # 315 "/usr/include/stdlib.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *initstate (unsigned int __seed, char *__statebuf,
> >>>    size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (2)));
> >>>
> >>>
> >>>
> >>> extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct random_data
> >>>   {
> >>>     int32_t *fptr;
> >>>     int32_t *rptr;
> >>>     int32_t *state;
> >>>     int rand_type;
> >>>     int rand_deg;
> >>>     int rand_sep;
> >>>     int32_t *end_ptr;
> >>>   };
> >>>
> >>> extern int random_r (struct random_data *__restrict __buf,
> >>>        int32_t *__restrict __result) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>> extern int srandom_r (unsigned int __seed, struct random_data *__buf)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>> extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
> >>>    size_t __statelen,
> >>>    struct random_data *__restrict __buf)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2, 4)));
> >>>
> >>> extern int setstate_r (char *__restrict __statebuf,
> >>>          struct random_data *__restrict __buf)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>> extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern double erand48 (unsigned short int __xsubi[3]) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern long int nrand48 (unsigned short int __xsubi[3])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>> extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern long int jrand48 (unsigned short int __xsubi[3])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>> extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern unsigned short int *seed48 (unsigned short int __seed16v[3])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>> extern void lcong48 (unsigned short int __param[7]) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct drand48_data
> >>>   {
> >>>     unsigned short int __x[3];
> >>>     unsigned short int __old_x[3];
> >>>     unsigned short int __c;
> >>>     unsigned short int __init;
> >>>     __extension__ unsigned long long int __a;
> >>>
> >>>   };
> >>>
> >>>
> >>> extern int drand48_r (struct drand48_data *__restrict __buffer,
> >>>         double *__restrict __result) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
> >>> extern int erand48_r (unsigned short int __xsubi[3],
> >>>         struct drand48_data *__restrict __buffer,
> >>>         double *__restrict __result) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>> extern int lrand48_r (struct drand48_data *__restrict __buffer,
> >>>         long int *__restrict __result)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>> extern int nrand48_r (unsigned short int __xsubi[3],
> >>>         struct drand48_data *__restrict __buffer,
> >>>         long int *__restrict __result)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>> extern int mrand48_r (struct drand48_data *__restrict __buffer,
> >>>         long int *__restrict __result)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>> extern int jrand48_r (unsigned short int __xsubi[3],
> >>>         struct drand48_data *__restrict __buffer,
> >>>         long int *__restrict __result)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>> extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>> extern int seed48_r (unsigned short int __seed16v[3],
> >>>        struct drand48_data *__buffer) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>> extern int lcong48_r (unsigned short int __param[7],
> >>>         struct drand48_data *__buffer)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__malloc__)) ;
> >>>
> >>> extern void *calloc (size_t __nmemb, size_t __size)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__malloc__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *realloc (void *__ptr, size_t __size)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__warn_unused_result__));
> >>>
> >>> extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern void cfree (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/alloca.h" 1 3 4
> >>> # 24 "/usr/include/alloca.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 25 "/usr/include/alloca.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 493 "/usr/include/stdlib.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__malloc__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int posix_memalign (void **__memptr, size_t __alignment, size_t 
> >>> __size)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern void *aligned_alloc (size_t __alignment, size_t __size)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__noreturn__));
> >>>
> >>>
> >>>
> >>> extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int at_quick_exit (void (*__func) (void)) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int on_exit (void (*__func) (int __status, void *__arg), void 
> >>> *__arg)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__noreturn__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void quick_exit (int __status) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__noreturn__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__noreturn__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>> # 578 "/usr/include/stdlib.h" 3 4
> >>> extern int putenv (char *__string) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int setenv (const char *__name, const char *__value, int __replace)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>>
> >>> extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> # 606 "/usr/include/stdlib.h" 3 4
> >>> extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>> # 619 "/usr/include/stdlib.h" 3 4
> >>> extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
> >>> # 641 "/usr/include/stdlib.h" 3 4
> >>> extern int mkstemps (char *__template, int __suffixlen) __attribute__ 
> >>> ((__nonnull__ (1))) ;
> >>> # 662 "/usr/include/stdlib.h" 3 4
> >>> extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1))) ;
> >>> # 711 "/usr/include/stdlib.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int system (const char *__command) ;
> >>>
> >>> # 733 "/usr/include/stdlib.h" 3 4
> >>> extern char *realpath (const char *__restrict __name,
> >>>          char *__restrict __resolved) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef int (*__compar_fn_t) (const void *, const void *);
> >>> # 751 "/usr/include/stdlib.h" 3 4
> >>>
> >>>
> >>>
> >>> extern void *bsearch (const void *__key, const void *__base,
> >>>         size_t __nmemb, size_t __size, __compar_fn_t __compar)
> >>>      __attribute__ ((__nonnull__ (1, 2, 5))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void qsort (void *__base, size_t __nmemb, size_t __size,
> >>>      __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
> >>> # 774 "/usr/include/stdlib.h" 3 4
> >>> extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__const__)) ;
> >>> extern long int labs (long int __x) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__const__)) ;
> >>>
> >>>
> >>>
> >>> __extension__ extern long long int llabs (long long int __x)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) 
> >>> ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern div_t div (int __numer, int __denom)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) 
> >>> ;
> >>> extern ldiv_t ldiv (long int __numer, long int __denom)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) 
> >>> ;
> >>>
> >>>
> >>>
> >>>
> >>> __extension__ extern lldiv_t lldiv (long long int __numer,
> >>>         long long int __denom)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) 
> >>> ;
> >>>
> >>> # 811 "/usr/include/stdlib.h" 3 4
> >>> extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
> >>>      int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (3, 4))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
> >>>      int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (3, 4))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern char *gcvt (double __value, int __ndigit, char *__buf)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern char *qecvt (long double __value, int __ndigit,
> >>>       int *__restrict __decpt, int *__restrict __sign)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3, 4))) ;
> >>> extern char *qfcvt (long double __value, int __ndigit,
> >>>       int *__restrict __decpt, int *__restrict __sign)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3, 4))) ;
> >>> extern char *qgcvt (long double __value, int __ndigit, char *__buf)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
> >>>      int *__restrict __sign, char *__restrict __buf,
> >>>      size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__nonnull__ (3, 4, 5)));
> >>> extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
> >>>      int *__restrict __sign, char *__restrict __buf,
> >>>      size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__nonnull__ (3, 4, 5)));
> >>>
> >>> extern int qecvt_r (long double __value, int __ndigit,
> >>>       int *__restrict __decpt, int *__restrict __sign,
> >>>       char *__restrict __buf, size_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3, 4, 5)));
> >>> extern int qfcvt_r (long double __value, int __ndigit,
> >>>       int *__restrict __decpt, int *__restrict __sign,
> >>>       char *__restrict __buf, size_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3, 4, 5)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int mblen (const char *__s, size_t __n) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int mbtowc (wchar_t *__restrict __pwc,
> >>>      const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>> extern int wctomb (char *__s, wchar_t __wchar) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern size_t mbstowcs (wchar_t *__restrict __pwcs,
> >>>    const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern size_t wcstombs (char *__restrict __s,
> >>>    const wchar_t *__restrict __pwcs, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1))) ;
> >>> # 898 "/usr/include/stdlib.h" 3 4
> >>> extern int getsubopt (char **__restrict __optionp,
> >>>         char *const *__restrict __tokens,
> >>>         char **__restrict __valuep)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2, 3))) ;
> >>> # 950 "/usr/include/stdlib.h" 3 4
> >>> extern int getloadavg (double __loadavg[], int __nelem)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>> # 1 "/usr/include/bits/stdlib-float.h" 1 3 4
> >>> # 955 "/usr/include/stdlib.h" 2 3 4
> >>> # 967 "/usr/include/stdlib.h" 3 4
> >>>
> >>> # 41 "machine.c" 2
> >>> # 1 "/usr/include/signal.h" 1 3 4
> >>> # 30 "/usr/include/signal.h" 3 4
> >>>
> >>>
> >>> # 1 "/usr/include/bits/sigset.h" 1 3 4
> >>> # 102 "/usr/include/bits/sigset.h" 3 4
> >>> extern int __sigismember (const __sigset_t *, int);
> >>> extern int __sigaddset (__sigset_t *, int);
> >>> extern int __sigdelset (__sigset_t *, int);
> >>> # 33 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef __sig_atomic_t sig_atomic_t;
> >>>
> >>> # 57 "/usr/include/signal.h" 3 4
> >>> # 1 "/usr/include/bits/signum.h" 1 3 4
> >>> # 58 "/usr/include/signal.h" 2 3 4
> >>> # 75 "/usr/include/signal.h" 3 4
> >>> # 1 "/usr/include/time.h" 1 3 4
> >>> # 76 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/siginfo.h" 1 3 4
> >>> # 24 "/usr/include/bits/siginfo.h" 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 25 "/usr/include/bits/siginfo.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef union sigval
> >>>   {
> >>>     int sival_int;
> >>>     void *sival_ptr;
> >>>   } sigval_t;
> >>> # 58 "/usr/include/bits/siginfo.h" 3 4
> >>> typedef __clock_t __sigchld_clock_t;
> >>>
> >>>
> >>>
> >>> typedef struct
> >>>   {
> >>>     int si_signo;
> >>>     int si_errno;
> >>>
> >>>     int si_code;
> >>>
> >>>     union
> >>>       {
> >>>  int _pad[((128 / sizeof (int)) - 3)];
> >>>
> >>>
> >>>  struct
> >>>    {
> >>>      __pid_t si_pid;
> >>>      __uid_t si_uid;
> >>>    } _kill;
> >>>
> >>>
> >>>  struct
> >>>    {
> >>>      int si_tid;
> >>>      int si_overrun;
> >>>      sigval_t si_sigval;
> >>>    } _timer;
> >>>
> >>>
> >>>  struct
> >>>    {
> >>>      __pid_t si_pid;
> >>>      __uid_t si_uid;
> >>>      sigval_t si_sigval;
> >>>    } _rt;
> >>>
> >>>
> >>>  struct
> >>>    {
> >>>      __pid_t si_pid;
> >>>      __uid_t si_uid;
> >>>      int si_status;
> >>>      __sigchld_clock_t si_utime;
> >>>      __sigchld_clock_t si_stime;
> >>>    } _sigchld;
> >>>
> >>>
> >>>  struct
> >>>    {
> >>>      void *si_addr;
> >>>      short int si_addr_lsb;
> >>>      struct
> >>>        {
> >>>   void *_lower;
> >>>   void *_upper;
> >>>        } si_addr_bnd;
> >>>    } _sigfault;
> >>>
> >>>
> >>>  struct
> >>>    {
> >>>      long int si_band;
> >>>      int si_fd;
> >>>    } _sigpoll;
> >>>
> >>>
> >>>  struct
> >>>    {
> >>>      void *_call_addr;
> >>>      int _syscall;
> >>>      unsigned int _arch;
> >>>    } _sigsys;
> >>>       } _sifields;
> >>>   } siginfo_t ;
> >>> # 160 "/usr/include/bits/siginfo.h" 3 4
> >>> enum
> >>> {
> >>>   SI_ASYNCNL = -60,
> >>>
> >>>   SI_TKILL = -6,
> >>>
> >>>   SI_SIGIO,
> >>>
> >>>   SI_ASYNCIO,
> >>>
> >>>   SI_MESGQ,
> >>>
> >>>   SI_TIMER,
> >>>
> >>>   SI_QUEUE,
> >>>
> >>>   SI_USER,
> >>>
> >>>   SI_KERNEL = 0x80
> >>>
> >>> };
> >>>
> >>>
> >>>
> >>>
> >>> enum
> >>> {
> >>>   ILL_ILLOPC = 1,
> >>>
> >>>   ILL_ILLOPN,
> >>>
> >>>   ILL_ILLADR,
> >>>
> >>>   ILL_ILLTRP,
> >>>
> >>>   ILL_PRVOPC,
> >>>
> >>>   ILL_PRVREG,
> >>>
> >>>   ILL_COPROC,
> >>>
> >>>   ILL_BADSTK
> >>>
> >>> };
> >>>
> >>>
> >>> enum
> >>> {
> >>>   FPE_INTDIV = 1,
> >>>
> >>>   FPE_INTOVF,
> >>>
> >>>   FPE_FLTDIV,
> >>>
> >>>   FPE_FLTOVF,
> >>>
> >>>   FPE_FLTUND,
> >>>
> >>>   FPE_FLTRES,
> >>>
> >>>   FPE_FLTINV,
> >>>
> >>>   FPE_FLTSUB
> >>>
> >>> };
> >>>
> >>>
> >>> enum
> >>> {
> >>>   SEGV_MAPERR = 1,
> >>>
> >>>   SEGV_ACCERR
> >>>
> >>> };
> >>>
> >>>
> >>> enum
> >>> {
> >>>   BUS_ADRALN = 1,
> >>>
> >>>   BUS_ADRERR,
> >>>
> >>>   BUS_OBJERR,
> >>>
> >>>   BUS_MCEERR_AR,
> >>>
> >>>   BUS_MCEERR_AO
> >>>
> >>> };
> >>> # 264 "/usr/include/bits/siginfo.h" 3 4
> >>> enum
> >>> {
> >>>   CLD_EXITED = 1,
> >>>
> >>>   CLD_KILLED,
> >>>
> >>>   CLD_DUMPED,
> >>>
> >>>   CLD_TRAPPED,
> >>>
> >>>   CLD_STOPPED,
> >>>
> >>>   CLD_CONTINUED
> >>>
> >>> };
> >>>
> >>>
> >>> enum
> >>> {
> >>>   POLL_IN = 1,
> >>>
> >>>   POLL_OUT,
> >>>
> >>>   POLL_MSG,
> >>>
> >>>   POLL_ERR,
> >>>
> >>>   POLL_PRI,
> >>>
> >>>   POLL_HUP
> >>>
> >>> };
> >>> # 320 "/usr/include/bits/siginfo.h" 3 4
> >>> typedef struct sigevent
> >>>   {
> >>>     sigval_t sigev_value;
> >>>     int sigev_signo;
> >>>     int sigev_notify;
> >>>
> >>>     union
> >>>       {
> >>>  int _pad[((64 / sizeof (int)) - 3)];
> >>>
> >>>
> >>>
> >>>  __pid_t _tid;
> >>>
> >>>  struct
> >>>    {
> >>>      void (*_function) (sigval_t);
> >>>      pthread_attr_t *_attribute;
> >>>    } _sigev_thread;
> >>>       } _sigev_un;
> >>>   } sigevent_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> enum
> >>> {
> >>>   SIGEV_SIGNAL = 0,
> >>>
> >>>   SIGEV_NONE,
> >>>
> >>>   SIGEV_THREAD,
> >>>
> >>>
> >>>   SIGEV_THREAD_ID = 4
> >>>
> >>> };
> >>> # 81 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> typedef void (*__sighandler_t) (int);
> >>>
> >>>
> >>>
> >>>
> >>> extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>> # 100 "/usr/include/signal.h" 3 4
> >>>
> >>>
> >>> extern __sighandler_t signal (int __sig, __sighandler_t __handler)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>> # 114 "/usr/include/signal.h" 3 4
> >>>
> >>> # 127 "/usr/include/signal.h" 3 4
> >>> extern int kill (__pid_t __pid, int __sig) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int killpg (__pid_t __pgrp, int __sig) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int raise (int __sig) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int gsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern void psignal (int __sig, const char *__s);
> >>>
> >>>
> >>> extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
> >>> # 187 "/usr/include/signal.h" 3 4
> >>> extern int sigblock (int __mask) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__deprecated__));
> >>>
> >>>
> >>> extern int sigsetmask (int __mask) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__deprecated__));
> >>>
> >>>
> >>> extern int siggetmask (void) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__deprecated__));
> >>> # 207 "/usr/include/signal.h" 3 4
> >>> typedef __sighandler_t sig_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int sigemptyset (sigset_t *__set) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> extern int sigfillset (sigset_t *__set) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> extern int sigaddset (sigset_t *__set, int __signo) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> extern int sigdelset (sigset_t *__set, int __signo) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> extern int sigismember (const sigset_t *__set, int __signo)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>> # 243 "/usr/include/signal.h" 3 4
> >>> # 1 "/usr/include/bits/sigaction.h" 1 3 4
> >>> # 24 "/usr/include/bits/sigaction.h" 3 4
> >>> struct sigaction
> >>>   {
> >>>
> >>>
> >>>     union
> >>>       {
> >>>
> >>>  __sighandler_t sa_handler;
> >>>
> >>>  void (*sa_sigaction) (int, siginfo_t *, void *);
> >>>       }
> >>>     __sigaction_handler;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>     __sigset_t sa_mask;
> >>>
> >>>
> >>>     int sa_flags;
> >>>
> >>>
> >>>     void (*sa_restorer) (void);
> >>>   };
> >>> # 244 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>> extern int sigprocmask (int __how, const sigset_t *__restrict __set,
> >>>    sigset_t *__restrict __oset) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>> extern int sigaction (int __sig, const struct sigaction *__restrict __act,
> >>>         struct sigaction *__restrict __oact) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>> extern int sigpending (sigset_t *__set) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int sigwait (const sigset_t *__restrict __set, int *__restrict 
> >>> __sig)
> >>>      __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int sigwaitinfo (const sigset_t *__restrict __set,
> >>>    siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int sigtimedwait (const sigset_t *__restrict __set,
> >>>     siginfo_t *__restrict __info,
> >>>     const struct timespec *__restrict __timeout)
> >>>      __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>> extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>> # 301 "/usr/include/signal.h" 3 4
> >>> extern const char *const _sys_siglist[65];
> >>> extern const char *const sys_siglist[65];
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/sigcontext.h" 1 3 4
> >>> # 29 "/usr/include/bits/sigcontext.h" 3 4
> >>> struct _fpx_sw_bytes
> >>> {
> >>>   __uint32_t magic1;
> >>>   __uint32_t extended_size;
> >>>   __uint64_t xstate_bv;
> >>>   __uint32_t xstate_size;
> >>>   __uint32_t padding[7];
> >>> };
> >>>
> >>> struct _fpreg
> >>> {
> >>>   unsigned short significand[4];
> >>>   unsigned short exponent;
> >>> };
> >>>
> >>> struct _fpxreg
> >>> {
> >>>   unsigned short significand[4];
> >>>   unsigned short exponent;
> >>>   unsigned short padding[3];
> >>> };
> >>>
> >>> struct _xmmreg
> >>> {
> >>>   __uint32_t element[4];
> >>> };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct _fpstate
> >>> {
> >>>
> >>>   __uint32_t cw;
> >>>   __uint32_t sw;
> >>>   __uint32_t tag;
> >>>   __uint32_t ipoff;
> >>>   __uint32_t cssel;
> >>>   __uint32_t dataoff;
> >>>   __uint32_t datasel;
> >>>   struct _fpreg _st[8];
> >>>   unsigned short status;
> >>>   unsigned short magic;
> >>>
> >>>
> >>>   __uint32_t _fxsr_env[6];
> >>>   __uint32_t mxcsr;
> >>>   __uint32_t reserved;
> >>>   struct _fpxreg _fxsr_st[8];
> >>>   struct _xmmreg _xmm[8];
> >>>   __uint32_t padding[56];
> >>> };
> >>> # 93 "/usr/include/bits/sigcontext.h" 3 4
> >>> struct sigcontext
> >>> {
> >>>   unsigned short gs, __gsh;
> >>>   unsigned short fs, __fsh;
> >>>   unsigned short es, __esh;
> >>>   unsigned short ds, __dsh;
> >>>   unsigned long edi;
> >>>   unsigned long esi;
> >>>   unsigned long ebp;
> >>>   unsigned long esp;
> >>>   unsigned long ebx;
> >>>   unsigned long edx;
> >>>   unsigned long ecx;
> >>>   unsigned long eax;
> >>>   unsigned long trapno;
> >>>   unsigned long err;
> >>>   unsigned long eip;
> >>>   unsigned short cs, __csh;
> >>>   unsigned long eflags;
> >>>   unsigned long esp_at_signal;
> >>>   unsigned short ss, __ssh;
> >>>   struct _fpstate * fpstate;
> >>>   unsigned long oldmask;
> >>>   unsigned long cr2;
> >>> };
> >>> # 175 "/usr/include/bits/sigcontext.h" 3 4
> >>> struct _xsave_hdr
> >>> {
> >>>   __uint64_t xstate_bv;
> >>>   __uint64_t reserved1[2];
> >>>   __uint64_t reserved2[5];
> >>> };
> >>>
> >>> struct _ymmh_state
> >>> {
> >>>   __uint32_t ymmh_space[64];
> >>> };
> >>>
> >>> struct _xstate
> >>> {
> >>>   struct _fpstate fpstate;
> >>>   struct _xsave_hdr xstate_hdr;
> >>>   struct _ymmh_state ymmh;
> >>> };
> >>> # 307 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>> extern int sigreturn (struct sigcontext *__scp) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 317 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> extern int siginterrupt (int __sig, int __interrupt) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>> # 1 "/usr/include/bits/sigstack.h" 1 3 4
> >>> # 25 "/usr/include/bits/sigstack.h" 3 4
> >>> struct sigstack
> >>>   {
> >>>     void *ss_sp;
> >>>     int ss_onstack;
> >>>   };
> >>>
> >>>
> >>>
> >>> enum
> >>> {
> >>>   SS_ONSTACK = 1,
> >>>
> >>>   SS_DISABLE
> >>>
> >>> };
> >>> # 49 "/usr/include/bits/sigstack.h" 3 4
> >>> typedef struct sigaltstack
> >>>   {
> >>>     void *ss_sp;
> >>>     int ss_flags;
> >>>     size_t ss_size;
> >>>   } stack_t;
> >>> # 324 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>> # 1 "/usr/include/sys/ucontext.h" 1 3 4
> >>> # 22 "/usr/include/sys/ucontext.h" 3 4
> >>> # 1 "/usr/include/signal.h" 1 3 4
> >>> # 23 "/usr/include/sys/ucontext.h" 2 3 4
> >>> # 146 "/usr/include/sys/ucontext.h" 3 4
> >>> typedef int greg_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef greg_t gregset_t[19];
> >>> # 200 "/usr/include/sys/ucontext.h" 3 4
> >>> struct _libc_fpreg
> >>> {
> >>>   unsigned short int significand[4];
> >>>   unsigned short int exponent;
> >>> };
> >>>
> >>> struct _libc_fpstate
> >>> {
> >>>   unsigned long int cw;
> >>>   unsigned long int sw;
> >>>   unsigned long int tag;
> >>>   unsigned long int ipoff;
> >>>   unsigned long int cssel;
> >>>   unsigned long int dataoff;
> >>>   unsigned long int datasel;
> >>>   struct _libc_fpreg _st[8];
> >>>   unsigned long int status;
> >>> };
> >>>
> >>>
> >>> typedef struct _libc_fpstate *fpregset_t;
> >>>
> >>>
> >>> typedef struct
> >>>   {
> >>>     gregset_t gregs;
> >>>
> >>>
> >>>     fpregset_t fpregs;
> >>>     unsigned long int oldmask;
> >>>     unsigned long int cr2;
> >>>   } mcontext_t;
> >>>
> >>>
> >>> typedef struct ucontext
> >>>   {
> >>>     unsigned long int uc_flags;
> >>>     struct ucontext *uc_link;
> >>>     stack_t uc_stack;
> >>>     mcontext_t uc_mcontext;
> >>>     __sigset_t uc_sigmask;
> >>>     struct _libc_fpstate __fpregs_mem;
> >>>   } ucontext_t;
> >>> # 327 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__deprecated__));
> >>>
> >>>
> >>>
> >>> extern int sigaltstack (const struct sigaltstack *__restrict __ss,
> >>>    struct sigaltstack *__restrict __oss) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 362 "/usr/include/signal.h" 3 4
> >>> # 1 "/usr/include/bits/sigthread.h" 1 3 4
> >>> # 30 "/usr/include/bits/sigthread.h" 3 4
> >>> extern int pthread_sigmask (int __how,
> >>>        const __sigset_t *__restrict __newmask,
> >>>        __sigset_t *__restrict __oldmask)__attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern int pthread_kill (pthread_t __threadid, int __signo) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> # 363 "/usr/include/signal.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int __libc_current_sigrtmin (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern int __libc_current_sigrtmax (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> # 42 "machine.c" 2
> >>> # 1 "/usr/include/errno.h" 1 3 4
> >>> # 31 "/usr/include/errno.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/errno.h" 1 3 4
> >>> # 24 "/usr/include/bits/errno.h" 3 4
> >>> # 1 "/usr/include/linux/errno.h" 1 3 4
> >>> # 1 "/usr/include/asm/errno.h" 1 3 4
> >>> # 1 "/usr/include/asm-generic/errno.h" 1 3 4
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
> >>> # 5 "/usr/include/asm-generic/errno.h" 2 3 4
> >>> # 1 "/usr/include/asm/errno.h" 2 3 4
> >>> # 1 "/usr/include/linux/errno.h" 2 3 4
> >>> # 25 "/usr/include/bits/errno.h" 2 3 4
> >>> # 50 "/usr/include/bits/errno.h" 3 4
> >>> extern int *__errno_location (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__const__));
> >>> # 36 "/usr/include/errno.h" 2 3 4
> >>> # 58 "/usr/include/errno.h" 3 4
> >>>
> >>> # 43 "machine.c" 2
> >>> # 1 "/usr/include/fcntl.h" 1 3 4
> >>> # 28 "/usr/include/fcntl.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/fcntl.h" 1 3 4
> >>> # 35 "/usr/include/bits/fcntl.h" 3 4
> >>> struct flock
> >>>   {
> >>>     short int l_type;
> >>>     short int l_whence;
> >>>
> >>>     __off_t l_start;
> >>>     __off_t l_len;
> >>>
> >>>
> >>>
> >>>
> >>>     __pid_t l_pid;
> >>>   };
> >>> # 61 "/usr/include/bits/fcntl.h" 3 4
> >>> # 1 "/usr/include/bits/fcntl-linux.h" 1 3 4
> >>> # 345 "/usr/include/bits/fcntl-linux.h" 3 4
> >>>
> >>> # 419 "/usr/include/bits/fcntl-linux.h" 3 4
> >>>
> >>> # 61 "/usr/include/bits/fcntl.h" 2 3 4
> >>> # 36 "/usr/include/fcntl.h" 2 3 4
> >>> # 76 "/usr/include/fcntl.h" 3 4
> >>> # 1 "/usr/include/time.h" 1 3 4
> >>> # 77 "/usr/include/fcntl.h" 2 3 4
> >>> # 1 "/usr/include/bits/stat.h" 1 3 4
> >>> # 46 "/usr/include/bits/stat.h" 3 4
> >>> struct stat
> >>>   {
> >>>     __dev_t st_dev;
> >>>
> >>>     unsigned short int __pad1;
> >>>
> >>>
> >>>     __ino_t st_ino;
> >>>
> >>>
> >>>
> >>>
> >>>     __mode_t st_mode;
> >>>     __nlink_t st_nlink;
> >>>
> >>>
> >>>
> >>>
> >>>     __uid_t st_uid;
> >>>     __gid_t st_gid;
> >>>
> >>>
> >>>
> >>>     __dev_t st_rdev;
> >>>
> >>>     unsigned short int __pad2;
> >>>
> >>>
> >>>     __off_t st_size;
> >>>
> >>>
> >>>
> >>>     __blksize_t st_blksize;
> >>>
> >>>     __blkcnt_t st_blocks;
> >>> # 91 "/usr/include/bits/stat.h" 3 4
> >>>     struct timespec st_atim;
> >>>     struct timespec st_mtim;
> >>>     struct timespec st_ctim;
> >>> # 109 "/usr/include/bits/stat.h" 3 4
> >>>     unsigned long int __glibc_reserved4;
> >>>     unsigned long int __glibc_reserved5;
> >>>
> >>>
> >>>
> >>>
> >>>   };
> >>> # 78 "/usr/include/fcntl.h" 2 3 4
> >>> # 169 "/usr/include/fcntl.h" 3 4
> >>> extern int fcntl (int __fd, int __cmd, ...);
> >>> # 179 "/usr/include/fcntl.h" 3 4
> >>> extern int open (const char *__file, int __oflag, ...) __attribute__ 
> >>> ((__nonnull__ (1)));
> >>> # 203 "/usr/include/fcntl.h" 3 4
> >>> extern int openat (int __fd, const char *__file, int __oflag, ...)
> >>>      __attribute__ ((__nonnull__ (2)));
> >>> # 225 "/usr/include/fcntl.h" 3 4
> >>> extern int creat (const char *__file, mode_t __mode) __attribute__ 
> >>> ((__nonnull__ (1)));
> >>> # 254 "/usr/include/fcntl.h" 3 4
> >>> extern int lockf (int __fd, int __cmd, off_t __len);
> >>> # 271 "/usr/include/fcntl.h" 3 4
> >>> extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
> >>>      int __advise) __attribute__ ((__nothrow__ , __leaf__));
> >>> # 293 "/usr/include/fcntl.h" 3 4
> >>> extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
> >>> # 315 "/usr/include/fcntl.h" 3 4
> >>>
> >>> # 44 "machine.c" 2
> >>> # 1 "/usr/include/ctype.h" 1 3 4
> >>> # 28 "/usr/include/ctype.h" 3 4
> >>>
> >>> # 46 "/usr/include/ctype.h" 3 4
> >>> enum
> >>> {
> >>>   _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
> >>>   _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
> >>>   _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
> >>>   _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
> >>>   _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
> >>>   _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
> >>>   _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
> >>>   _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
> >>>   _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
> >>>   _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
> >>>   _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
> >>>   _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
> >>> };
> >>> # 79 "/usr/include/ctype.h" 3 4
> >>> extern const unsigned short int **__ctype_b_loc (void)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> extern const __int32_t **__ctype_tolower_loc (void)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> extern const __int32_t **__ctype_toupper_loc (void)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> # 104 "/usr/include/ctype.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int isalnum (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int isalpha (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int iscntrl (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int isdigit (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int islower (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int isgraph (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int isprint (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int ispunct (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int isspace (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int isupper (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int isxdigit (int) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern int tolower (int __c) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int toupper (int __c) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int isblank (int) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> # 150 "/usr/include/ctype.h" 3 4
> >>> extern int isascii (int __c) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern int toascii (int __c) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern int _toupper (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern int _tolower (int) __attribute__ ((__nothrow__ , __leaf__));
> >>> # 257 "/usr/include/ctype.h" 3 4
> >>> # 1 "/usr/include/xlocale.h" 1 3 4
> >>> # 27 "/usr/include/xlocale.h" 3 4
> >>> typedef struct __locale_struct
> >>> {
> >>>
> >>>   struct __locale_data *__locales[13];
> >>>
> >>>
> >>>   const unsigned short int *__ctype_b;
> >>>   const int *__ctype_tolower;
> >>>   const int *__ctype_toupper;
> >>>
> >>>
> >>>   const char *__names[13];
> >>> } *__locale_t;
> >>>
> >>>
> >>> typedef __locale_t locale_t;
> >>> # 258 "/usr/include/ctype.h" 2 3 4
> >>> # 271 "/usr/include/ctype.h" 3 4
> >>> extern int isalnum_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int isalpha_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int iscntrl_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int isdigit_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int islower_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int isgraph_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int isprint_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int ispunct_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int isspace_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int isupper_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern int isxdigit_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern int isblank_l (int, __locale_t) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern int __tolower_l (int __c, __locale_t __l) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> extern int tolower_l (int __c, __locale_t __l) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int __toupper_l (int __c, __locale_t __l) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> extern int toupper_l (int __c, __locale_t __l) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> # 347 "/usr/include/ctype.h" 3 4
> >>>
> >>> # 45 "machine.c" 2
> >>> # 1 "/usr/include/string.h" 1 3 4
> >>> # 27 "/usr/include/string.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 33 "/usr/include/string.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *memcpy (void *__restrict __dest, const void *__restrict 
> >>> __src,
> >>>        size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>> extern void *memmove (void *__dest, const void *__src, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *memccpy (void *__restrict __dest, const void *__restrict 
> >>> __src,
> >>>         int __c, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *memset (void *__s, int __c, size_t __n) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> extern int memcmp (const void *__s1, const void *__s2, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>> # 92 "/usr/include/string.h" 3 4
> >>> extern void *memchr (const void *__s, int __c, size_t __n)
> >>>       __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> # 123 "/usr/include/string.h" 3 4
> >>>
> >>>
> >>> extern char *strcpy (char *__restrict __dest, const char *__restrict 
> >>> __src)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>> extern char *strncpy (char *__restrict __dest,
> >>>         const char *__restrict __src, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>> extern char *strcat (char *__restrict __dest, const char *__restrict 
> >>> __src)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>> extern char *strncat (char *__restrict __dest, const char *__restrict 
> >>> __src,
> >>>         size_t __n) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>> extern int strcmp (const char *__s1, const char *__s2)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>> extern int strncmp (const char *__s1, const char *__s2, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>> extern int strcoll (const char *__s1, const char *__s2)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>> extern size_t strxfrm (char *__restrict __dest,
> >>>          const char *__restrict __src, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>> # 162 "/usr/include/string.h" 3 4
> >>> extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2, 3)));
> >>>
> >>> extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
> >>>     __locale_t __l) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (2, 4)));
> >>>
> >>>
> >>>
> >>>
> >>> extern char *strdup (const char *__s)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__malloc__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *strndup (const char *__string, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__malloc__)) __attribute__ ((__nonnull__ (1)));
> >>> # 206 "/usr/include/string.h" 3 4
> >>>
> >>> # 231 "/usr/include/string.h" 3 4
> >>> extern char *strchr (const char *__s, int __c)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>> # 258 "/usr/include/string.h" 3 4
> >>> extern char *strrchr (const char *__s, int __c)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> # 277 "/usr/include/string.h" 3 4
> >>>
> >>>
> >>>
> >>> extern size_t strcspn (const char *__s, const char *__reject)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>> extern size_t strspn (const char *__s, const char *__accept)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>> # 310 "/usr/include/string.h" 3 4
> >>> extern char *strpbrk (const char *__s, const char *__accept)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>> # 337 "/usr/include/string.h" 3 4
> >>> extern char *strstr (const char *__haystack, const char *__needle)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>> extern char *strtok (char *__restrict __s, const char *__restrict __delim)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>>
> >>>
> >>>
> >>> extern char *__strtok_r (char *__restrict __s,
> >>>     const char *__restrict __delim,
> >>>     char **__restrict __save_ptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2, 3)));
> >>>
> >>> extern char *strtok_r (char *__restrict __s, const char *__restrict 
> >>> __delim,
> >>>          char **__restrict __save_ptr)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2, 3)));
> >>> # 392 "/usr/include/string.h" 3 4
> >>>
> >>>
> >>> extern size_t strlen (const char *__s)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern size_t strnlen (const char *__string, size_t __maxlen)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *strerror (int __errnum) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> # 422 "/usr/include/string.h" 3 4
> >>> extern int strerror_r (int __errnum, char *__buf, size_t __buflen) 
> >>> __asm__ ("" "__xpg_strerror_r") __attribute__ ((__nothrow__ , __leaf__))
> >>>
> >>>                         __attribute__ ((__nonnull__ (2)));
> >>> # 440 "/usr/include/string.h" 3 4
> >>> extern char *strerror_l (int __errnum, __locale_t __l) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>> extern void bcopy (const void *__src, void *__dest, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>> extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>> extern int bcmp (const void *__s1, const void *__s2, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>> # 484 "/usr/include/string.h" 3 4
> >>> extern char *index (const char *__s, int __c)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>> # 512 "/usr/include/string.h" 3 4
> >>> extern char *rindex (const char *__s, int __c)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int ffs (int __i) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__const__));
> >>> # 529 "/usr/include/string.h" 3 4
> >>> extern int strcasecmp (const char *__s1, const char *__s2)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>> extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>> # 552 "/usr/include/string.h" 3 4
> >>> extern char *strsep (char **__restrict __stringp,
> >>>        const char *__restrict __delim)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>> extern char *strsignal (int __sig) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern char *__stpcpy (char *__restrict __dest, const char *__restrict 
> >>> __src)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>> extern char *stpcpy (char *__restrict __dest, const char *__restrict 
> >>> __src)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>> extern char *__stpncpy (char *__restrict __dest,
> >>>    const char *__restrict __src, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>> extern char *stpncpy (char *__restrict __dest,
> >>>         const char *__restrict __src, size_t __n)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>> # 658 "/usr/include/string.h" 3 4
> >>>
> >>> # 46 "machine.c" 2
> >>> # 1 "/usr/include/time.h" 1 3 4
> >>> # 29 "/usr/include/time.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 38 "/usr/include/time.h" 2 3 4
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/time.h" 1 3 4
> >>> # 42 "/usr/include/time.h" 2 3 4
> >>> # 131 "/usr/include/time.h" 3 4
> >>>
> >>>
> >>> struct tm
> >>> {
> >>>   int tm_sec;
> >>>   int tm_min;
> >>>   int tm_hour;
> >>>   int tm_mday;
> >>>   int tm_mon;
> >>>   int tm_year;
> >>>   int tm_wday;
> >>>   int tm_yday;
> >>>   int tm_isdst;
> >>>
> >>>
> >>>   long int tm_gmtoff;
> >>>   const char *tm_zone;
> >>>
> >>>
> >>>
> >>>
> >>> };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct itimerspec
> >>>   {
> >>>     struct timespec it_interval;
> >>>     struct timespec it_value;
> >>>   };
> >>>
> >>>
> >>> struct sigevent;
> >>> # 186 "/usr/include/time.h" 3 4
> >>>
> >>>
> >>>
> >>> extern clock_t clock (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern time_t time (time_t *__timer) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern double difftime (time_t __time1, time_t __time0)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>>
> >>>
> >>> extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern size_t strftime (char *__restrict __s, size_t __maxsize,
> >>>    const char *__restrict __format,
> >>>    const struct tm *__restrict __tp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> # 223 "/usr/include/time.h" 3 4
> >>> extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
> >>>      const char *__restrict __format,
> >>>      const struct tm *__restrict __tp,
> >>>      __locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
> >>> # 236 "/usr/include/time.h" 3 4
> >>>
> >>>
> >>>
> >>> extern struct tm *gmtime (const time_t *__timer) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern struct tm *localtime (const time_t *__timer) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct tm *gmtime_r (const time_t *__restrict __timer,
> >>>        struct tm *__restrict __tp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern struct tm *localtime_r (const time_t *__restrict __timer,
> >>>           struct tm *__restrict __tp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>> extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *asctime_r (const struct tm *__restrict __tp,
> >>>    char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern char *ctime_r (const time_t *__restrict __timer,
> >>>         char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern char *__tzname[2];
> >>> extern int __daylight;
> >>> extern long int __timezone;
> >>>
> >>>
> >>>
> >>>
> >>> extern char *tzname[2];
> >>>
> >>>
> >>>
> >>> extern void tzset (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern int daylight;
> >>> extern long int timezone;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int stime (const time_t *__when) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 319 "/usr/include/time.h" 3 4
> >>> extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern int dysize (int __year) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__const__));
> >>> # 334 "/usr/include/time.h" 3 4
> >>> extern int nanosleep (const struct timespec *__requested_time,
> >>>         struct timespec *__remaining);
> >>>
> >>>
> >>>
> >>> extern int clock_getres (clockid_t __clock_id, struct timespec *__res) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int clock_settime (clockid_t __clock_id, const struct timespec 
> >>> *__tp)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int clock_nanosleep (clockid_t __clock_id, int __flags,
> >>>        const struct timespec *__req,
> >>>        struct timespec *__rem);
> >>>
> >>>
> >>> extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int timer_create (clockid_t __clock_id,
> >>>     struct sigevent *__restrict __evp,
> >>>     timer_t *__restrict __timerid) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern int timer_settime (timer_t __timerid, int __flags,
> >>>      const struct itimerspec *__restrict __value,
> >>>      struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>> extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int timer_getoverrun (timer_t __timerid) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int timespec_get (struct timespec *__ts, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>> # 430 "/usr/include/time.h" 3 4
> >>>
> >>> # 47 "machine.c" 2
> >>>
> >>> # 1 "/usr/include/sys/stat.h" 1 3 4
> >>> # 102 "/usr/include/sys/stat.h" 3 4
> >>>
> >>>
> >>> # 1 "/usr/include/bits/stat.h" 1 3 4
> >>> # 105 "/usr/include/sys/stat.h" 2 3 4
> >>> # 208 "/usr/include/sys/stat.h" 3 4
> >>> extern int stat (const char *__restrict __file,
> >>>    struct stat *__restrict __buf) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>>
> >>> extern int fstat (int __fd, struct stat *__buf) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
> >>> # 237 "/usr/include/sys/stat.h" 3 4
> >>> extern int fstatat (int __fd, const char *__restrict __file,
> >>>       struct stat *__restrict __buf, int __flag)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2, 3)));
> >>> # 262 "/usr/include/sys/stat.h" 3 4
> >>> extern int lstat (const char *__restrict __file,
> >>>     struct stat *__restrict __buf) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
> >>> # 283 "/usr/include/sys/stat.h" 3 4
> >>> extern int chmod (const char *__file, __mode_t __mode)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int lchmod (const char *__file, __mode_t __mode)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int fchmod (int __fd, __mode_t __mode) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
> >>>        int __flag)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern __mode_t umask (__mode_t __mask) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 320 "/usr/include/sys/stat.h" 3 4
> >>> extern int mkdir (const char *__path, __mode_t __mode)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int mknodat (int __fd, const char *__path, __mode_t __mode,
> >>>       __dev_t __dev) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int mkfifo (const char *__path, __mode_t __mode)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int utimensat (int __fd, const char *__path,
> >>>         const struct timespec __times[2],
> >>>         int __flags)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int futimens (int __fd, const struct timespec __times[2]) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>> # 398 "/usr/include/sys/stat.h" 3 4
> >>> extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3)));
> >>> extern int __xstat (int __ver, const char *__filename,
> >>>       struct stat *__stat_buf) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (2, 3)));
> >>> extern int __lxstat (int __ver, const char *__filename,
> >>>        struct stat *__stat_buf) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (2, 3)));
> >>> extern int __fxstatat (int __ver, int __fildes, const char *__filename,
> >>>          struct stat *__stat_buf, int __flag)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3, 4)));
> >>> # 441 "/usr/include/sys/stat.h" 3 4
> >>> extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
> >>>        __dev_t *__dev) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (2, 4)));
> >>>
> >>> extern int __xmknodat (int __ver, int __fd, const char *__path,
> >>>          __mode_t __mode, __dev_t *__dev)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (3, 5)));
> >>> # 533 "/usr/include/sys/stat.h" 3 4
> >>>
> >>> # 49 "machine.c" 2
> >>>
> >>> # 1 "gp_config.h" 1
> >>> # 327 "gp_config.h"
> >>> # 1 "arch_dep.h" 1
> >>> # 328 "gp_config.h" 2
> >>> # 1 "pl_long.h" 1
> >>> # 41 "pl_long.h"
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stdint.h" 1 3 4
> >>> # 9 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stdint.h" 3 4
> >>> # 1 "/usr/include/stdint.h" 1 3 4
> >>> # 26 "/usr/include/stdint.h" 3 4
> >>> # 1 "/usr/include/bits/wchar.h" 1 3 4
> >>> # 27 "/usr/include/stdint.h" 2 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 28 "/usr/include/stdint.h" 2 3 4
> >>> # 48 "/usr/include/stdint.h" 3 4
> >>> typedef unsigned char uint8_t;
> >>> typedef unsigned short int uint16_t;
> >>>
> >>> typedef unsigned int uint32_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> __extension__
> >>> typedef unsigned long long int uint64_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef signed char int_least8_t;
> >>> typedef short int int_least16_t;
> >>> typedef int int_least32_t;
> >>>
> >>>
> >>>
> >>> __extension__
> >>> typedef long long int int_least64_t;
> >>>
> >>>
> >>>
> >>> typedef unsigned char uint_least8_t;
> >>> typedef unsigned short int uint_least16_t;
> >>> typedef unsigned int uint_least32_t;
> >>>
> >>>
> >>>
> >>> __extension__
> >>> typedef unsigned long long int uint_least64_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef signed char int_fast8_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef int int_fast16_t;
> >>> typedef int int_fast32_t;
> >>> __extension__
> >>> typedef long long int int_fast64_t;
> >>>
> >>>
> >>>
> >>> typedef unsigned char uint_fast8_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef unsigned int uint_fast16_t;
> >>> typedef unsigned int uint_fast32_t;
> >>> __extension__
> >>> typedef unsigned long long int uint_fast64_t;
> >>> # 125 "/usr/include/stdint.h" 3 4
> >>> typedef int intptr_t;
> >>>
> >>>
> >>> typedef unsigned int uintptr_t;
> >>> # 137 "/usr/include/stdint.h" 3 4
> >>> __extension__
> >>> typedef long long int intmax_t;
> >>> __extension__
> >>> typedef unsigned long long int uintmax_t;
> >>> # 10 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stdint.h" 2 3 4
> >>> # 42 "pl_long.h" 2
> >>>
> >>> # 1 "gp_config.h" 1
> >>> # 44 "pl_long.h" 2
> >>>
> >>>
> >>>
> >>>
> >>> # 47 "pl_long.h"
> >>> typedef intptr_t PlLong;
> >>> typedef uintptr_t PlULong;
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/inttypes.h" 1 3 4
> >>> # 34 "/usr/include/inttypes.h" 3 4
> >>>
> >>> # 34 "/usr/include/inttypes.h" 3 4
> >>> typedef long int __gwchar_t;
> >>> # 266 "/usr/include/inttypes.h" 3 4
> >>>
> >>> # 280 "/usr/include/inttypes.h" 3 4
> >>> typedef struct
> >>>   {
> >>>     __extension__ long long int quot;
> >>>     __extension__ long long int rem;
> >>>   } imaxdiv_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern intmax_t imaxabs (intmax_t __n) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__const__));
> >>>
> >>>
> >>> extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
> >>>       __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__const__));
> >>>
> >>>
> >>> extern intmax_t strtoimax (const char *__restrict __nptr,
> >>>       char **__restrict __endptr, int __base) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>> extern uintmax_t strtoumax (const char *__restrict __nptr,
> >>>        char ** __restrict __endptr, int __base) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern intmax_t wcstoimax (const __gwchar_t *__restrict __nptr,
> >>>       __gwchar_t **__restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern uintmax_t wcstoumax (const __gwchar_t *__restrict __nptr,
> >>>        __gwchar_t ** __restrict __endptr, int __base)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>> # 432 "/usr/include/inttypes.h" 3 4
> >>>
> >>> # 53 "pl_long.h" 2
> >>> # 329 "gp_config.h" 2
> >>> # 51 "machine.c" 2
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/pwd.h" 1 3 4
> >>> # 27 "/usr/include/pwd.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 33 "/usr/include/pwd.h" 2 3 4
> >>> # 49 "/usr/include/pwd.h" 3 4
> >>> struct passwd
> >>> {
> >>>   char *pw_name;
> >>>   char *pw_passwd;
> >>>   __uid_t pw_uid;
> >>>   __gid_t pw_gid;
> >>>   char *pw_gecos;
> >>>   char *pw_dir;
> >>>   char *pw_shell;
> >>> };
> >>> # 72 "/usr/include/pwd.h" 3 4
> >>> extern void setpwent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void endpwent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct passwd *getpwent (void);
> >>> # 94 "/usr/include/pwd.h" 3 4
> >>> extern struct passwd *fgetpwent (FILE *__stream) __attribute__ 
> >>> ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int putpwent (const struct passwd *__restrict __p,
> >>>        FILE *__restrict __f);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct passwd *getpwuid (__uid_t __uid);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct passwd *getpwnam (const char *__name) __attribute__ 
> >>> ((__nonnull__ (1)));
> >>> # 139 "/usr/include/pwd.h" 3 4
> >>> extern int getpwent_r (struct passwd *__restrict __resultbuf,
> >>>          char *__restrict __buffer, size_t __buflen,
> >>>          struct passwd **__restrict __result)
> >>>          __attribute__ ((__nonnull__ (1, 2, 4)));
> >>>
> >>>
> >>> extern int getpwuid_r (__uid_t __uid,
> >>>          struct passwd *__restrict __resultbuf,
> >>>          char *__restrict __buffer, size_t __buflen,
> >>>          struct passwd **__restrict __result)
> >>>          __attribute__ ((__nonnull__ (2, 3, 5)));
> >>>
> >>> extern int getpwnam_r (const char *__restrict __name,
> >>>          struct passwd *__restrict __resultbuf,
> >>>          char *__restrict __buffer, size_t __buflen,
> >>>          struct passwd **__restrict __result)
> >>>          __attribute__ ((__nonnull__ (1, 2, 3, 5)));
> >>> # 166 "/usr/include/pwd.h" 3 4
> >>> extern int fgetpwent_r (FILE *__restrict __stream,
> >>>    struct passwd *__restrict __resultbuf,
> >>>    char *__restrict __buffer, size_t __buflen,
> >>>    struct passwd **__restrict __result)
> >>>    __attribute__ ((__nonnull__ (1, 2, 3, 5)));
> >>> # 187 "/usr/include/pwd.h" 3 4
> >>>
> >>> # 58 "machine.c" 2
> >>> # 1 "/usr/include/unistd.h" 1 3 4
> >>> # 27 "/usr/include/unistd.h" 3 4
> >>>
> >>> # 205 "/usr/include/unistd.h" 3 4
> >>> # 1 "/usr/include/bits/posix_opt.h" 1 3 4
> >>> # 206 "/usr/include/unistd.h" 2 3 4
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/environments.h" 1 3 4
> >>> # 22 "/usr/include/bits/environments.h" 3 4
> >>> # 1 "/usr/include/bits/wordsize.h" 1 3 4
> >>> # 23 "/usr/include/bits/environments.h" 2 3 4
> >>> # 210 "/usr/include/unistd.h" 2 3 4
> >>> # 229 "/usr/include/unistd.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 230 "/usr/include/unistd.h" 2 3 4
> >>> # 258 "/usr/include/unistd.h" 3 4
> >>> typedef __useconds_t useconds_t;
> >>> # 277 "/usr/include/unistd.h" 3 4
> >>> typedef __socklen_t socklen_t;
> >>> # 290 "/usr/include/unistd.h" 3 4
> >>> extern int access (const char *__name, int __type) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>> # 307 "/usr/include/unistd.h" 3 4
> >>> extern int faccessat (int __fd, const char *__file, int __type, int 
> >>> __flag)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2))) ;
> >>> # 337 "/usr/include/unistd.h" 3 4
> >>> extern __off_t lseek (int __fd, __off_t __offset, int __whence) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>> # 356 "/usr/include/unistd.h" 3 4
> >>> extern int close (int __fd);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
> >>> # 379 "/usr/include/unistd.h" 3 4
> >>> extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
> >>>         __off_t __offset) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
> >>>          __off_t __offset) ;
> >>> # 420 "/usr/include/unistd.h" 3 4
> >>> extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>> # 435 "/usr/include/unistd.h" 3 4
> >>> extern unsigned int alarm (unsigned int __seconds) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> # 447 "/usr/include/unistd.h" 3 4
> >>> extern unsigned int sleep (unsigned int __seconds);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int usleep (__useconds_t __useconds);
> >>> # 472 "/usr/include/unistd.h" 3 4
> >>> extern int pause (void);
> >>>
> >>>
> >>>
> >>> extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) ;
> >>>
> >>>
> >>>
> >>> extern int fchown (int __fd, __uid_t __owner, __gid_t __group) 
> >>> __attribute__ ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fchownat (int __fd, const char *__file, __uid_t __owner,
> >>>        __gid_t __group, int __flag)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2))) ;
> >>>
> >>>
> >>>
> >>> extern int chdir (const char *__path) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>>
> >>>
> >>> extern int fchdir (int __fd) __attribute__ ((__nothrow__ , __leaf__)) ;
> >>> # 514 "/usr/include/unistd.h" 3 4
> >>> extern char *getcwd (char *__buf, size_t __size) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) ;
> >>> # 528 "/usr/include/unistd.h" 3 4
> >>> extern char *getwd (char *__buf)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) __attribute__ ((__deprecated__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int dup (int __fd) __attribute__ ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>> extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 546 "/usr/include/unistd.h" 3 4
> >>> extern char **__environ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int execve (const char *__path, char *const __argv[],
> >>>      char *const __envp[]) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int execv (const char *__path, char *const __argv[])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>> extern int execle (const char *__path, const char *__arg, ...)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>> extern int execl (const char *__path, const char *__arg, ...)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>> extern int execvp (const char *__file, char *const __argv[])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int execlp (const char *__file, const char *__arg, ...)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2)));
> >>> # 601 "/usr/include/unistd.h" 3 4
> >>> extern int nice (int __inc) __attribute__ ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern void _exit (int __status) __attribute__ ((__noreturn__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/confname.h" 1 3 4
> >>> # 24 "/usr/include/bits/confname.h" 3 4
> >>> enum
> >>>   {
> >>>     _PC_LINK_MAX,
> >>>
> >>>     _PC_MAX_CANON,
> >>>
> >>>     _PC_MAX_INPUT,
> >>>
> >>>     _PC_NAME_MAX,
> >>>
> >>>     _PC_PATH_MAX,
> >>>
> >>>     _PC_PIPE_BUF,
> >>>
> >>>     _PC_CHOWN_RESTRICTED,
> >>>
> >>>     _PC_NO_TRUNC,
> >>>
> >>>     _PC_VDISABLE,
> >>>
> >>>     _PC_SYNC_IO,
> >>>
> >>>     _PC_ASYNC_IO,
> >>>
> >>>     _PC_PRIO_IO,
> >>>
> >>>     _PC_SOCK_MAXBUF,
> >>>
> >>>     _PC_FILESIZEBITS,
> >>>
> >>>     _PC_REC_INCR_XFER_SIZE,
> >>>
> >>>     _PC_REC_MAX_XFER_SIZE,
> >>>
> >>>     _PC_REC_MIN_XFER_SIZE,
> >>>
> >>>     _PC_REC_XFER_ALIGN,
> >>>
> >>>     _PC_ALLOC_SIZE_MIN,
> >>>
> >>>     _PC_SYMLINK_MAX,
> >>>
> >>>     _PC_2_SYMLINKS
> >>>
> >>>   };
> >>>
> >>>
> >>> enum
> >>>   {
> >>>     _SC_ARG_MAX,
> >>>
> >>>     _SC_CHILD_MAX,
> >>>
> >>>     _SC_CLK_TCK,
> >>>
> >>>     _SC_NGROUPS_MAX,
> >>>
> >>>     _SC_OPEN_MAX,
> >>>
> >>>     _SC_STREAM_MAX,
> >>>
> >>>     _SC_TZNAME_MAX,
> >>>
> >>>     _SC_JOB_CONTROL,
> >>>
> >>>     _SC_SAVED_IDS,
> >>>
> >>>     _SC_REALTIME_SIGNALS,
> >>>
> >>>     _SC_PRIORITY_SCHEDULING,
> >>>
> >>>     _SC_TIMERS,
> >>>
> >>>     _SC_ASYNCHRONOUS_IO,
> >>>
> >>>     _SC_PRIORITIZED_IO,
> >>>
> >>>     _SC_SYNCHRONIZED_IO,
> >>>
> >>>     _SC_FSYNC,
> >>>
> >>>     _SC_MAPPED_FILES,
> >>>
> >>>     _SC_MEMLOCK,
> >>>
> >>>     _SC_MEMLOCK_RANGE,
> >>>
> >>>     _SC_MEMORY_PROTECTION,
> >>>
> >>>     _SC_MESSAGE_PASSING,
> >>>
> >>>     _SC_SEMAPHORES,
> >>>
> >>>     _SC_SHARED_MEMORY_OBJECTS,
> >>>
> >>>     _SC_AIO_LISTIO_MAX,
> >>>
> >>>     _SC_AIO_MAX,
> >>>
> >>>     _SC_AIO_PRIO_DELTA_MAX,
> >>>
> >>>     _SC_DELAYTIMER_MAX,
> >>>
> >>>     _SC_MQ_OPEN_MAX,
> >>>
> >>>     _SC_MQ_PRIO_MAX,
> >>>
> >>>     _SC_VERSION,
> >>>
> >>>     _SC_PAGESIZE,
> >>>
> >>>
> >>>     _SC_RTSIG_MAX,
> >>>
> >>>     _SC_SEM_NSEMS_MAX,
> >>>
> >>>     _SC_SEM_VALUE_MAX,
> >>>
> >>>     _SC_SIGQUEUE_MAX,
> >>>
> >>>     _SC_TIMER_MAX,
> >>>
> >>>
> >>>
> >>>
> >>>     _SC_BC_BASE_MAX,
> >>>
> >>>     _SC_BC_DIM_MAX,
> >>>
> >>>     _SC_BC_SCALE_MAX,
> >>>
> >>>     _SC_BC_STRING_MAX,
> >>>
> >>>     _SC_COLL_WEIGHTS_MAX,
> >>>
> >>>     _SC_EQUIV_CLASS_MAX,
> >>>
> >>>     _SC_EXPR_NEST_MAX,
> >>>
> >>>     _SC_LINE_MAX,
> >>>
> >>>     _SC_RE_DUP_MAX,
> >>>
> >>>     _SC_CHARCLASS_NAME_MAX,
> >>>
> >>>
> >>>     _SC_2_VERSION,
> >>>
> >>>     _SC_2_C_BIND,
> >>>
> >>>     _SC_2_C_DEV,
> >>>
> >>>     _SC_2_FORT_DEV,
> >>>
> >>>     _SC_2_FORT_RUN,
> >>>
> >>>     _SC_2_SW_DEV,
> >>>
> >>>     _SC_2_LOCALEDEF,
> >>>
> >>>
> >>>     _SC_PII,
> >>>
> >>>     _SC_PII_XTI,
> >>>
> >>>     _SC_PII_SOCKET,
> >>>
> >>>     _SC_PII_INTERNET,
> >>>
> >>>     _SC_PII_OSI,
> >>>
> >>>     _SC_POLL,
> >>>
> >>>     _SC_SELECT,
> >>>
> >>>     _SC_UIO_MAXIOV,
> >>>
> >>>     _SC_IOV_MAX = _SC_UIO_MAXIOV,
> >>>
> >>>     _SC_PII_INTERNET_STREAM,
> >>>
> >>>     _SC_PII_INTERNET_DGRAM,
> >>>
> >>>     _SC_PII_OSI_COTS,
> >>>
> >>>     _SC_PII_OSI_CLTS,
> >>>
> >>>     _SC_PII_OSI_M,
> >>>
> >>>     _SC_T_IOV_MAX,
> >>>
> >>>
> >>>
> >>>     _SC_THREADS,
> >>>
> >>>     _SC_THREAD_SAFE_FUNCTIONS,
> >>>
> >>>     _SC_GETGR_R_SIZE_MAX,
> >>>
> >>>     _SC_GETPW_R_SIZE_MAX,
> >>>
> >>>     _SC_LOGIN_NAME_MAX,
> >>>
> >>>     _SC_TTY_NAME_MAX,
> >>>
> >>>     _SC_THREAD_DESTRUCTOR_ITERATIONS,
> >>>
> >>>     _SC_THREAD_KEYS_MAX,
> >>>
> >>>     _SC_THREAD_STACK_MIN,
> >>>
> >>>     _SC_THREAD_THREADS_MAX,
> >>>
> >>>     _SC_THREAD_ATTR_STACKADDR,
> >>>
> >>>     _SC_THREAD_ATTR_STACKSIZE,
> >>>
> >>>     _SC_THREAD_PRIORITY_SCHEDULING,
> >>>
> >>>     _SC_THREAD_PRIO_INHERIT,
> >>>
> >>>     _SC_THREAD_PRIO_PROTECT,
> >>>
> >>>     _SC_THREAD_PROCESS_SHARED,
> >>>
> >>>
> >>>     _SC_NPROCESSORS_CONF,
> >>>
> >>>     _SC_NPROCESSORS_ONLN,
> >>>
> >>>     _SC_PHYS_PAGES,
> >>>
> >>>     _SC_AVPHYS_PAGES,
> >>>
> >>>     _SC_ATEXIT_MAX,
> >>>
> >>>     _SC_PASS_MAX,
> >>>
> >>>
> >>>     _SC_XOPEN_VERSION,
> >>>
> >>>     _SC_XOPEN_XCU_VERSION,
> >>>
> >>>     _SC_XOPEN_UNIX,
> >>>
> >>>     _SC_XOPEN_CRYPT,
> >>>
> >>>     _SC_XOPEN_ENH_I18N,
> >>>
> >>>     _SC_XOPEN_SHM,
> >>>
> >>>
> >>>     _SC_2_CHAR_TERM,
> >>>
> >>>     _SC_2_C_VERSION,
> >>>
> >>>     _SC_2_UPE,
> >>>
> >>>
> >>>     _SC_XOPEN_XPG2,
> >>>
> >>>     _SC_XOPEN_XPG3,
> >>>
> >>>     _SC_XOPEN_XPG4,
> >>>
> >>>
> >>>     _SC_CHAR_BIT,
> >>>
> >>>     _SC_CHAR_MAX,
> >>>
> >>>     _SC_CHAR_MIN,
> >>>
> >>>     _SC_INT_MAX,
> >>>
> >>>     _SC_INT_MIN,
> >>>
> >>>     _SC_LONG_BIT,
> >>>
> >>>     _SC_WORD_BIT,
> >>>
> >>>     _SC_MB_LEN_MAX,
> >>>
> >>>     _SC_NZERO,
> >>>
> >>>     _SC_SSIZE_MAX,
> >>>
> >>>     _SC_SCHAR_MAX,
> >>>
> >>>     _SC_SCHAR_MIN,
> >>>
> >>>     _SC_SHRT_MAX,
> >>>
> >>>     _SC_SHRT_MIN,
> >>>
> >>>     _SC_UCHAR_MAX,
> >>>
> >>>     _SC_UINT_MAX,
> >>>
> >>>     _SC_ULONG_MAX,
> >>>
> >>>     _SC_USHRT_MAX,
> >>>
> >>>
> >>>     _SC_NL_ARGMAX,
> >>>
> >>>     _SC_NL_LANGMAX,
> >>>
> >>>     _SC_NL_MSGMAX,
> >>>
> >>>     _SC_NL_NMAX,
> >>>
> >>>     _SC_NL_SETMAX,
> >>>
> >>>     _SC_NL_TEXTMAX,
> >>>
> >>>
> >>>     _SC_XBS5_ILP32_OFF32,
> >>>
> >>>     _SC_XBS5_ILP32_OFFBIG,
> >>>
> >>>     _SC_XBS5_LP64_OFF64,
> >>>
> >>>     _SC_XBS5_LPBIG_OFFBIG,
> >>>
> >>>
> >>>     _SC_XOPEN_LEGACY,
> >>>
> >>>     _SC_XOPEN_REALTIME,
> >>>
> >>>     _SC_XOPEN_REALTIME_THREADS,
> >>>
> >>>
> >>>     _SC_ADVISORY_INFO,
> >>>
> >>>     _SC_BARRIERS,
> >>>
> >>>     _SC_BASE,
> >>>
> >>>     _SC_C_LANG_SUPPORT,
> >>>
> >>>     _SC_C_LANG_SUPPORT_R,
> >>>
> >>>     _SC_CLOCK_SELECTION,
> >>>
> >>>     _SC_CPUTIME,
> >>>
> >>>     _SC_THREAD_CPUTIME,
> >>>
> >>>     _SC_DEVICE_IO,
> >>>
> >>>     _SC_DEVICE_SPECIFIC,
> >>>
> >>>     _SC_DEVICE_SPECIFIC_R,
> >>>
> >>>     _SC_FD_MGMT,
> >>>
> >>>     _SC_FIFO,
> >>>
> >>>     _SC_PIPE,
> >>>
> >>>     _SC_FILE_ATTRIBUTES,
> >>>
> >>>     _SC_FILE_LOCKING,
> >>>
> >>>     _SC_FILE_SYSTEM,
> >>>
> >>>     _SC_MONOTONIC_CLOCK,
> >>>
> >>>     _SC_MULTI_PROCESS,
> >>>
> >>>     _SC_SINGLE_PROCESS,
> >>>
> >>>     _SC_NETWORKING,
> >>>
> >>>     _SC_READER_WRITER_LOCKS,
> >>>
> >>>     _SC_SPIN_LOCKS,
> >>>
> >>>     _SC_REGEXP,
> >>>
> >>>     _SC_REGEX_VERSION,
> >>>
> >>>     _SC_SHELL,
> >>>
> >>>     _SC_SIGNALS,
> >>>
> >>>     _SC_SPAWN,
> >>>
> >>>     _SC_SPORADIC_SERVER,
> >>>
> >>>     _SC_THREAD_SPORADIC_SERVER,
> >>>
> >>>     _SC_SYSTEM_DATABASE,
> >>>
> >>>     _SC_SYSTEM_DATABASE_R,
> >>>
> >>>     _SC_TIMEOUTS,
> >>>
> >>>     _SC_TYPED_MEMORY_OBJECTS,
> >>>
> >>>     _SC_USER_GROUPS,
> >>>
> >>>     _SC_USER_GROUPS_R,
> >>>
> >>>     _SC_2_PBS,
> >>>
> >>>     _SC_2_PBS_ACCOUNTING,
> >>>
> >>>     _SC_2_PBS_LOCATE,
> >>>
> >>>     _SC_2_PBS_MESSAGE,
> >>>
> >>>     _SC_2_PBS_TRACK,
> >>>
> >>>     _SC_SYMLOOP_MAX,
> >>>
> >>>     _SC_STREAMS,
> >>>
> >>>     _SC_2_PBS_CHECKPOINT,
> >>>
> >>>
> >>>     _SC_V6_ILP32_OFF32,
> >>>
> >>>     _SC_V6_ILP32_OFFBIG,
> >>>
> >>>     _SC_V6_LP64_OFF64,
> >>>
> >>>     _SC_V6_LPBIG_OFFBIG,
> >>>
> >>>
> >>>     _SC_HOST_NAME_MAX,
> >>>
> >>>     _SC_TRACE,
> >>>
> >>>     _SC_TRACE_EVENT_FILTER,
> >>>
> >>>     _SC_TRACE_INHERIT,
> >>>
> >>>     _SC_TRACE_LOG,
> >>>
> >>>
> >>>     _SC_LEVEL1_ICACHE_SIZE,
> >>>
> >>>     _SC_LEVEL1_ICACHE_ASSOC,
> >>>
> >>>     _SC_LEVEL1_ICACHE_LINESIZE,
> >>>
> >>>     _SC_LEVEL1_DCACHE_SIZE,
> >>>
> >>>     _SC_LEVEL1_DCACHE_ASSOC,
> >>>
> >>>     _SC_LEVEL1_DCACHE_LINESIZE,
> >>>
> >>>     _SC_LEVEL2_CACHE_SIZE,
> >>>
> >>>     _SC_LEVEL2_CACHE_ASSOC,
> >>>
> >>>     _SC_LEVEL2_CACHE_LINESIZE,
> >>>
> >>>     _SC_LEVEL3_CACHE_SIZE,
> >>>
> >>>     _SC_LEVEL3_CACHE_ASSOC,
> >>>
> >>>     _SC_LEVEL3_CACHE_LINESIZE,
> >>>
> >>>     _SC_LEVEL4_CACHE_SIZE,
> >>>
> >>>     _SC_LEVEL4_CACHE_ASSOC,
> >>>
> >>>     _SC_LEVEL4_CACHE_LINESIZE,
> >>>
> >>>
> >>>
> >>>     _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
> >>>
> >>>     _SC_RAW_SOCKETS,
> >>>
> >>>
> >>>     _SC_V7_ILP32_OFF32,
> >>>
> >>>     _SC_V7_ILP32_OFFBIG,
> >>>
> >>>     _SC_V7_LP64_OFF64,
> >>>
> >>>     _SC_V7_LPBIG_OFFBIG,
> >>>
> >>>
> >>>     _SC_SS_REPL_MAX,
> >>>
> >>>
> >>>     _SC_TRACE_EVENT_NAME_MAX,
> >>>
> >>>     _SC_TRACE_NAME_MAX,
> >>>
> >>>     _SC_TRACE_SYS_MAX,
> >>>
> >>>     _SC_TRACE_USER_EVENT_MAX,
> >>>
> >>>
> >>>     _SC_XOPEN_STREAMS,
> >>>
> >>>
> >>>     _SC_THREAD_ROBUST_PRIO_INHERIT,
> >>>
> >>>     _SC_THREAD_ROBUST_PRIO_PROTECT
> >>>
> >>>   };
> >>>
> >>>
> >>> enum
> >>>   {
> >>>     _CS_PATH,
> >>>
> >>>
> >>>     _CS_V6_WIDTH_RESTRICTED_ENVS,
> >>>
> >>>
> >>>
> >>>     _CS_GNU_LIBC_VERSION,
> >>>
> >>>     _CS_GNU_LIBPTHREAD_VERSION,
> >>>
> >>>
> >>>     _CS_V5_WIDTH_RESTRICTED_ENVS,
> >>>
> >>>
> >>>
> >>>     _CS_V7_WIDTH_RESTRICTED_ENVS,
> >>>
> >>>
> >>>
> >>>     _CS_LFS_CFLAGS = 1000,
> >>>
> >>>     _CS_LFS_LDFLAGS,
> >>>
> >>>     _CS_LFS_LIBS,
> >>>
> >>>     _CS_LFS_LINTFLAGS,
> >>>
> >>>     _CS_LFS64_CFLAGS,
> >>>
> >>>     _CS_LFS64_LDFLAGS,
> >>>
> >>>     _CS_LFS64_LIBS,
> >>>
> >>>     _CS_LFS64_LINTFLAGS,
> >>>
> >>>
> >>>     _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
> >>>
> >>>     _CS_XBS5_ILP32_OFF32_LDFLAGS,
> >>>
> >>>     _CS_XBS5_ILP32_OFF32_LIBS,
> >>>
> >>>     _CS_XBS5_ILP32_OFF32_LINTFLAGS,
> >>>
> >>>     _CS_XBS5_ILP32_OFFBIG_CFLAGS,
> >>>
> >>>     _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
> >>>
> >>>     _CS_XBS5_ILP32_OFFBIG_LIBS,
> >>>
> >>>     _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
> >>>
> >>>     _CS_XBS5_LP64_OFF64_CFLAGS,
> >>>
> >>>     _CS_XBS5_LP64_OFF64_LDFLAGS,
> >>>
> >>>     _CS_XBS5_LP64_OFF64_LIBS,
> >>>
> >>>     _CS_XBS5_LP64_OFF64_LINTFLAGS,
> >>>
> >>>     _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
> >>>
> >>>     _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
> >>>
> >>>     _CS_XBS5_LPBIG_OFFBIG_LIBS,
> >>>
> >>>     _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
> >>>
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFF32_LIBS,
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
> >>>
> >>>     _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
> >>>
> >>>     _CS_POSIX_V6_LP64_OFF64_CFLAGS,
> >>>
> >>>     _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V6_LP64_OFF64_LIBS,
> >>>
> >>>     _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
> >>>
> >>>     _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
> >>>
> >>>     _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
> >>>
> >>>     _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
> >>>
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFF32_LIBS,
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
> >>>
> >>>     _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
> >>>
> >>>     _CS_POSIX_V7_LP64_OFF64_CFLAGS,
> >>>
> >>>     _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V7_LP64_OFF64_LIBS,
> >>>
> >>>     _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
> >>>
> >>>     _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
> >>>
> >>>     _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
> >>>
> >>>     _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
> >>>
> >>>     _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
> >>>
> >>>
> >>>     _CS_V6_ENV,
> >>>
> >>>     _CS_V7_ENV
> >>>
> >>>   };
> >>> # 613 "/usr/include/unistd.h" 2 3 4
> >>>
> >>>
> >>> extern long int pathconf (const char *__path, int __name)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>> extern long int fpathconf (int __fd, int __name) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern long int sysconf (int __name) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern size_t confstr (int __name, char *__buf, size_t __len) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern __pid_t getpid (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern __pid_t getppid (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern __pid_t getpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> # 663 "/usr/include/unistd.h" 3 4
> >>> extern int setpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern __pid_t setsid (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern __uid_t getuid (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern __uid_t geteuid (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern __gid_t getgid (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern __gid_t getegid (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int getgroups (int __size, __gid_t __list[]) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) ;
> >>> # 703 "/usr/include/unistd.h" 3 4
> >>> extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>> # 759 "/usr/include/unistd.h" 3 4
> >>> extern __pid_t fork (void) __attribute__ ((__nothrow__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern __pid_t vfork (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *ttyname (int __fd) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2))) ;
> >>>
> >>>
> >>>
> >>> extern int isatty (int __fd) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int ttyslot (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int link (const char *__from, const char *__to)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int linkat (int __fromfd, const char *__from, int __tofd,
> >>>      const char *__to, int __flags)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2, 4))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int symlink (const char *__from, const char *__to)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t readlink (const char *__restrict __path,
> >>>     char *__restrict __buf, size_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1, 2))) ;
> >>>
> >>>
> >>>
> >>>
> >>> extern int symlinkat (const char *__from, int __tofd,
> >>>         const char *__to) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (1, 3))) ;
> >>>
> >>>
> >>> extern ssize_t readlinkat (int __fd, const char *__restrict __path,
> >>>       char *__restrict __buf, size_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2, 3))) ;
> >>>
> >>>
> >>>
> >>> extern int unlink (const char *__name) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>> extern int unlinkat (int __fd, const char *__name, int __flag)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (2)));
> >>>
> >>>
> >>>
> >>> extern int rmdir (const char *__path) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>> extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char *getlogin (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getlogin_r (char *__name, size_t __name_len) __attribute__ 
> >>> ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int setlogin (const char *__name) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>> # 874 "/usr/include/unistd.h" 3 4
> >>> # 1 "/usr/include/getopt.h" 1 3 4
> >>> # 57 "/usr/include/getopt.h" 3 4
> >>> extern char *optarg;
> >>> # 71 "/usr/include/getopt.h" 3 4
> >>> extern int optind;
> >>>
> >>>
> >>>
> >>>
> >>> extern int opterr;
> >>>
> >>>
> >>>
> >>> extern int optopt;
> >>> # 150 "/usr/include/getopt.h" 3 4
> >>> extern int getopt (int ___argc, char *const *___argv, const char 
> >>> *__shortopts)
> >>>        __attribute__ ((__nothrow__ , __leaf__));
> >>> # 875 "/usr/include/unistd.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int gethostname (char *__name, size_t __len) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int sethostname (const char *__name, size_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) ;
> >>>
> >>>
> >>>
> >>> extern int sethostid (long int __id) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getdomainname (char *__name, size_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) ;
> >>> extern int setdomainname (const char *__name, size_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int vhangup (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int revoke (const char *__file) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int profil (unsigned short int *__sample_buffer, size_t __size,
> >>>      size_t __offset, unsigned int __scale)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int acct (const char *__name) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern char *getusershell (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern void endusershell (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern void setusershell (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int daemon (int __nochdir, int __noclose) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int chroot (const char *__path) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__nonnull__ (1))) ;
> >>>
> >>>
> >>>
> >>> extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int fsync (int __fd);
> >>> # 972 "/usr/include/unistd.h" 3 4
> >>> extern long int gethostid (void);
> >>>
> >>>
> >>> extern void sync (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getpagesize (void) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__const__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int getdtablesize (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> # 996 "/usr/include/unistd.h" 3 4
> >>> extern int truncate (const char *__file, __off_t __length)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1))) ;
> >>> # 1019 "/usr/include/unistd.h" 3 4
> >>> extern int ftruncate (int __fd, __off_t __length) __attribute__ 
> >>> ((__nothrow__ , __leaf__)) ;
> >>> # 1040 "/usr/include/unistd.h" 3 4
> >>> extern int brk (void *__addr) __attribute__ ((__nothrow__ , __leaf__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 1061 "/usr/include/unistd.h" 3 4
> >>> extern long int syscall (long int __sysno, ...) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> # 1115 "/usr/include/unistd.h" 3 4
> >>> extern int fdatasync (int __fildes);
> >>> # 1154 "/usr/include/unistd.h" 3 4
> >>>
> >>> # 59 "machine.c" 2
> >>> # 1 "/usr/include/sys/param.h" 1 3 4
> >>> # 23 "/usr/include/sys/param.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 24 "/usr/include/sys/param.h" 2 3 4
> >>>
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/limits.h" 1 3 4
> >>> # 34 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/limits.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/syslimits.h" 1 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/limits.h" 1 3 4
> >>> # 168 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/limits.h" 3 4
> >>> # 1 "/usr/include/limits.h" 1 3 4
> >>> # 143 "/usr/include/limits.h" 3 4
> >>> # 1 "/usr/include/bits/posix1_lim.h" 1 3 4
> >>> # 160 "/usr/include/bits/posix1_lim.h" 3 4
> >>> # 1 "/usr/include/bits/local_lim.h" 1 3 4
> >>> # 38 "/usr/include/bits/local_lim.h" 3 4
> >>> # 1 "/usr/include/linux/limits.h" 1 3 4
> >>> # 39 "/usr/include/bits/local_lim.h" 2 3 4
> >>> # 161 "/usr/include/bits/posix1_lim.h" 2 3 4
> >>> # 144 "/usr/include/limits.h" 2 3 4
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/posix2_lim.h" 1 3 4
> >>> # 148 "/usr/include/limits.h" 2 3 4
> >>> # 169 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/limits.h" 2 3 4
> >>> # 8 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/syslimits.h" 2 3 4
> >>> # 35 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/limits.h" 2 3 4
> >>> # 27 "/usr/include/sys/param.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/param.h" 1 3 4
> >>> # 28 "/usr/include/bits/param.h" 3 4
> >>> # 1 "/usr/include/linux/param.h" 1 3 4
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/asm/param.h" 1 3 4
> >>> # 1 "/usr/include/asm-generic/param.h" 1 3 4
> >>> # 1 "/usr/include/asm/param.h" 2 3 4
> >>> # 5 "/usr/include/linux/param.h" 2 3 4
> >>> # 29 "/usr/include/bits/param.h" 2 3 4
> >>> # 32 "/usr/include/sys/param.h" 2 3 4
> >>> # 60 "machine.c" 2
> >>> # 1 "/usr/include/sys/time.h" 1 3 4
> >>> # 27 "/usr/include/sys/time.h" 3 4
> >>> # 1 "/usr/include/bits/time.h" 1 3 4
> >>> # 28 "/usr/include/sys/time.h" 2 3 4
> >>> # 37 "/usr/include/sys/time.h" 3 4
> >>>
> >>> # 55 "/usr/include/sys/time.h" 3 4
> >>> struct timezone
> >>>   {
> >>>     int tz_minuteswest;
> >>>     int tz_dsttime;
> >>>   };
> >>>
> >>> typedef struct timezone *__restrict __timezone_ptr_t;
> >>> # 71 "/usr/include/sys/time.h" 3 4
> >>> extern int gettimeofday (struct timeval *__restrict __tv,
> >>>     __timezone_ptr_t __tz) __attribute__ ((__nothrow__ , __leaf__)) 
> >>> __attribute__ ((__nonnull__ (1)));
> >>>
> >>>
> >>>
> >>>
> >>> extern int settimeofday (const struct timeval *__tv,
> >>>     const struct timezone *__tz)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int adjtime (const struct timeval *__delta,
> >>>       struct timeval *__olddelta) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> enum __itimer_which
> >>>   {
> >>>
> >>>     ITIMER_REAL = 0,
> >>>
> >>>
> >>>     ITIMER_VIRTUAL = 1,
> >>>
> >>>
> >>>
> >>>     ITIMER_PROF = 2
> >>>
> >>>   };
> >>>
> >>>
> >>>
> >>> struct itimerval
> >>>   {
> >>>
> >>>     struct timeval it_interval;
> >>>
> >>>     struct timeval it_value;
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef int __itimer_which_t;
> >>>
> >>>
> >>>
> >>>
> >>> extern int getitimer (__itimer_which_t __which,
> >>>         struct itimerval *__value) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int setitimer (__itimer_which_t __which,
> >>>         const struct itimerval *__restrict __new,
> >>>         struct itimerval *__restrict __old) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int utimes (const char *__file, const struct timeval __tvp[2])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>>
> >>> extern int lutimes (const char *__file, const struct timeval __tvp[2])
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ 
> >>> (1)));
> >>>
> >>>
> >>> extern int futimes (int __fd, const struct timeval __tvp[2]) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>> # 189 "/usr/include/sys/time.h" 3 4
> >>>
> >>> # 61 "machine.c" 2
> >>> # 1 "/usr/include/sys/times.h" 1 3 4
> >>> # 31 "/usr/include/sys/times.h" 3 4
> >>>
> >>>
> >>>
> >>> struct tms
> >>>   {
> >>>     clock_t tms_utime;
> >>>     clock_t tms_stime;
> >>>
> >>>     clock_t tms_cutime;
> >>>     clock_t tms_cstime;
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern clock_t times (struct tms *__buffer) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> # 62 "machine.c" 2
> >>> # 1 "/usr/include/sys/resource.h" 1 3 4
> >>> # 24 "/usr/include/sys/resource.h" 3 4
> >>> # 1 "/usr/include/bits/resource.h" 1 3 4
> >>> # 31 "/usr/include/bits/resource.h" 3 4
> >>> enum __rlimit_resource
> >>> {
> >>>
> >>>   RLIMIT_CPU = 0,
> >>>
> >>>
> >>>
> >>>   RLIMIT_FSIZE = 1,
> >>>
> >>>
> >>>
> >>>   RLIMIT_DATA = 2,
> >>>
> >>>
> >>>
> >>>   RLIMIT_STACK = 3,
> >>>
> >>>
> >>>
> >>>   RLIMIT_CORE = 4,
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   __RLIMIT_RSS = 5,
> >>>
> >>>
> >>>
> >>>   RLIMIT_NOFILE = 7,
> >>>   __RLIMIT_OFILE = RLIMIT_NOFILE,
> >>>
> >>>
> >>>
> >>>
> >>>   RLIMIT_AS = 9,
> >>>
> >>>
> >>>
> >>>   __RLIMIT_NPROC = 6,
> >>>
> >>>
> >>>
> >>>   __RLIMIT_MEMLOCK = 8,
> >>>
> >>>
> >>>
> >>>   __RLIMIT_LOCKS = 10,
> >>>
> >>>
> >>>
> >>>   __RLIMIT_SIGPENDING = 11,
> >>>
> >>>
> >>>
> >>>   __RLIMIT_MSGQUEUE = 12,
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   __RLIMIT_NICE = 13,
> >>>
> >>>
> >>>
> >>>
> >>>   __RLIMIT_RTPRIO = 14,
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   __RLIMIT_RTTIME = 15,
> >>>
> >>>
> >>>   __RLIMIT_NLIMITS = 16,
> >>>   __RLIM_NLIMITS = __RLIMIT_NLIMITS
> >>>
> >>>
> >>> };
> >>> # 131 "/usr/include/bits/resource.h" 3 4
> >>> typedef __rlim_t rlim_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct rlimit
> >>>   {
> >>>
> >>>     rlim_t rlim_cur;
> >>>
> >>>     rlim_t rlim_max;
> >>>   };
> >>> # 158 "/usr/include/bits/resource.h" 3 4
> >>> enum __rusage_who
> >>> {
> >>>
> >>>   RUSAGE_SELF = 0,
> >>>
> >>>
> >>>
> >>>   RUSAGE_CHILDREN = -1
> >>> # 176 "/usr/include/bits/resource.h" 3 4
> >>> };
> >>>
> >>>
> >>> # 1 "/usr/include/bits/time.h" 1 3 4
> >>> # 180 "/usr/include/bits/resource.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct rusage
> >>>   {
> >>>
> >>>     struct timeval ru_utime;
> >>>
> >>>     struct timeval ru_stime;
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_maxrss;
> >>>  __syscall_slong_t __ru_maxrss_word;
> >>>       };
> >>>
> >>>
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_ixrss;
> >>>  __syscall_slong_t __ru_ixrss_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_idrss;
> >>>  __syscall_slong_t __ru_idrss_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_isrss;
> >>>   __syscall_slong_t __ru_isrss_word;
> >>>       };
> >>>
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_minflt;
> >>>  __syscall_slong_t __ru_minflt_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_majflt;
> >>>  __syscall_slong_t __ru_majflt_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_nswap;
> >>>  __syscall_slong_t __ru_nswap_word;
> >>>       };
> >>>
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_inblock;
> >>>  __syscall_slong_t __ru_inblock_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_oublock;
> >>>  __syscall_slong_t __ru_oublock_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_msgsnd;
> >>>  __syscall_slong_t __ru_msgsnd_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_msgrcv;
> >>>  __syscall_slong_t __ru_msgrcv_word;
> >>>       };
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_nsignals;
> >>>  __syscall_slong_t __ru_nsignals_word;
> >>>       };
> >>>
> >>>
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_nvcsw;
> >>>  __syscall_slong_t __ru_nvcsw_word;
> >>>       };
> >>>
> >>>
> >>>     __extension__ union
> >>>       {
> >>>  long int ru_nivcsw;
> >>>  __syscall_slong_t __ru_nivcsw_word;
> >>>       };
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> enum __priority_which
> >>> {
> >>>   PRIO_PROCESS = 0,
> >>>
> >>>   PRIO_PGRP = 1,
> >>>
> >>>   PRIO_USER = 2
> >>>
> >>> };
> >>>
> >>>
> >>>
> >>> # 328 "/usr/include/bits/resource.h" 3 4
> >>>
> >>> # 25 "/usr/include/sys/resource.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> # 42 "/usr/include/sys/resource.h" 3 4
> >>> typedef int __rlimit_resource_t;
> >>> typedef int __rusage_who_t;
> >>> typedef int __priority_which_t;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getrlimit (__rlimit_resource_t __resource,
> >>>         struct rlimit *__rlimits) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 69 "/usr/include/sys/resource.h" 3 4
> >>> extern int setrlimit (__rlimit_resource_t __resource,
> >>>         const struct rlimit *__rlimits) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 87 "/usr/include/sys/resource.h" 3 4
> >>> extern int getrusage (__rusage_who_t __who, struct rusage *__usage) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getpriority (__priority_which_t __which, id_t __who) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern int setpriority (__priority_which_t __which, id_t __who, int 
> >>> __prio)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> # 63 "machine.c" 2
> >>> # 71 "machine.c"
> >>> # 1 "engine_pl.h" 1
> >>> # 40 "engine_pl.h"
> >>> # 1 "pl_params.h" 1
> >>> # 41 "engine_pl.h" 2
> >>> # 1 "hash_fct.h" 1
> >>> # 53 "hash_fct.h"
> >>>
> >>> # 53 "hash_fct.h"
> >>> typedef struct
> >>> {
> >>>   int len;
> >>>   uint32_t hash;
> >>> } HashIncrInfo;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> uint32_t Pl_Hash_Buffer(const void *data, int len);
> >>>
> >>> void Pl_Hash_Incr_Init(HashIncrInfo *hi);
> >>>
> >>> void Pl_Hash_Incr_Buffer(HashIncrInfo *hi, const void *data, int len);
> >>>
> >>> void Pl_Hash_Incr_Int32(HashIncrInfo *hi, uint32_t x);
> >>>
> >>> void Pl_Hash_Incr_Int64(HashIncrInfo *hi, uint64_t x);
> >>>
> >>> void Pl_Hash_Incr_Double(HashIncrInfo *hi, double x);
> >>>
> >>> uint32_t Pl_Hash_Incr_Term(HashIncrInfo *hi);
> >>> # 42 "engine_pl.h" 2
> >>> # 1 "hash.h" 1
> >>> # 48 "hash.h"
> >>> typedef struct
> >>> {
> >>>   char *endt;
> >>>   char *cur_t;
> >>>   char *cur_p;
> >>> }
> >>> HashScan;
> >>> # 67 "hash.h"
> >>> char *Pl_Hash_Alloc_Table(int tbl_size, int elem_size);
> >>>
> >>> void Pl_Hash_Free_Table(char *tbl);
> >>>
> >>> char *Pl_Hash_Realloc_Table(char *tbl, int new_tbl_size);
> >>>
> >>> void Pl_Hash_Delete_All(char *tbl);
> >>>
> >>> char *Pl_Hash_Insert(char *tbl, char *elem, int replace);
> >>>
> >>> char *Pl_Hash_Find(char *tbl, PlLong key);
> >>>
> >>> char *Pl_Hash_Delete(char *tbl, PlLong key);
> >>>
> >>> char *Pl_Hash_First(char *tbl, HashScan *scan);
> >>>
> >>> char *Pl_Hash_Next(HashScan *scan);
> >>>
> >>> int Pl_Hash_Table_Size(char *tbl);
> >>>
> >>> int Pl_Hash_Nb_Elements(char *tbl);
> >>> # 43 "engine_pl.h" 2
> >>> # 1 "bool.h" 1
> >>> # 65 "bool.h"
> >>> typedef int Bool;
> >>> # 44 "engine_pl.h" 2
> >>> # 1 "wam_regs.h" 1
> >>> # 45 "engine_pl.h" 2
> >>> # 1 "wam_archi.h" 1
> >>> # 44 "wam_archi.h"
> >>> typedef intptr_t WamWord;
> >>>
> >>> typedef void (*CodePtr) ();
> >>>
> >>> typedef CodePtr WamCont;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef WamWord *WamWordP;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> register WamWordP TR asm ("ebx");
> >>> # 96 "wam_archi.h"
> >>> extern WamWord pl_reg_bank[];
> >>> extern WamWord pl_buff_signal_reg[];
> >>>
> >>> extern char *pl_reg_tbl[];
> >>> # 270 "wam_archi.h"
> >>> typedef enum
> >>> {
> >>>   LONG_INT,
> >>>   SHORT_UNS,
> >>>   ADDRESS
> >>> }TypTag;
> >>>
> >>> typedef struct
> >>> {
> >>>   char *name;
> >>>   TypTag type;
> >>>   int value;
> >>>   PlLong tag_mask;
> >>> }InfTag;
> >>> # 301 "wam_archi.h"
> >>> extern InfTag pl_tag_tbl[];
> >>> # 328 "wam_archi.h"
> >>> # 1 "wam_stacks.h" 1
> >>> # 27 "wam_stacks.h"
> >>> typedef struct
> >>> {
> >>>   char *name;
> >>>   char *desc;
> >>>   char *env_var_name;
> >>>   PlLong *p_def_size;
> >>>   int default_size;
> >>>   int size;
> >>>   WamWord *stack;
> >>> }InfStack;
> >>> # 58 "wam_stacks.h"
> >>> extern PlLong pl_def_trail_size;
> >>> extern PlLong pl_def_cstr_size;
> >>> extern PlLong pl_def_global_size;
> >>> extern PlLong pl_def_local_size;
> >>> extern PlLong pl_fixed_sizes;
> >>>
> >>>
> >>> extern InfStack pl_stk_tbl[];
> >>> # 329 "wam_archi.h" 2
> >>> # 46 "engine_pl.h" 2
> >>> # 1 "engine.h" 1
> >>> # 87 "engine.h"
> >>> extern int pl_os_argc;
> >>> extern char **pl_os_argv;
> >>>
> >>> extern char *pl_home;
> >>> extern int pl_devel_mode;
> >>>
> >>> extern char pl_glob_buff[];
> >>>
> >>> extern PlLong *pl_base_fl;
> >>> extern double *pl_base_fd;
> >>>
> >>> extern int pl_le_mode;
> >>> # 108 "engine.h"
> >>> int Pl_Start_Prolog(int argc, char *argv[]);
> >>>
> >>> void Pl_Stop_Prolog(void);
> >>>
> >>> void Pl_Reset_Prolog(void);
> >>>
> >>> void Pl_Reset_Prolog_In_Signal(void);
> >>>
> >>> void Pl_Set_Heap_Actual_Start(WamWord *heap_actual_start);
> >>>
> >>>
> >>>
> >>> void Pl_Execute_Directive(int pl_file, int pl_line, Bool is_system,
> >>>      CodePtr proc);
> >>>
> >>> Bool Pl_Try_Execute_Top_Level(void);
> >>>
> >>> Bool Pl_Call_Prolog(CodePtr codep);
> >>>
> >>> Bool Pl_Call_Prolog_Next_Sol(WamWord *query_b);
> >>>
> >>> void Pl_Keep_Rest_For_Prolog(WamWord *query_b);
> >>>
> >>> void Pl_Exit_With_Exception(void);
> >>>
> >>> void Pl_Execute_A_Continuation(CodePtr codep);
> >>> # 47 "engine_pl.h" 2
> >>> # 1 "atom.h" 1
> >>> # 97 "atom.h"
> >>> typedef struct
> >>> {
> >>>   unsigned length:16;
> >>>   unsigned op_mask:4;
> >>>   unsigned type:2;
> >>>   unsigned needs_quote:1;
> >>>   unsigned needs_scan:1;
> >>> }
> >>> AtomProp;
> >>>
> >>>
> >>>
> >>>
> >>> typedef struct
> >>> {
> >>>   char *name;
> >>>   unsigned hash;
> >>>   AtomProp prop;
> >>>   void *info;
> >>> }
> >>> AtomInf;
> >>> # 153 "atom.h"
> >>> extern AtomInf *pl_atom_tbl;
> >>> extern int pl_max_atom;
> >>> extern int pl_nb_atom;
> >>>
> >>> extern int pl_atom_void;
> >>> extern int pl_atom_curly_brackets;
> >>>
> >>> extern int pl_atom_false;
> >>> extern int pl_atom_true;
> >>>
> >>> extern int pl_atom_end_of_file;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern char pl_char_conv[];
> >>> extern int pl_char_type[];
> >>>
> >>> extern char pl_escape_symbol[];
> >>> extern char pl_escape_char[];
> >>>
> >>>
> >>>
> >>> PlLong pl_def_max_atom;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> void Pl_Init_Atom(void);
> >>>
> >>> int Pl_Create_Allocate_Atom(char *name);
> >>>
> >>> int Pl_Create_Atom(char *name);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Create_Atom_Tagged(char *name);
> >>>
> >>> int Pl_Find_Atom(char *name);
> >>>
> >>> int Pl_Gen_New_Atom(char *prefix);
> >>>
> >>> int Pl_Find_Next_Atom(int last_atom);
> >>> # 48 "engine_pl.h" 2
> >>> # 1 "pred.h" 1
> >>> # 62 "pred.h"
> >>> typedef struct
> >>> {
> >>>   PlLong f_n;
> >>>   int pl_file;
> >>>   int pl_line;
> >>>   int prop;
> >>>   PlLong *codep;
> >>>   PlLong *dyn;
> >>> }
> >>> PredInf;
> >>> # 86 "pred.h"
> >>> extern char *pl_pred_tbl;
> >>> # 97 "pred.h"
> >>> void Pl_Init_Pred(void);
> >>>
> >>> PredInf * __attribute__((regparm(3))) Pl_Create_Pred(int func, int arity, 
> >>> int pl_file, int pl_line,
> >>>        int prop, PlLong *codep);
> >>>
> >>> PredInf * __attribute__((regparm(3))) Pl_Lookup_Pred(int func, int arity);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Delete_Pred(int func, int arity);
> >>> # 49 "engine_pl.h" 2
> >>> # 1 "misc.h" 1
> >>> # 57 "misc.h"
> >>> char *Pl_Malloc_Check(unsigned size, char *src_file, int src_line);
> >>>
> >>> char *Pl_Calloc_Check(unsigned nb, unsigned size, char *src_file,
> >>>      int src_line);
> >>>
> >>> char *Pl_Realloc_Check(char *ptr, unsigned size, char *src_file, int 
> >>> src_line);
> >>>
> >>> char *Pl_Strdup_Check(char *str, char *src_file, int src_line);
> >>> # 76 "misc.h"
> >>> void Pl_Extend_Table_If_Needed(char **hash_tbl);
> >>>
> >>> void Pl_Extend_Array(char **ptbl, int *nb_elem, int elem_size, Bool 
> >>> bzero);
> >>>
> >>> void Pl_Exit_With_Value(int ret_val);
> >>>
> >>> void Pl_Fatal_Error(char *format, ...);
> >>> # 114 "misc.h"
> >>> void *Pl_Dummy_Ptr(void *p);
> >>> # 50 "engine_pl.h" 2
> >>> # 1 "oper.h" 1
> >>> # 72 "oper.h"
> >>> typedef struct
> >>> {
> >>>   PlLong a_t;
> >>>   int prec;
> >>>   int left;
> >>>   int right;
> >>> }
> >>> OperInf;
> >>> # 94 "oper.h"
> >>> extern char *pl_oper_tbl;
> >>> # 103 "oper.h"
> >>> void Pl_Init_Oper(void);
> >>>
> >>> OperInf *Pl_Create_Oper(int atom_op, int type, int prec, int left, int 
> >>> right);
> >>>
> >>> OperInf *Pl_Lookup_Oper(int atom_op, int type);
> >>>
> >>> OperInf *Pl_Lookup_Oper_Any_Type(int atom_op);
> >>>
> >>> OperInf *Pl_Delete_Oper(int atom_op, int type);
> >>> # 51 "engine_pl.h" 2
> >>> # 1 "machine1.h" 1
> >>> # 70 "machine1.h"
> >>> extern int pl_m_os_type;
> >>> extern char pl_m_architecture[];
> >>> extern char pl_m_os_version[];
> >>> # 83 "machine1.h"
> >>> void Pl_Init_Machine1(void);
> >>>
> >>> char **Pl_M_Create_Shell_Command(char *cmd);
> >>>
> >>> char **Pl_M_Cmd_Line_To_Argv(char *cmd, int *argc);
> >>>
> >>> int Pl_M_Shell(char *cmd);
> >>>
> >>> int Pl_M_Spawn(char *arg[]);
> >>>
> >>> int Pl_M_Spawn_Redirect(char *arg[], int detach,
> >>>        FILE **f_in, FILE **f_out, FILE **f_err);
> >>>
> >>> int Pl_M_Get_Status(int pid);
> >>>
> >>>
> >>>
> >>> char *Pl_M_Mktemp(char *tmp_template);
> >>>
> >>> char *Pl_M_Tempnam(char *dir, char *pfx);
> >>> # 52 "engine_pl.h" 2
> >>> # 1 "machine.h" 1
> >>> # 61 "machine.h"
> >>> void Pl_Init_Machine(void);
> >>>
> >>> char *Pl_M_Sys_Err_String(int ret_val);
> >>>
> >>> PlLong Pl_M_User_Time(void);
> >>>
> >>> PlLong Pl_M_System_Time(void);
> >>>
> >>> PlLong Pl_M_Real_Time(void);
> >>>
> >>> void Pl_M_Randomize(void);
> >>>
> >>> void Pl_M_Set_Seed(int n);
> >>>
> >>> int Pl_M_Get_Seed(void);
> >>>
> >>> int Pl_M_Random_Integer(int n);
> >>>
> >>> double Pl_M_Random_Float(double n);
> >>>
> >>>
> >>>
> >>> char *Pl_M_Host_Name_From_Name(char *host_name);
> >>>
> >>> char *Pl_M_Host_Name_From_Adr(char *host_address);
> >>>
> >>> char *Pl_M_Get_Working_Dir(void);
> >>>
> >>> Bool Pl_M_Set_Working_Dir(char *path);
> >>>
> >>> char *Pl_M_Absolute_Path_Name(char *src);
> >>>
> >>> Bool Pl_M_Is_Absolute_File_Name(char *path);
> >>>
> >>> char *Pl_M_Decompose_File_Name(char *path, Bool del_trail_slashes,
> >>>           char **base, char **suffix);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> void M_Check_Magic_Words(void);
> >>> # 53 "engine_pl.h" 2
> >>> # 1 "stacks_sigsegv.h" 1
> >>> # 50 "stacks_sigsegv.h"
> >>> typedef int (*SegvHdlr)(void *bad_addr);
> >>> # 60 "stacks_sigsegv.h"
> >>> void Pl_Allocate_Stacks(void);
> >>>
> >>> void Pl_Push_SIGSEGV_Handler(SegvHdlr handler);
> >>>
> >>> void Pl_Pop_SIGSEGV_Handler(void);
> >>> # 54 "engine_pl.h" 2
> >>> # 1 "obj_chain.h" 1
> >>> # 58 "obj_chain.h"
> >>> void Pl_Find_Linked_Objects(void);
> >>>
> >>> void Pl_New_Object(void (*fct_obj_init)(), void (*fct_exec_system) (), 
> >>> void (*fct_exec_user) ());
> >>> # 55 "engine_pl.h" 2
> >>> # 1 "wam_inst.h" 1
> >>> # 249 "wam_inst.h"
> >>> typedef struct
> >>> {
> >>>   PlLong key;
> >>>   CodePtr codep;
> >>> }
> >>> SwtInf;
> >>>
> >>> typedef SwtInf *SwtTbl;
> >>> # 269 "wam_inst.h"
> >>> WamWord __attribute__((regparm(3))) Pl_Create_Functor_Arity_Tagged(char 
> >>> *func_str, int arity);
> >>>
> >>> SwtTbl __attribute__((regparm(3))) Pl_Create_Swt_Table(int size);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Create_Swt_Atm_Element(SwtTbl t, int 
> >>> size, int atom, CodePtr codep);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Create_Swt_Stc_Element(SwtTbl t, int 
> >>> size, int func, int arity,
> >>>        CodePtr codep);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Atom_Tagged(WamWord w, WamWord 
> >>> start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Atom(int atom, WamWord 
> >>> start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Integer_Tagged(WamWord w, WamWord 
> >>> start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Integer(PlLong n, WamWord 
> >>> start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Float(double n, WamWord 
> >>> start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Nil(WamWord start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_List(WamWord start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Structure_Tagged(WamWord w, 
> >>> WamWord start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Get_Structure(int func, int arity, 
> >>> WamWord start_word);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_X_Variable(void);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Y_Variable(WamWord *y_adr);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Unsafe_Value(WamWord 
> >>> start_word);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Atom_Tagged(WamWord w);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Atom(int atom);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Integer_Tagged(WamWord w);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Integer(PlLong n);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Float(double n);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Nil(void);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_List(void);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Structure_Tagged(WamWord w);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Put_Structure(int func, int arity);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Unify_Variable(void);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Unify_Void(int n);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Value(WamWord start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Local_Value(WamWord start_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Atom_Tagged(WamWord w);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Atom(int atom);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Integer_Tagged(WamWord w);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Integer(PlLong n);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Nil(void);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_List(void);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Structure_Tagged(WamWord w);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Structure(int func, int arity);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Globalize_If_In_Local(WamWord 
> >>> start_word);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Allocate(int n);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Deallocate(void);
> >>>
> >>> CodePtr __attribute__((regparm(3))) Pl_Switch_On_Term(CodePtr c_var, 
> >>> CodePtr c_atm, CodePtr c_int,
> >>>             CodePtr c_lst, CodePtr c_stc);
> >>> CodePtr __attribute__((regparm(3))) Pl_Switch_On_Term_Var_Atm(CodePtr 
> >>> c_var, CodePtr c_atm);
> >>> CodePtr __attribute__((regparm(3))) Pl_Switch_On_Term_Var_Stc(CodePtr 
> >>> c_var, CodePtr c_stc);
> >>> CodePtr __attribute__((regparm(3))) Pl_Switch_On_Term_Var_Atm_Lst(CodePtr 
> >>> c_var, CodePtr c_atm,
> >>>           CodePtr c_lst);
> >>> CodePtr __attribute__((regparm(3))) Pl_Switch_On_Term_Var_Atm_Stc(CodePtr 
> >>> c_var, CodePtr c_atm,
> >>>           CodePtr c_stc);
> >>>
> >>> CodePtr __attribute__((regparm(3))) Pl_Switch_On_Atom(SwtTbl t, int size);
> >>>
> >>> PlLong __attribute__((regparm(3))) Pl_Switch_On_Integer(void);
> >>>
> >>> CodePtr __attribute__((regparm(3))) Pl_Switch_On_Structure(SwtTbl t, int 
> >>> size);
> >>>
> >>> WamWord __attribute__((regparm(3))) Pl_Get_Current_Choice(void);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Cut(WamWord b_word);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Soft_Cut(WamWord b_word);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Global_Push_Float(double n);
> >>>
> >>> double __attribute__((regparm(3))) Pl_Obtain_Float(WamWord *adr);
> >>>
> >>>
> >>> void __attribute__((regparm(3))) Pl_Create_Choice_Point(CodePtr 
> >>> codep_alt, int arity);
> >>> void __attribute__((regparm(3))) Pl_Create_Choice_Point0(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Create_Choice_Point1(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Create_Choice_Point2(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Create_Choice_Point3(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Create_Choice_Point4(CodePtr 
> >>> codep_alt);
> >>>
> >>>
> >>> void __attribute__((regparm(3))) Pl_Update_Choice_Point(CodePtr 
> >>> codep_alt, int arity);
> >>> void __attribute__((regparm(3))) Pl_Update_Choice_Point0(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Update_Choice_Point1(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Update_Choice_Point2(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Update_Choice_Point3(CodePtr 
> >>> codep_alt);
> >>> void __attribute__((regparm(3))) Pl_Update_Choice_Point4(CodePtr 
> >>> codep_alt);
> >>>
> >>> void __attribute__((regparm(3))) Pl_Delete_Choice_Point(int arity);
> >>> void __attribute__((regparm(3))) Pl_Delete_Choice_Point0(void);
> >>> void __attribute__((regparm(3))) Pl_Delete_Choice_Point1(void);
> >>> void __attribute__((regparm(3))) Pl_Delete_Choice_Point2(void);
> >>> void __attribute__((regparm(3))) Pl_Delete_Choice_Point3(void);
> >>> void __attribute__((regparm(3))) Pl_Delete_Choice_Point4(void);
> >>>
> >>>
> >>> void Pl_Defeasible_Open();
> >>> void Pl_Defeasible_Undo();
> >>> void Pl_Defeasible_Close(Bool undo_before);
> >>>
> >>>
> >>>
> >>> void __attribute__((regparm(3))) Pl_Untrail(WamWord *low_adr);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify(WamWord start_u_word, WamWord 
> >>> start_v_word);
> >>>
> >>> Bool __attribute__((regparm(3))) Pl_Unify_Occurs_Check(WamWord 
> >>> start_u_word, WamWord start_v_word);
> >>> # 56 "engine_pl.h" 2
> >>> # 1 "if_no_fd.h" 1
> >>> # 65 "if_no_fd.h"
> >>> extern void (*pl_fd_init_solver) ();
> >>> extern void (*pl_fd_reset_solver) ();
> >>> extern Bool (*pl_fd_unify_with_integer) ();
> >>> extern Bool (*pl_fd_unify_with_fd_var) ();
> >>> extern int (*pl_fd_variable_size) ();
> >>> extern int (*pl_fd_copy_variable) ();
> >>> extern char *(*pl_fd_variable_to_string) ();
> >>> # 82 "if_no_fd.h"
> >>> void Pl_Fd_Init_Solver(void);
> >>>
> >>> void Pl_Fd_Reset_Solver(void);
> >>> # 56 "engine_pl.h" 2
> >>> # 72 "machine.c" 2
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/malloc.h" 1 3 4
> >>> # 23 "/usr/include/malloc.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 149 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 3 4
> >>>
> >>> # 149 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 3 4
> >>> typedef int ptrdiff_t;
> >>> # 426 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 3 4
> >>> typedef struct {
> >>>   long long __max_align_ll __attribute__((__aligned__(__alignof__(long 
> >>> long))));
> >>>   long double __max_align_ld __attribute__((__aligned__(__alignof__(long 
> >>> double))));
> >>> } max_align_t;
> >>> # 24 "/usr/include/malloc.h" 2 3 4
> >>> # 35 "/usr/include/malloc.h" 3 4
> >>>
> >>>
> >>>
> >>> extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__malloc__)) ;
> >>>
> >>>
> >>> extern void *calloc (size_t __nmemb, size_t __size)
> >>> __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void *realloc (void *__ptr, size_t __size)
> >>> __attribute__ ((__nothrow__ , __leaf__)) __attribute__ 
> >>> ((__warn_unused_result__));
> >>>
> >>>
> >>> extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern void cfree (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern void *memalign (size_t __alignment, size_t __size)
> >>> __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;
> >>>
> >>>
> >>> extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__malloc__)) ;
> >>>
> >>>
> >>>
> >>> extern void *pvalloc (size_t __size) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__malloc__)) ;
> >>>
> >>>
> >>>
> >>> extern void *(*__morecore) (ptrdiff_t __size);
> >>>
> >>>
> >>> extern void *__default_morecore (ptrdiff_t __size)
> >>> __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__));
> >>>
> >>>
> >>>
> >>> struct mallinfo
> >>> {
> >>>   int arena;
> >>>   int ordblks;
> >>>   int smblks;
> >>>   int hblks;
> >>>   int hblkhd;
> >>>   int usmblks;
> >>>   int fsmblks;
> >>>   int uordblks;
> >>>   int fordblks;
> >>>   int keepcost;
> >>> };
> >>>
> >>>
> >>> extern struct mallinfo mallinfo (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 121 "/usr/include/malloc.h" 3 4
> >>> extern int mallopt (int __param, int __val) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern int malloc_trim (size_t __pad) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern size_t malloc_usable_size (void *__ptr) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern void malloc_stats (void) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int malloc_info (int __options, FILE *__fp) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern void *malloc_get_state (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern int malloc_set_state (void *__ptr) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern void (*volatile __malloc_initialize_hook) (void)
> >>> __attribute__ ((__deprecated__));
> >>>
> >>> extern void (*volatile __free_hook) (void *__ptr,
> >>>                                                    const void *)
> >>> __attribute__ ((__deprecated__));
> >>> extern void *(*volatile __malloc_hook)(size_t __size,
> >>>                                                      const void *)
> >>> __attribute__ ((__deprecated__));
> >>> extern void *(*volatile __realloc_hook)(void *__ptr,
> >>>                                                       size_t __size,
> >>>                                                       const void *)
> >>> __attribute__ ((__deprecated__));
> >>> extern void *(*volatile __memalign_hook)(size_t __alignment,
> >>>                                                        size_t __size,
> >>>                                                        const void *)
> >>> __attribute__ ((__deprecated__));
> >>> extern void (*volatile __after_morecore_hook) (void);
> >>>
> >>>
> >>> extern void __malloc_check_init (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__deprecated__));
> >>>
> >>>
> >>>
> >>> # 76 "machine.c" 2
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/netdb.h" 1 3 4
> >>> # 27 "/usr/include/netdb.h" 3 4
> >>> # 1 "/usr/include/netinet/in.h" 1 3 4
> >>> # 23 "/usr/include/netinet/in.h" 3 4
> >>> # 1 "/usr/include/sys/socket.h" 1 3 4
> >>> # 24 "/usr/include/sys/socket.h" 3 4
> >>>
> >>>
> >>> # 1 "/usr/include/sys/uio.h" 1 3 4
> >>> # 25 "/usr/include/sys/uio.h" 3 4
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/uio.h" 1 3 4
> >>> # 43 "/usr/include/bits/uio.h" 3 4
> >>> struct iovec
> >>>   {
> >>>     void *iov_base;
> >>>     size_t iov_len;
> >>>   };
> >>> # 29 "/usr/include/sys/uio.h" 2 3 4
> >>> # 39 "/usr/include/sys/uio.h" 3 4
> >>> extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
> >>>   ;
> >>> # 50 "/usr/include/sys/uio.h" 3 4
> >>> extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
> >>>   ;
> >>> # 65 "/usr/include/sys/uio.h" 3 4
> >>> extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
> >>>          __off_t __offset) ;
> >>> # 77 "/usr/include/sys/uio.h" 3 4
> >>> extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int 
> >>> __count,
> >>>    __off_t __offset) ;
> >>> # 120 "/usr/include/sys/uio.h" 3 4
> >>>
> >>> # 27 "/usr/include/sys/socket.h" 2 3 4
> >>>
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 29 "/usr/include/sys/socket.h" 2 3 4
> >>> # 38 "/usr/include/sys/socket.h" 3 4
> >>> # 1 "/usr/include/bits/socket.h" 1 3 4
> >>> # 27 "/usr/include/bits/socket.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 28 "/usr/include/bits/socket.h" 2 3 4
> >>> # 38 "/usr/include/bits/socket.h" 3 4
> >>> # 1 "/usr/include/bits/socket_type.h" 1 3 4
> >>> # 24 "/usr/include/bits/socket_type.h" 3 4
> >>> enum __socket_type
> >>> {
> >>>   SOCK_STREAM = 1,
> >>>
> >>>
> >>>   SOCK_DGRAM = 2,
> >>>
> >>>
> >>>   SOCK_RAW = 3,
> >>>
> >>>   SOCK_RDM = 4,
> >>>
> >>>   SOCK_SEQPACKET = 5,
> >>>
> >>>
> >>>   SOCK_DCCP = 6,
> >>>
> >>>   SOCK_PACKET = 10,
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   SOCK_CLOEXEC = 02000000,
> >>>
> >>>
> >>>   SOCK_NONBLOCK = 00004000
> >>>
> >>>
> >>> };
> >>> # 39 "/usr/include/bits/socket.h" 2 3 4
> >>> # 150 "/usr/include/bits/socket.h" 3 4
> >>> # 1 "/usr/include/bits/sockaddr.h" 1 3 4
> >>> # 28 "/usr/include/bits/sockaddr.h" 3 4
> >>> typedef unsigned short int sa_family_t;
> >>> # 151 "/usr/include/bits/socket.h" 2 3 4
> >>>
> >>>
> >>> struct sockaddr
> >>>   {
> >>>     sa_family_t sa_family;
> >>>     char sa_data[14];
> >>>   };
> >>> # 166 "/usr/include/bits/socket.h" 3 4
> >>> struct sockaddr_storage
> >>>   {
> >>>     sa_family_t ss_family;
> >>>     char __ss_padding[(128 - (sizeof (unsigned short int)) - sizeof 
> >>> (unsigned long int))];
> >>>     unsigned long int __ss_align;
> >>>   };
> >>>
> >>>
> >>>
> >>> enum
> >>>   {
> >>>     MSG_OOB = 0x01,
> >>>
> >>>     MSG_PEEK = 0x02,
> >>>
> >>>     MSG_DONTROUTE = 0x04,
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>     MSG_CTRUNC = 0x08,
> >>>
> >>>     MSG_PROXY = 0x10,
> >>>
> >>>     MSG_TRUNC = 0x20,
> >>>
> >>>     MSG_DONTWAIT = 0x40,
> >>>
> >>>     MSG_EOR = 0x80,
> >>>
> >>>     MSG_WAITALL = 0x100,
> >>>
> >>>     MSG_FIN = 0x200,
> >>>
> >>>     MSG_SYN = 0x400,
> >>>
> >>>     MSG_CONFIRM = 0x800,
> >>>
> >>>     MSG_RST = 0x1000,
> >>>
> >>>     MSG_ERRQUEUE = 0x2000,
> >>>
> >>>     MSG_NOSIGNAL = 0x4000,
> >>>
> >>>     MSG_MORE = 0x8000,
> >>>
> >>>     MSG_WAITFORONE = 0x10000,
> >>>
> >>>     MSG_FASTOPEN = 0x20000000,
> >>>
> >>>
> >>>     MSG_CMSG_CLOEXEC = 0x40000000
> >>>
> >>>
> >>>
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>> struct msghdr
> >>>   {
> >>>     void *msg_name;
> >>>     socklen_t msg_namelen;
> >>>
> >>>     struct iovec *msg_iov;
> >>>     size_t msg_iovlen;
> >>>
> >>>     void *msg_control;
> >>>     size_t msg_controllen;
> >>>
> >>>
> >>>
> >>>
> >>>     int msg_flags;
> >>>   };
> >>>
> >>>
> >>> struct cmsghdr
> >>>   {
> >>>     size_t cmsg_len;
> >>>
> >>>
> >>>
> >>>
> >>>     int cmsg_level;
> >>>     int cmsg_type;
> >>>
> >>>     __extension__ unsigned char __cmsg_data [];
> >>>
> >>>   };
> >>> # 276 "/usr/include/bits/socket.h" 3 4
> >>> extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
> >>>           struct cmsghdr *__cmsg) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 303 "/usr/include/bits/socket.h" 3 4
> >>> enum
> >>>   {
> >>>     SCM_RIGHTS = 0x01
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   };
> >>> # 349 "/usr/include/bits/socket.h" 3 4
> >>> # 1 "/usr/include/asm/socket.h" 1 3 4
> >>> # 1 "/usr/include/asm-generic/socket.h" 1 3 4
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/asm/sockios.h" 1 3 4
> >>> # 1 "/usr/include/asm-generic/sockios.h" 1 3 4
> >>> # 1 "/usr/include/asm/sockios.h" 2 3 4
> >>> # 5 "/usr/include/asm-generic/socket.h" 2 3 4
> >>> # 1 "/usr/include/asm/socket.h" 2 3 4
> >>> # 350 "/usr/include/bits/socket.h" 2 3 4
> >>> # 383 "/usr/include/bits/socket.h" 3 4
> >>> struct linger
> >>>   {
> >>>     int l_onoff;
> >>>     int l_linger;
> >>>   };
> >>> # 39 "/usr/include/sys/socket.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> struct osockaddr
> >>>   {
> >>>     unsigned short int sa_family;
> >>>     unsigned char sa_data[14];
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>> enum
> >>> {
> >>>   SHUT_RD = 0,
> >>>
> >>>   SHUT_WR,
> >>>
> >>>   SHUT_RDWR
> >>>
> >>> };
> >>> # 113 "/usr/include/sys/socket.h" 3 4
> >>> extern int socket (int __domain, int __type, int __protocol) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int socketpair (int __domain, int __type, int __protocol,
> >>>          int __fds[2]) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int bind (int __fd, const struct sockaddr * __addr, socklen_t 
> >>> __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
> >>>    socklen_t *__restrict __len) __attribute__ ((__nothrow__ , __leaf__));
> >>> # 137 "/usr/include/sys/socket.h" 3 4
> >>> extern int connect (int __fd, const struct sockaddr * __addr, socklen_t 
> >>> __len);
> >>>
> >>>
> >>>
> >>> extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
> >>>    socklen_t *__restrict __len) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t send (int __fd, const void *__buf, size_t __n, int 
> >>> __flags);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
> >>>          int __flags, const struct sockaddr * __addr,
> >>>          socklen_t __addr_len);
> >>> # 174 "/usr/include/sys/socket.h" 3 4
> >>> extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
> >>>     int __flags, struct sockaddr *__restrict __addr,
> >>>     socklen_t *__restrict __addr_len);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
> >>>    int __flags);
> >>> # 202 "/usr/include/sys/socket.h" 3 4
> >>> extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
> >>> # 219 "/usr/include/sys/socket.h" 3 4
> >>> extern int getsockopt (int __fd, int __level, int __optname,
> >>>          void *__restrict __optval,
> >>>          socklen_t *__restrict __optlen) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int setsockopt (int __fd, int __level, int __optname,
> >>>          const void *__optval, socklen_t __optlen) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int listen (int __fd, int __n) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> # 243 "/usr/include/sys/socket.h" 3 4
> >>> extern int accept (int __fd, struct sockaddr *__restrict __addr,
> >>>      socklen_t *__restrict __addr_len);
> >>> # 261 "/usr/include/sys/socket.h" 3 4
> >>> extern int shutdown (int __fd, int __how) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int sockatmark (int __fd) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int isfdtype (int __fd, int __fdtype) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>> # 283 "/usr/include/sys/socket.h" 3 4
> >>>
> >>> # 24 "/usr/include/netinet/in.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> typedef uint32_t in_addr_t;
> >>> struct in_addr
> >>>   {
> >>>     in_addr_t s_addr;
> >>>   };
> >>>
> >>>
> >>> # 1 "/usr/include/bits/in.h" 1 3 4
> >>> # 133 "/usr/include/bits/in.h" 3 4
> >>> struct ip_opts
> >>>   {
> >>>     struct in_addr ip_dst;
> >>>     char ip_opts[40];
> >>>   };
> >>>
> >>>
> >>> struct ip_mreqn
> >>>   {
> >>>     struct in_addr imr_multiaddr;
> >>>     struct in_addr imr_address;
> >>>     int imr_ifindex;
> >>>   };
> >>>
> >>>
> >>> struct in_pktinfo
> >>>   {
> >>>     int ipi_ifindex;
> >>>     struct in_addr ipi_spec_dst;
> >>>     struct in_addr ipi_addr;
> >>>   };
> >>> # 38 "/usr/include/netinet/in.h" 2 3 4
> >>>
> >>>
> >>> enum
> >>>   {
> >>>     IPPROTO_IP = 0,
> >>>
> >>>     IPPROTO_ICMP = 1,
> >>>
> >>>     IPPROTO_IGMP = 2,
> >>>
> >>>     IPPROTO_IPIP = 4,
> >>>
> >>>     IPPROTO_TCP = 6,
> >>>
> >>>     IPPROTO_EGP = 8,
> >>>
> >>>     IPPROTO_PUP = 12,
> >>>
> >>>     IPPROTO_UDP = 17,
> >>>
> >>>     IPPROTO_IDP = 22,
> >>>
> >>>     IPPROTO_TP = 29,
> >>>
> >>>     IPPROTO_DCCP = 33,
> >>>
> >>>     IPPROTO_IPV6 = 41,
> >>>
> >>>     IPPROTO_RSVP = 46,
> >>>
> >>>     IPPROTO_GRE = 47,
> >>>
> >>>     IPPROTO_ESP = 50,
> >>>
> >>>     IPPROTO_AH = 51,
> >>>
> >>>     IPPROTO_MTP = 92,
> >>>
> >>>     IPPROTO_BEETPH = 94,
> >>>
> >>>     IPPROTO_ENCAP = 98,
> >>>
> >>>     IPPROTO_PIM = 103,
> >>>
> >>>     IPPROTO_COMP = 108,
> >>>
> >>>     IPPROTO_SCTP = 132,
> >>>
> >>>     IPPROTO_UDPLITE = 136,
> >>>
> >>>     IPPROTO_MPLS = 137,
> >>>
> >>>     IPPROTO_RAW = 255,
> >>>
> >>>     IPPROTO_MAX
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> enum
> >>>   {
> >>>     IPPROTO_HOPOPTS = 0,
> >>>
> >>>     IPPROTO_ROUTING = 43,
> >>>
> >>>     IPPROTO_FRAGMENT = 44,
> >>>
> >>>     IPPROTO_ICMPV6 = 58,
> >>>
> >>>     IPPROTO_NONE = 59,
> >>>
> >>>     IPPROTO_DSTOPTS = 60,
> >>>
> >>>     IPPROTO_MH = 135
> >>>
> >>>   };
> >>>
> >>>
> >>>
> >>> typedef uint16_t in_port_t;
> >>>
> >>>
> >>> enum
> >>>   {
> >>>     IPPORT_ECHO = 7,
> >>>     IPPORT_DISCARD = 9,
> >>>     IPPORT_SYSTAT = 11,
> >>>     IPPORT_DAYTIME = 13,
> >>>     IPPORT_NETSTAT = 15,
> >>>     IPPORT_FTP = 21,
> >>>     IPPORT_TELNET = 23,
> >>>     IPPORT_SMTP = 25,
> >>>     IPPORT_TIMESERVER = 37,
> >>>     IPPORT_NAMESERVER = 42,
> >>>     IPPORT_WHOIS = 43,
> >>>     IPPORT_MTP = 57,
> >>>
> >>>     IPPORT_TFTP = 69,
> >>>     IPPORT_RJE = 77,
> >>>     IPPORT_FINGER = 79,
> >>>     IPPORT_TTYLINK = 87,
> >>>     IPPORT_SUPDUP = 95,
> >>>
> >>>
> >>>     IPPORT_EXECSERVER = 512,
> >>>     IPPORT_LOGINSERVER = 513,
> >>>     IPPORT_CMDSERVER = 514,
> >>>     IPPORT_EFSSERVER = 520,
> >>>
> >>>
> >>>     IPPORT_BIFFUDP = 512,
> >>>     IPPORT_WHOSERVER = 513,
> >>>     IPPORT_ROUTESERVER = 520,
> >>>
> >>>
> >>>     IPPORT_RESERVED = 1024,
> >>>
> >>>
> >>>     IPPORT_USERRESERVED = 5000
> >>>   };
> >>> # 211 "/usr/include/netinet/in.h" 3 4
> >>> struct in6_addr
> >>>   {
> >>>     union
> >>>       {
> >>>  uint8_t __u6_addr8[16];
> >>>
> >>>  uint16_t __u6_addr16[8];
> >>>  uint32_t __u6_addr32[4];
> >>>
> >>>       } __in6_u;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   };
> >>>
> >>>
> >>> extern const struct in6_addr in6addr_any;
> >>> extern const struct in6_addr in6addr_loopback;
> >>> # 239 "/usr/include/netinet/in.h" 3 4
> >>> struct sockaddr_in
> >>>   {
> >>>     sa_family_t sin_family;
> >>>     in_port_t sin_port;
> >>>     struct in_addr sin_addr;
> >>>
> >>>
> >>>     unsigned char sin_zero[sizeof (struct sockaddr) -
> >>>       (sizeof (unsigned short int)) -
> >>>       sizeof (in_port_t) -
> >>>       sizeof (struct in_addr)];
> >>>   };
> >>>
> >>>
> >>>
> >>> struct sockaddr_in6
> >>>   {
> >>>     sa_family_t sin6_family;
> >>>     in_port_t sin6_port;
> >>>     uint32_t sin6_flowinfo;
> >>>     struct in6_addr sin6_addr;
> >>>     uint32_t sin6_scope_id;
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>> struct ip_mreq
> >>>   {
> >>>
> >>>     struct in_addr imr_multiaddr;
> >>>
> >>>
> >>>     struct in_addr imr_interface;
> >>>   };
> >>>
> >>> struct ip_mreq_source
> >>>   {
> >>>
> >>>     struct in_addr imr_multiaddr;
> >>>
> >>>
> >>>     struct in_addr imr_interface;
> >>>
> >>>
> >>>     struct in_addr imr_sourceaddr;
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>> struct ipv6_mreq
> >>>   {
> >>>
> >>>     struct in6_addr ipv6mr_multiaddr;
> >>>
> >>>
> >>>     unsigned int ipv6mr_interface;
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>> struct group_req
> >>>   {
> >>>
> >>>     uint32_t gr_interface;
> >>>
> >>>
> >>>     struct sockaddr_storage gr_group;
> >>>   };
> >>>
> >>> struct group_source_req
> >>>   {
> >>>
> >>>     uint32_t gsr_interface;
> >>>
> >>>
> >>>     struct sockaddr_storage gsr_group;
> >>>
> >>>
> >>>     struct sockaddr_storage gsr_source;
> >>>   };
> >>>
> >>>
> >>>
> >>> struct ip_msfilter
> >>>   {
> >>>
> >>>     struct in_addr imsf_multiaddr;
> >>>
> >>>
> >>>     struct in_addr imsf_interface;
> >>>
> >>>
> >>>     uint32_t imsf_fmode;
> >>>
> >>>
> >>>     uint32_t imsf_numsrc;
> >>>
> >>>     struct in_addr imsf_slist[1];
> >>>   };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct group_filter
> >>>   {
> >>>
> >>>     uint32_t gf_interface;
> >>>
> >>>
> >>>     struct sockaddr_storage gf_group;
> >>>
> >>>
> >>>     uint32_t gf_fmode;
> >>>
> >>>
> >>>     uint32_t gf_numsrc;
> >>>
> >>>     struct sockaddr_storage gf_slist[1];
> >>> };
> >>> # 376 "/usr/include/netinet/in.h" 3 4
> >>> extern uint32_t ntohl (uint32_t __netlong) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__const__));
> >>> extern uint16_t ntohs (uint16_t __netshort)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> extern uint32_t htonl (uint32_t __hostlong)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>> extern uint16_t htons (uint16_t __hostshort)
> >>>      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/bits/byteswap.h" 1 3 4
> >>> # 388 "/usr/include/netinet/in.h" 2 3 4
> >>> # 503 "/usr/include/netinet/in.h" 3 4
> >>> extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>> # 631 "/usr/include/netinet/in.h" 3 4
> >>>
> >>> # 28 "/usr/include/netdb.h" 2 3 4
> >>>
> >>>
> >>>
> >>>
> >>> # 1 "/usr/include/rpc/netdb.h" 1 3 4
> >>> # 42 "/usr/include/rpc/netdb.h" 3 4
> >>> # 1 "/usr/lib/gcc/i686-redhat-linux/6.1.1/include/stddef.h" 1 3 4
> >>> # 43 "/usr/include/rpc/netdb.h" 2 3 4
> >>>
> >>>
> >>>
> >>> struct rpcent
> >>> {
> >>>   char *r_name;
> >>>   char **r_aliases;
> >>>   int r_number;
> >>> };
> >>>
> >>> extern void setrpcent (int __stayopen) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>> extern void endrpcent (void) __attribute__ ((__nothrow__ , __leaf__));
> >>> extern struct rpcent *getrpcbyname (const char *__name) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> extern struct rpcent *getrpcbynumber (int __number) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>> extern struct rpcent *getrpcent (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern int getrpcbyname_r (const char *__name, struct rpcent 
> >>> *__result_buf,
> >>>       char *__buffer, size_t __buflen,
> >>>       struct rpcent **__result) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>> extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
> >>>         char *__buffer, size_t __buflen,
> >>>         struct rpcent **__result) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>> extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
> >>>    size_t __buflen, struct rpcent **__result) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>>
> >>> # 33 "/usr/include/netdb.h" 2 3 4
> >>> # 42 "/usr/include/netdb.h" 3 4
> >>> # 1 "/usr/include/bits/netdb.h" 1 3 4
> >>> # 26 "/usr/include/bits/netdb.h" 3 4
> >>> struct netent
> >>> {
> >>>   char *n_name;
> >>>   char **n_aliases;
> >>>   int n_addrtype;
> >>>   uint32_t n_net;
> >>> };
> >>> # 43 "/usr/include/netdb.h" 2 3 4
> >>> # 53 "/usr/include/netdb.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int *__h_errno_location (void) __attribute__ ((__nothrow__ , 
> >>> __leaf__)) __attribute__ ((__const__));
> >>> # 92 "/usr/include/netdb.h" 3 4
> >>> extern void herror (const char *__str) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>> extern const char *hstrerror (int __err_num) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> struct hostent
> >>> {
> >>>   char *h_name;
> >>>   char **h_aliases;
> >>>   int h_addrtype;
> >>>   int h_length;
> >>>   char **h_addr_list;
> >>>
> >>>
> >>>
> >>> };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void sethostent (int __stay_open);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void endhostent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct hostent *gethostent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t 
> >>> __len,
> >>>           int __type);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct hostent *gethostbyname (const char *__name);
> >>> # 155 "/usr/include/netdb.h" 3 4
> >>> extern struct hostent *gethostbyname2 (const char *__name, int __af);
> >>> # 167 "/usr/include/netdb.h" 3 4
> >>> extern int gethostent_r (struct hostent *__restrict __result_buf,
> >>>     char *__restrict __buf, size_t __buflen,
> >>>     struct hostent **__restrict __result,
> >>>     int *__restrict __h_errnop);
> >>>
> >>> extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t 
> >>> __len,
> >>>        int __type,
> >>>        struct hostent *__restrict __result_buf,
> >>>        char *__restrict __buf, size_t __buflen,
> >>>        struct hostent **__restrict __result,
> >>>        int *__restrict __h_errnop);
> >>>
> >>> extern int gethostbyname_r (const char *__restrict __name,
> >>>        struct hostent *__restrict __result_buf,
> >>>        char *__restrict __buf, size_t __buflen,
> >>>        struct hostent **__restrict __result,
> >>>        int *__restrict __h_errnop);
> >>>
> >>> extern int gethostbyname2_r (const char *__restrict __name, int __af,
> >>>         struct hostent *__restrict __result_buf,
> >>>         char *__restrict __buf, size_t __buflen,
> >>>         struct hostent **__restrict __result,
> >>>         int *__restrict __h_errnop);
> >>> # 198 "/usr/include/netdb.h" 3 4
> >>> extern void setnetent (int __stay_open);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void endnetent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct netent *getnetent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct netent *getnetbyaddr (uint32_t __net, int __type);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct netent *getnetbyname (const char *__name);
> >>> # 237 "/usr/include/netdb.h" 3 4
> >>> extern int getnetent_r (struct netent *__restrict __result_buf,
> >>>    char *__restrict __buf, size_t __buflen,
> >>>    struct netent **__restrict __result,
> >>>    int *__restrict __h_errnop);
> >>>
> >>> extern int getnetbyaddr_r (uint32_t __net, int __type,
> >>>       struct netent *__restrict __result_buf,
> >>>       char *__restrict __buf, size_t __buflen,
> >>>       struct netent **__restrict __result,
> >>>       int *__restrict __h_errnop);
> >>>
> >>> extern int getnetbyname_r (const char *__restrict __name,
> >>>       struct netent *__restrict __result_buf,
> >>>       char *__restrict __buf, size_t __buflen,
> >>>       struct netent **__restrict __result,
> >>>       int *__restrict __h_errnop);
> >>>
> >>>
> >>>
> >>>
> >>> struct servent
> >>> {
> >>>   char *s_name;
> >>>   char **s_aliases;
> >>>   int s_port;
> >>>   char *s_proto;
> >>> };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void setservent (int __stay_open);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void endservent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct servent *getservent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct servent *getservbyname (const char *__name, const char 
> >>> *__proto);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct servent *getservbyport (int __port, const char *__proto);
> >>> # 308 "/usr/include/netdb.h" 3 4
> >>> extern int getservent_r (struct servent *__restrict __result_buf,
> >>>     char *__restrict __buf, size_t __buflen,
> >>>     struct servent **__restrict __result);
> >>>
> >>> extern int getservbyname_r (const char *__restrict __name,
> >>>        const char *__restrict __proto,
> >>>        struct servent *__restrict __result_buf,
> >>>        char *__restrict __buf, size_t __buflen,
> >>>        struct servent **__restrict __result);
> >>>
> >>> extern int getservbyport_r (int __port, const char *__restrict __proto,
> >>>        struct servent *__restrict __result_buf,
> >>>        char *__restrict __buf, size_t __buflen,
> >>>        struct servent **__restrict __result);
> >>>
> >>>
> >>>
> >>>
> >>> struct protoent
> >>> {
> >>>   char *p_name;
> >>>   char **p_aliases;
> >>>   int p_proto;
> >>> };
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void setprotoent (int __stay_open);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void endprotoent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct protoent *getprotoent (void);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct protoent *getprotobyname (const char *__name);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern struct protoent *getprotobynumber (int __proto);
> >>> # 374 "/usr/include/netdb.h" 3 4
> >>> extern int getprotoent_r (struct protoent *__restrict __result_buf,
> >>>      char *__restrict __buf, size_t __buflen,
> >>>      struct protoent **__restrict __result);
> >>>
> >>> extern int getprotobyname_r (const char *__restrict __name,
> >>>         struct protoent *__restrict __result_buf,
> >>>         char *__restrict __buf, size_t __buflen,
> >>>         struct protoent **__restrict __result);
> >>>
> >>> extern int getprotobynumber_r (int __proto,
> >>>           struct protoent *__restrict __result_buf,
> >>>           char *__restrict __buf, size_t __buflen,
> >>>           struct protoent **__restrict __result);
> >>> # 395 "/usr/include/netdb.h" 3 4
> >>> extern int setnetgrent (const char *__netgroup);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern void endnetgrent (void);
> >>> # 412 "/usr/include/netdb.h" 3 4
> >>> extern int getnetgrent (char **__restrict __hostp,
> >>>    char **__restrict __userp,
> >>>    char **__restrict __domainp);
> >>> # 423 "/usr/include/netdb.h" 3 4
> >>> extern int innetgr (const char *__netgroup, const char *__host,
> >>>       const char *__user, const char *__domain);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getnetgrent_r (char **__restrict __hostp,
> >>>      char **__restrict __userp,
> >>>      char **__restrict __domainp,
> >>>      char *__restrict __buffer, size_t __buflen);
> >>> # 451 "/usr/include/netdb.h" 3 4
> >>> extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
> >>>    const char *__restrict __locuser,
> >>>    const char *__restrict __remuser,
> >>>    const char *__restrict __cmd, int *__restrict __fd2p);
> >>> # 463 "/usr/include/netdb.h" 3 4
> >>> extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
> >>>       const char *__restrict __locuser,
> >>>       const char *__restrict __remuser,
> >>>       const char *__restrict __cmd, int *__restrict __fd2p,
> >>>       sa_family_t __af);
> >>> # 479 "/usr/include/netdb.h" 3 4
> >>> extern int rexec (char **__restrict __ahost, int __rport,
> >>>     const char *__restrict __name,
> >>>     const char *__restrict __pass,
> >>>     const char *__restrict __cmd, int *__restrict __fd2p);
> >>> # 491 "/usr/include/netdb.h" 3 4
> >>> extern int rexec_af (char **__restrict __ahost, int __rport,
> >>>        const char *__restrict __name,
> >>>        const char *__restrict __pass,
> >>>        const char *__restrict __cmd, int *__restrict __fd2p,
> >>>        sa_family_t __af);
> >>> # 505 "/usr/include/netdb.h" 3 4
> >>> extern int ruserok (const char *__rhost, int __suser,
> >>>       const char *__remuser, const char *__locuser);
> >>> # 515 "/usr/include/netdb.h" 3 4
> >>> extern int ruserok_af (const char *__rhost, int __suser,
> >>>          const char *__remuser, const char *__locuser,
> >>>          sa_family_t __af);
> >>> # 528 "/usr/include/netdb.h" 3 4
> >>> extern int iruserok (uint32_t __raddr, int __suser,
> >>>        const char *__remuser, const char *__locuser);
> >>> # 539 "/usr/include/netdb.h" 3 4
> >>> extern int iruserok_af (const void *__raddr, int __suser,
> >>>    const char *__remuser, const char *__locuser,
> >>>    sa_family_t __af);
> >>> # 551 "/usr/include/netdb.h" 3 4
> >>> extern int rresvport (int *__alport);
> >>> # 560 "/usr/include/netdb.h" 3 4
> >>> extern int rresvport_af (int *__alport, sa_family_t __af);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> struct addrinfo
> >>> {
> >>>   int ai_flags;
> >>>   int ai_family;
> >>>   int ai_socktype;
> >>>   int ai_protocol;
> >>>   socklen_t ai_addrlen;
> >>>   struct sockaddr *ai_addr;
> >>>   char *ai_canonname;
> >>>   struct addrinfo *ai_next;
> >>> };
> >>> # 662 "/usr/include/netdb.h" 3 4
> >>> extern int getaddrinfo (const char *__restrict __name,
> >>>    const char *__restrict __service,
> >>>    const struct addrinfo *__restrict __req,
> >>>    struct addrinfo **__restrict __pai);
> >>>
> >>>
> >>> extern void freeaddrinfo (struct addrinfo *__ai) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern const char *gai_strerror (int __ecode) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int getnameinfo (const struct sockaddr *__restrict __sa,
> >>>    socklen_t __salen, char *__restrict __host,
> >>>    socklen_t __hostlen, char *__restrict __serv,
> >>>    socklen_t __servlen, int __flags);
> >>> # 713 "/usr/include/netdb.h" 3 4
> >>>
> >>> # 81 "machine.c" 2
> >>>
> >>> # 1 "/usr/include/arpa/inet.h" 1 3 4
> >>> # 30 "/usr/include/arpa/inet.h" 3 4
> >>>
> >>>
> >>>
> >>>
> >>> extern in_addr_t inet_addr (const char *__cp) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>> extern in_addr_t inet_lnaof (struct in_addr __in) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>> extern in_addr_t inet_netof (struct in_addr __in) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern in_addr_t inet_network (const char *__cp) __attribute__ 
> >>> ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern char *inet_ntoa (struct in_addr __in) __attribute__ ((__nothrow__ 
> >>> , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int inet_pton (int __af, const char *__restrict __cp,
> >>>         void *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern const char *inet_ntop (int __af, const void *__restrict __cp,
> >>>          char *__restrict __buf, socklen_t __len)
> >>>      __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> extern int inet_aton (const char *__cp, struct in_addr *__inp) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) 
> >>> __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
> >>>        char *__buf, size_t __len) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern int inet_net_pton (int __af, const char *__cp,
> >>>      void *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>>
> >>> extern unsigned int inet_nsap_addr (const char *__cp,
> >>>         unsigned char *__buf, int __len) __attribute__ ((__nothrow__ , 
> >>> __leaf__));
> >>>
> >>>
> >>>
> >>> extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
> >>>         char *__buf) __attribute__ ((__nothrow__ , __leaf__));
> >>>
> >>>
> >>>
> >>> # 83 "machine.c" 2
> >>> # 135 "machine.c"
> >>>
> >>> # 135 "machine.c"
> >>> static PlLong start_user_time = 0;
> >>> static PlLong start_system_time = 0;
> >>> static PlLong start_real_time = 0;
> >>>
> >>> static int cur_seed = 1;
> >>> # 150 "machine.c"
> >>> static char *Host_Name_From_Alias(struct hostent *host_entry);
> >>> # 167 "machine.c"
> >>> void
> >>> Pl_Init_Machine(void)
> >>> {
> >>>   tzset();
> >>>
> >>>   start_user_time = Pl_M_User_Time();
> >>>   start_system_time = Pl_M_System_Time();
> >>>   start_real_time = Pl_M_Real_Time();
> >>>
> >>>
> >>>   mallopt(
> >>> # 177 "machine.c" 3 4
> >>>          -4
> >>> # 177 "machine.c"
> >>>                    , 0);
> >>>
> >>>
> >>>   Pl_Init_Machine1();
> >>> }
> >>> # 190 "machine.c"
> >>> char *
> >>> Pl_M_Sys_Err_String(int ret_val)
> >>> {
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   char *str;
> >>>   static char buff[64];
> >>> # 226 "machine.c"
> >>>   str = strerror(
> >>> # 226 "machine.c" 3 4
> >>>                 (*__errno_location ())
> >>> # 226 "machine.c"
> >>>                      );
> >>>
> >>>
> >>>   if (str)
> >>>     return str;
> >>>
> >>>   sprintf(buff, "Unknown error (%d)", 
> >>> # 232 "machine.c" 3 4
> >>>                                   (*__errno_location ())
> >>> # 232 "machine.c"
> >>>                                        );
> >>>   return buff;
> >>> }
> >>> # 244 "machine.c"
> >>> PlLong
> >>> Pl_M_User_Time(void)
> >>> {
> >>>   PlLong user_time;
> >>>
> >>>
> >>>   struct rusage rsr_usage;
> >>>
> >>>   getrusage(
> >>> # 252 "machine.c" 3 4
> >>>            RUSAGE_SELF
> >>> # 252 "machine.c"
> >>>                       , &rsr_usage);
> >>>
> >>>   user_time = (rsr_usage.ru_utime.tv_sec * 1000) +
> >>>     (rsr_usage.ru_utime.tv_usec / 1000);
> >>> # 275 "machine.c"
> >>>   return user_time - start_user_time;
> >>> }
> >>> # 286 "machine.c"
> >>> PlLong
> >>> Pl_M_System_Time(void)
> >>> {
> >>>   PlLong system_time;
> >>>
> >>>
> >>>   struct rusage rsr_usage;
> >>>
> >>>   getrusage(
> >>> # 294 "machine.c" 3 4
> >>>            RUSAGE_SELF
> >>> # 294 "machine.c"
> >>>                       , &rsr_usage);
> >>>
> >>>   system_time = (rsr_usage.ru_stime.tv_sec * 1000) +
> >>>     (rsr_usage.ru_stime.tv_usec / 1000);
> >>> # 317 "machine.c"
> >>>   return system_time - start_system_time;
> >>> }
> >>> # 328 "machine.c"
> >>> PlLong
> >>> Pl_M_Real_Time(void)
> >>> {
> >>>   PlLong real_time;
> >>>
> >>>
> >>>   struct timeval tv;
> >>>
> >>>   gettimeofday(&tv, 
> >>> # 336 "machine.c" 3 4
> >>>                    ((void *)0)
> >>> # 336 "machine.c"
> >>>                        );
> >>>   real_time = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
> >>> # 350 "machine.c"
> >>>   return real_time - start_real_time;
> >>> }
> >>> # 367 "machine.c"
> >>> void
> >>> Pl_M_Randomize(void)
> >>> {
> >>>   static int count = 0;
> >>>
> >>>
> >>>
> >>>   struct timeval tv;
> >>>   int seed;
> >>>
> >>>   gettimeofday(&tv, 
> >>> # 377 "machine.c" 3 4
> >>>                    ((void *)0)
> >>> # 377 "machine.c"
> >>>                        );
> >>>   seed = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
> >>>
> >>>   count = (count + rand()) % 0xFFFF;
> >>>   seed = seed ^ (getpid() << (seed & 0xFF));
> >>>   seed *= count;
> >>>   seed = seed & 0xFFFFFF;
> >>>
> >>>   Pl_M_Set_Seed(seed);
> >>> }
> >>> # 395 "machine.c"
> >>> void
> >>> Pl_M_Set_Seed(int n)
> >>> {
> >>>   cur_seed = n;
> >>>   srand(cur_seed);
> >>> }
> >>> # 409 "machine.c"
> >>> int
> >>> Pl_M_Get_Seed(void)
> >>> {
> >>>   return cur_seed;
> >>> }
> >>> # 423 "machine.c"
> >>> int
> >>> Pl_M_Random_Integer(int n)
> >>> {
> >>>   return (int) ((double) n * rand() / (
> >>> # 426 "machine.c" 3 4
> >>>                                       2147483647 
> >>> # 426 "machine.c"
> >>>                                                + 1.0));
> >>> }
> >>> # 437 "machine.c"
> >>> double
> >>> Pl_M_Random_Float(double n)
> >>> {
> >>>   return n * rand() / (
> >>> # 440 "machine.c" 3 4
> >>>                       2147483647 
> >>> # 440 "machine.c"
> >>>                                + 1.0);
> >>> }
> >>> # 451 "machine.c"
> >>> char *
> >>> Pl_M_Host_Name_From_Name(char *host_name)
> >>> {
> >>>   static char buff[4096];
> >>>
> >>>
> >>>   struct hostent *host_entry;
> >>>
> >>>
> >>>   if (host_name == 
> >>> # 460 "machine.c" 3 4
> >>>                   ((void *)0)
> >>> # 460 "machine.c"
> >>>                       )
> >>>     {
> >>>       PlLong length = sizeof(buff);
> >>>       host_name = buff;
> >>>
> >>>
> >>>
> >>>       if (gethostname(buff, length))
> >>>
> >>>         {
> >>>           strcpy(buff, "unknown host name");
> >>>           goto finish;
> >>>         }
> >>>     }
> >>>
> >>>   if (strchr(host_name, '.') != 
> >>> # 475 "machine.c" 3 4
> >>>                                ((void *)0)
> >>> # 475 "machine.c"
> >>>                                    )
> >>>     goto finish;
> >>>
> >>>
> >>>
> >>>   host_entry = gethostbyname(host_name);
> >>>   if (host_entry == 
> >>> # 481 "machine.c" 3 4
> >>>                    ((void *)0)
> >>> # 481 "machine.c"
> >>>                        )
> >>>     goto finish;
> >>>
> >>>   host_name = Host_Name_From_Alias(host_entry);
> >>>
> >>>
> >>>
> >>> finish:
> >>>   return host_name;
> >>> }
> >>> # 499 "machine.c"
> >>> char *
> >>> Pl_M_Host_Name_From_Adr(char *host_address)
> >>> {
> >>>
> >>>   struct hostent *host_entry;
> >>>   struct in_addr iadr;
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   if (inet_aton(host_address, &iadr) == 0)
> >>>
> >>>     return 0;
> >>>
> >>>   host_entry = gethostbyaddr((char *) &iadr, sizeof(iadr), 
> >>> # 515 "machine.c" 3 4
> >>>                                                           2
> >>> # 515 "machine.c"
> >>>                                                                  );
> >>>   if (host_entry == 
> >>> # 516 "machine.c" 3 4
> >>>                    ((void *)0)
> >>> # 516 "machine.c"
> >>>                        )
> >>>     return 
> >>> # 517 "machine.c" 3 4
> >>>           ((void *)0)
> >>> # 517 "machine.c"
> >>>               ;
> >>>
> >>>   return Host_Name_From_Alias(host_entry);
> >>>
> >>>
> >>>
> >>> }
> >>> # 534 "machine.c"
> >>> static char *
> >>> Host_Name_From_Alias(struct hostent *host_entry)
> >>> {
> >>>   char *name;
> >>>   char **alias;
> >>>   char *p;
> >>>
> >>>   name = (char *) host_entry->h_name;
> >>>   alias = host_entry->h_aliases;
> >>>   while ((p = strchr(name, '.')) == 
> >>> # 543 "machine.c" 3 4
> >>>                                    ((void *)0) 
> >>> # 543 "machine.c"
> >>>                                         && *alias)
> >>>     name = *alias++;
> >>>
> >>>   if (p)
> >>>     return name;
> >>>
> >>>   return (char *) host_entry->h_name;
> >>> }
> >>> # 561 "machine.c"
> >>> Bool
> >>> Pl_M_Set_Working_Dir(char *path)
> >>> {
> >>>   char *new_path = Pl_M_Absolute_Path_Name(path);
> >>>
> >>>   return (new_path != 
> >>> # 566 "machine.c" 3 4
> >>>                      ((void *)0) 
> >>> # 566 "machine.c"
> >>>                           && chdir(new_path) == 0);
> >>> }
> >>> # 576 "machine.c"
> >>> char *
> >>> Pl_M_Get_Working_Dir(void)
> >>> {
> >>>   static char cur_work_dir[
> >>> # 579 "machine.c" 3 4
> >>>                           4096
> >>> # 579 "machine.c"
> >>>                                     ];
> >>>
> >>>   if (getcwd(cur_work_dir, sizeof(cur_work_dir) - 1) == 
> >>> # 581 "machine.c" 3 4
> >>>                                                        ((void *)0)
> >>> # 581 "machine.c"
> >>>                                                            )
> >>>     strcpy(cur_work_dir, ".");
> >>>   return cur_work_dir;
> >>> }
> >>> # 594 "machine.c"
> >>> char *
> >>> Pl_M_Absolute_Path_Name(char *src)
> >>> {
> >>>   static char buff[2][
> >>> # 597 "machine.c" 3 4
> >>>                      4096
> >>> # 597 "machine.c"
> >>>                                ];
> >>>   int res = 0;
> >>>   char *dst;
> >>>   char *p, *q;
> >>>   char c;
> >>>
> >>>   dst = buff[res];
> >>>   while ((*dst++ = *src))
> >>>     {
> >>>       c = *src++;
> >>>       if (c == '$'
> >>>
> >>>
> >>>
> >>>         )
> >>>         {
> >>>           p = dst;
> >>>           while (
> >>> # 614 "machine.c" 3 4
> >>>                 ((*__ctype_b_loc ())[(int) ((
> >>> # 614 "machine.c"
> >>>                 *src
> >>> # 614 "machine.c" 3 4
> >>>                 ))] & (unsigned short int) _ISalnum) 
> >>> # 614 "machine.c"
> >>>                               || *src == '_')
> >>>             *dst++ = *src++;
> >>>
> >>>
> >>>
> >>>
> >>>           *dst = '\0';
> >>>           q = getenv(p);
> >>>           if (q)
> >>>             {
> >>>               p--;
> >>>               strcpy(p, q);
> >>>               dst = p + strlen(p);
> >>>
> >>>
> >>>
> >>>
> >>>             }
> >>>
> >>>
> >>>
> >>>
> >>>         }
> >>>     }
> >>>   *dst = '\0';
> >>>
> >>>   if (buff[res][0] == '~')
> >>>     {
> >>>       if (((buff[res][1]) == '/' || (buff[res][1]) == '/') || 
> >>> buff[res][1] == '\0')
> >>>         {
> >>>    q = 
> >>> # 644 "machine.c" 3 4
> >>>       ((void *)0)
> >>> # 644 "machine.c"
> >>>           ;;
> >>>           if ((p = getenv("HOME")) == 
> >>> # 645 "machine.c" 3 4
> >>>                                      ((void *)0)
> >>> # 645 "machine.c"
> >>>                                          )
> >>>      {
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>        return 
> >>> # 652 "machine.c" 3 4
> >>>              ((void *)0)
> >>> # 652 "machine.c"
> >>>                  ;
> >>>
> >>>      }
> >>>    if (q == 
> >>> # 655 "machine.c" 3 4
> >>>            ((void *)0)
> >>> # 655 "machine.c"
> >>>                )
> >>>      q = "";
> >>>           sprintf(buff[1 - res], "%s%s/%s", q, p, buff[res] + 1);
> >>>           res = 1 - res;
> >>>         }
> >>>
> >>>       else
> >>>         {
> >>>           struct passwd *pw;
> >>>
> >>>           p = buff[res] + 1;
> >>>           while (*p && !((*p) == '/' || (*p) == '/'))
> >>>             p++;
> >>>
> >>>           buff[res][0] = *p;
> >>>           *p = '\0';
> >>>           if ((pw = getpwnam(buff[res] + 1)) == 
> >>> # 671 "machine.c" 3 4
> >>>                                                ((void *)0)
> >>> # 671 "machine.c"
> >>>                                                    )
> >>>             return 
> >>> # 672 "machine.c" 3 4
> >>>                   ((void *)0)
> >>> # 672 "machine.c"
> >>>                       ;
> >>>
> >>>           *p = buff[res][0];
> >>>
> >>>           sprintf(buff[1 - res], "%s/%s", pw->pw_dir, p);
> >>>           res = 1 - res;
> >>>         }
> >>>
> >>>     }
> >>>
> >>>   if (strcmp(buff[res], "user") == 0)
> >>>     return buff[res];
> >>> # 706 "machine.c"
> >>>   if (buff[res][0] != '/')
> >>>     {
> >>>       sprintf(buff[1 - res], "%s/%s", Pl_M_Get_Working_Dir(), buff[res]);
> >>>       res = 1 - res;
> >>>     }
> >>>
> >>>   src = buff[res];
> >>>   res = 1 - res;
> >>>   dst = buff[res];
> >>>
> >>>   while ((*dst++ = *src))
> >>>     {
> >>>       if (*src++ != '/')
> >>>         continue;
> >>>
> >>>     collapse:
> >>>       while (*src == '/')
> >>>         src++;
> >>>
> >>>       if (*src != '.')
> >>>         continue;
> >>>
> >>>       if (src[1] == '/' || src[1] == '\0')
> >>>         {
> >>>           src++;
> >>>           goto collapse;
> >>>         }
> >>>
> >>>       if (src[1] != '.' || (src[2] != '/' && src[2] != '\0'))
> >>>         continue;
> >>>
> >>>       src += 2;
> >>>       p = dst - 2;
> >>>       while (p >= buff[res] && *p != '/')
> >>>         p--;
> >>>
> >>>       if (p < buff[res])
> >>>         return 
> >>> # 743 "machine.c" 3 4
> >>>               ((void *)0)
> >>> # 743 "machine.c"
> >>>                   ;
> >>>
> >>>       dst = p;
> >>>     }
> >>>
> >>>   dst--;
> >>> # 759 "machine.c"
> >>>   if (dst - buff[res] > 1 && ((dst[-1]) == '/' || (dst[-1]) == '/'))
> >>>     dst[-1] = '\0';
> >>>
> >>>   return buff[res];
> >>> }
> >>> # 773 "machine.c"
> >>> Bool
> >>> Pl_M_Is_Absolute_File_Name(char *path)
> >>> {
> >>>   if (((*path) == '/' || (*path) == '/'))
> >>>     return 1;
> >>> # 795 "machine.c"
> >>>   return 0;
> >>> }
> >>> # 829 "machine.c"
> >>> char *
> >>> Pl_M_Decompose_File_Name(char *path, Bool del_trail_slashes, char **base, 
> >>> char **suffix)
> >>> {
> >>>   static char buff_dir[
> >>> # 832 "machine.c" 3 4
> >>>                       4096
> >>> # 832 "machine.c"
> >>>                                 ];
> >>>   static char buff_base[
> >>> # 833 "machine.c" 3 4
> >>>                        4096
> >>> # 833 "machine.c"
> >>>                                  ];
> >>>   int dir_start_pos = 0;
> >>> # 852 "machine.c"
> >>>   char *p;
> >>>
> >>>   strcpy(buff_dir, path);
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   do { char *_ptr; for((p) = 
> >>> # 860 "machine.c" 3 4
> >>>  ((void *)0)
> >>> # 860 "machine.c"
> >>>  , _ptr = (buff_dir); *_ptr; _ptr++) if (((*_ptr) == '/' || (*_ptr) == 
> >>> '/')) (p) = _ptr; } while(0);
> >>>
> >>>   p = (p == 
> >>> # 862 "machine.c" 3 4
> >>>            ((void *)0)
> >>> # 862 "machine.c"
> >>>                ) ? buff_dir + dir_start_pos : p + 1;
> >>>
> >>>   strcpy(buff_base, p);
> >>>   *p = '\0';
> >>>
> >>>   if ((p = strrchr(buff_base, '.')) != 
> >>> # 867 "machine.c" 3 4
> >>>                                       ((void *)0)
> >>> # 867 "machine.c"
> >>>                                           )
> >>>     *suffix = p;
> >>>   else
> >>>     *suffix = buff_base + strlen(buff_base);
> >>>
> >>>
> >>>
> >>>   if (del_trail_slashes)
> >>>     {
> >>>       if (buff_dir[dir_start_pos] == '\0')
> >>>  strcat(buff_dir, ".");
> >>>       else
> >>>  {
> >>>    int len = strlen(buff_dir);
> >>>    while(--len >= dir_start_pos && ((buff_dir[len]) == '/' || 
> >>> (buff_dir[len]) == '/'))
> >>>      ;
> >>>
> >>>    if (len < dir_start_pos)
> >>>      len = dir_start_pos;
> >>>    buff_dir[len + 1] = '\0';
> >>>  }
> >>>     }
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>
> >>>   *base = buff_base;
> >>>
> >>>   return buff_dir;
> >>> }
> >>
> >>> _______________________________________________
> >>> Bug-prolog mailing list
> >>> address@hidden
> >>> https://lists.gnu.org/mailman/listinfo/bug-prolog
> >>
> >>
> > 
> 
> _______________________________________________
> Bug-prolog mailing list
> address@hidden
> https://lists.gnu.org/mailman/listinfo/bug-prolog

-- 
Matthew Carter
address@hidden



reply via email to

[Prev in Thread] Current Thread [Next in Thread]