Mock Version: 1.4.21
Mock Version: 1.4.21
ENTER ['do_with_status'](['bash', '--login', '-c', '/usr/bin/rpmbuild -bs --target riscv64 --nodeps /builddir/build/SPECS/libtpcimgio.spec'], chrootPath='/var/lib/mock/f33-build-279218-51688/root'env={'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'en_US.UTF-8'}shell=Falselogger=<mockbuild.trace_decorator.getLog object at 0x3fe229d700>timeout=432000uid=987gid=135user='mockbuild'nspawn_args=[]unshare_net=TrueprintOutput=False)
Executing command: ['bash', '--login', '-c', '/usr/bin/rpmbuild -bs --target riscv64 --nodeps /builddir/build/SPECS/libtpcimgio.spec'] with env {'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'en_US.UTF-8'} and shell False
Building target platforms: riscv64
Building for target riscv64
setting SOURCE_DATE_EPOCH=1564012800
Wrote: /builddir/build/SRPMS/libtpcimgio-1.5.10-20.fc33.src.rpm
Child return code was: 0
ENTER ['do_with_status'](['bash', '--login', '-c', '/usr/bin/rpmbuild -bb --target riscv64 --nodeps /builddir/build/SPECS/libtpcimgio.spec'], chrootPath='/var/lib/mock/f33-build-279218-51688/root'env={'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'en_US.UTF-8'}shell=Falselogger=<mockbuild.trace_decorator.getLog object at 0x3fe229d700>timeout=432000uid=987gid=135user='mockbuild'nspawn_args=[]unshare_net=TrueprintOutput=False)
Executing command: ['bash', '--login', '-c', '/usr/bin/rpmbuild -bb --target riscv64 --nodeps /builddir/build/SPECS/libtpcimgio.spec'] with env {'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'en_US.UTF-8'} and shell False
Building target platforms: riscv64
Building for target riscv64
setting SOURCE_DATE_EPOCH=1564012800
Executing(%prep): /bin/sh -e /var/tmp/rpm-tmp.klqQNE
+ umask 022
+ cd /builddir/build/BUILD
+ cd /builddir/build/BUILD
+ rm -rf libtpcimgio
+ /usr/bin/unzip -qq /builddir/build/SOURCES/libtpcimgio_1_5_10_src.zip
+ STATUS=0
+ '[' 0 -ne 0 ']'
+ cd libtpcimgio
+ /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w .
+ echo 'Patch #0 (libtpcimgio-add-header.patch):'
Patch #0 (libtpcimgio-add-header.patch):
+ /usr/bin/patch --no-backup-if-mismatch -p1 --fuzz=0
patching file ecat7h.c
patching file imgunit.c
Patch #1 (libtpcimgio-shared.patch):
+ echo 'Patch #1 (libtpcimgio-shared.patch):'
+ /usr/bin/patch --no-backup-if-mismatch -p1 -b --suffix .shared --fuzz=0
patching file Makefile
+ sed -i '/^CFLAGS/d' Makefile
+ dos2unix -k History Readme TODO
dos2unix: converting file History to Unix format...
dos2unix: converting file Readme to Unix format...
dos2unix: converting file TODO to Unix format...
+ iconv -f ISO_8859-1 -t utf8 -o History.new History
+ mv -f History.new History
+ RPM_EC=0
++ jobs -p
+ exit 0
Executing(%build): /bin/sh -e /var/tmp/rpm-tmp.FeypgC
+ umask 022
+ cd /builddir/build/BUILD
+ cd libtpcimgio
+ export 'CFLAGS=-O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC'
+ CFLAGS='-O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC'
+ export 'CXXFLAGS=-O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fPIC -DPIC'
+ CXXFLAGS='-O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fPIC -DPIC'
+ make -j4
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat63r.o ecat63r.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat63w.o ecat63w.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat63p.o ecat63p.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat63ml.o ecat63ml.c
ecat63ml.c: In function 'ecat63ReadMatlist':
ecat63ml.c:99:58: warning: variable 'nr_used' set but not used [-Wunused-but-set-variable]
   99 |   int blk=MatFirstDirBlk, next_blk=0, nr_free, prev_blk, nr_used;
      |                                                          ^~~~~~~
ecat63ml.c:99:48: warning: variable 'prev_blk' set but not used [-Wunused-but-set-variable]
   99 |   int blk=MatFirstDirBlk, next_blk=0, nr_free, prev_blk, nr_used;
      |                                                ^~~~~~~~
ecat63ml.c:99:39: warning: variable 'nr_free' set but not used [-Wunused-but-set-variable]
   99 |   int blk=MatFirstDirBlk, next_blk=0, nr_free, prev_blk, nr_used;
      |                                       ^~~~~~~
ecat63p.c: In function 'ecat63PrintImageheader':
ecat63p.c:135:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
  135 |   for(i=0; i<6; i++) fprintf(fp, " %g", h->filter_params[i]); fprintf(fp, "\n");
      |   ^~~
ecat63p.c:135:63: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
  135 |   for(i=0; i<6; i++) fprintf(fp, " %g", h->filter_params[i]); fprintf(fp, "\n");
      |                                                               ^~~~~~~
ecat63p.c: In function 'ecat63PrintScanheader':
ecat63p.c:168:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
  168 |   for(i=0; i<16; i++) fprintf(fp, " %8.0f", h->cor_singles[i]); printf("\n");
      |   ^~~
ecat63p.c:168:65: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
  168 |   for(i=0; i<16; i++) fprintf(fp, " %8.0f", h->cor_singles[i]); printf("\n");
      |                                                                 ^~~~~~
ecat63p.c:170:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
  170 |   for(i=0; i<16; i++) fprintf(fp, " %8.0f", h->uncor_singles[i]); printf("\n");
      |   ^~~
ecat63p.c:170:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
  170 |   for(i=0; i<16; i++) fprintf(fp, " %8.0f", h->uncor_singles[i]); printf("\n");
      |                                                                   ^~~~~~
ecat63w.c: In function 'ecat63WriteMatdata':
ecat63w.c:632:35: warning: variable 'little' set but not used [-Wunused-but-set-variable]
  632 |   int i, blkNr, dataSize, byteNr, little;
      |                                   ^~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat7r.o ecat7r.c
ecat7r.c: In function 'ecat7ReadMainheader':
ecat7r.c:95:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
   95 |   if(little) swabip(buf+46, 2); memcpy(&h->sw_version, buf+46, 2);
      |   ^~
ecat7r.c:95:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
   95 |   if(little) swabip(buf+46, 2); memcpy(&h->sw_version, buf+46, 2);
      |                                 ^~~~~~
ecat7r.c:96:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
   96 |   if(little) swabip(buf+48, 2); memcpy(&h->system_type, buf+48, 2);
      |   ^~
ecat7r.c:96:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
   96 |   if(little) swabip(buf+48, 2); memcpy(&h->system_type, buf+48, 2);
      |                                 ^~~~~~
ecat7r.c:97:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
   97 |   if(little) swabip(buf+50, 2); memcpy(&h->file_type, buf+50, 2);
      |   ^~
ecat7r.c:97:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
   97 |   if(little) swabip(buf+50, 2); memcpy(&h->file_type, buf+50, 2);
      |                                 ^~~~~~
ecat7r.c:99:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
   99 |   if(little) swawbip(buf+62, 4); memcpy(&h->scan_start_time, buf+62, 4);
      |   ^~
ecat7r.c:99:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
   99 |   if(little) swawbip(buf+62, 4); memcpy(&h->scan_start_time, buf+62, 4);
      |                                  ^~~~~~
ecat7r.c:101:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  101 |   if(little) swawbip(buf+74, 4); memcpy(&h->isotope_halflife, buf+74, 4);
      |   ^~
ecat7r.c:101:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  101 |   if(little) swawbip(buf+74, 4); memcpy(&h->isotope_halflife, buf+74, 4);
      |                                  ^~~~~~
ecat7r.c:103:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  103 |   if(little) swawbip(buf+110, 4); memcpy(&h->gantry_tilt, buf+110, 4);
      |   ^~
ecat7r.c:103:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  103 |   if(little) swawbip(buf+110, 4); memcpy(&h->gantry_tilt, buf+110, 4);
      |                                   ^~~~~~
ecat7r.c:104:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  104 |   if(little) swawbip(buf+114, 4); memcpy(&h->gantry_rotation, buf+114, 4);
      |   ^~
ecat7r.c:104:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  104 |   if(little) swawbip(buf+114, 4); memcpy(&h->gantry_rotation, buf+114, 4);
      |                                   ^~~~~~
ecat7r.c:105:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  105 |   if(little) swawbip(buf+118, 4); memcpy(&h->bed_elevation, buf+118, 4);
      |   ^~
ecat7r.c:105:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  105 |   if(little) swawbip(buf+118, 4); memcpy(&h->bed_elevation, buf+118, 4);
      |                                   ^~~~~~
ecat7r.c:106:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  106 |   if(little) swawbip(buf+122, 4); memcpy(&h->intrinsic_tilt, buf+122, 4);
      |   ^~
ecat7r.c:106:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  106 |   if(little) swawbip(buf+122, 4); memcpy(&h->intrinsic_tilt, buf+122, 4);
      |                                   ^~~~~~
ecat7r.c:107:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  107 |   if(little) swabip(buf+126, 2); memcpy(&h->wobble_speed, buf+126, 2);
      |   ^~
ecat7r.c:107:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  107 |   if(little) swabip(buf+126, 2); memcpy(&h->wobble_speed, buf+126, 2);
      |                                  ^~~~~~
ecat7r.c:108:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  108 |   if(little) swabip(buf+128, 2); memcpy(&h->transm_source_type, buf+128, 2);
      |   ^~
ecat7r.c:108:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  108 |   if(little) swabip(buf+128, 2); memcpy(&h->transm_source_type, buf+128, 2);
      |                                  ^~~~~~
ecat7r.c:109:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  109 |   if(little) swawbip(buf+130, 4); memcpy(&h->distance_scanned, buf+130, 4);
      |   ^~
ecat7r.c:109:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  109 |   if(little) swawbip(buf+130, 4); memcpy(&h->distance_scanned, buf+130, 4);
      |                                   ^~~~~~
ecat7r.c:110:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  110 |   if(little) swawbip(buf+134, 4); memcpy(&h->transaxial_fov, buf+134, 4);
      |   ^~
ecat7r.c:110:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  110 |   if(little) swawbip(buf+134, 4); memcpy(&h->transaxial_fov, buf+134, 4);
      |                                   ^~~~~~
ecat7r.c:111:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  111 |   if(little) swabip(buf+138, 2); memcpy(&h->angular_compression, buf+138, 2);
      |   ^~
ecat7r.c:111:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  111 |   if(little) swabip(buf+138, 2); memcpy(&h->angular_compression, buf+138, 2);
      |                                  ^~~~~~
ecat7r.c:112:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  112 |   if(little) swabip(buf+140, 2); memcpy(&h->coin_samp_mode, buf+140, 2);
      |   ^~
ecat7r.c:112:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  112 |   if(little) swabip(buf+140, 2); memcpy(&h->coin_samp_mode, buf+140, 2);
      |                                  ^~~~~~
ecat7r.c:113:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  113 |   if(little) swabip(buf+142, 2); memcpy(&h->axial_samp_mode, buf+142, 2);
      |   ^~
ecat7r.c:113:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  113 |   if(little) swabip(buf+142, 2); memcpy(&h->axial_samp_mode, buf+142, 2);
      |                                  ^~~~~~
ecat7r.c:114:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  114 |   if(little) swawbip(buf+144, 4); memcpy(&h->ecat_calibration_factor, buf+144, 4);
      |   ^~
ecat7r.c:114:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  114 |   if(little) swawbip(buf+144, 4); memcpy(&h->ecat_calibration_factor, buf+144, 4);
      |                                   ^~~~~~
ecat7r.c:115:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  115 |   if(little) swabip(buf+148, 2); memcpy(&h->calibration_units, buf+148, 2);
      |   ^~
ecat7r.c:115:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  115 |   if(little) swabip(buf+148, 2); memcpy(&h->calibration_units, buf+148, 2);
      |                                  ^~~~~~
ecat7r.c:116:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  116 |   if(little) swabip(buf+150, 2); memcpy(&h->calibration_units_label, buf+150, 2);
      |   ^~
ecat7r.c:116:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  116 |   if(little) swabip(buf+150, 2); memcpy(&h->calibration_units_label, buf+150, 2);
      |                                  ^~~~~~
ecat7r.c:117:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  117 |   if(little) swabip(buf+152, 2); memcpy(&h->compression_code, buf+152, 2);
      |   ^~
ecat7r.c:117:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  117 |   if(little) swabip(buf+152, 2); memcpy(&h->compression_code, buf+152, 2);
      |                                  ^~~~~~
ecat7r.c:123:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  123 |   if(little) swawbip(buf+216, 4); memcpy(&h->patient_age, buf+216, 4);
      |   ^~
ecat7r.c:123:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  123 |   if(little) swawbip(buf+216, 4); memcpy(&h->patient_age, buf+216, 4);
      |                                   ^~~~~~
ecat7r.c:124:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  124 |   if(little) swawbip(buf+220, 4); memcpy(&h->patient_height, buf+220, 4);
      |   ^~
ecat7r.c:124:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  124 |   if(little) swawbip(buf+220, 4); memcpy(&h->patient_height, buf+220, 4);
      |                                   ^~~~~~
ecat7r.c:125:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  125 |   if(little) swawbip(buf+224, 4); memcpy(&h->patient_weight, buf+224, 4);
      |   ^~
ecat7r.c:125:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  125 |   if(little) swawbip(buf+224, 4); memcpy(&h->patient_weight, buf+224, 4);
      |                                   ^~~~~~
ecat7r.c:126:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  126 |   if(little) swawbip(buf+228, 4); memcpy(&h->patient_birth_date, buf+228, 4);
      |   ^~
ecat7r.c:126:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  126 |   if(little) swawbip(buf+228, 4); memcpy(&h->patient_birth_date, buf+228, 4);
      |                                   ^~~~~~
ecat7r.c:130:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  130 |   if(little) swabip(buf+328, 2); memcpy(&h->acquisition_type, buf+328, 2);
      |   ^~
ecat7r.c:130:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  130 |   if(little) swabip(buf+328, 2); memcpy(&h->acquisition_type, buf+328, 2);
      |                                  ^~~~~~
ecat7r.c:131:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  131 |   if(little) swabip(buf+330, 2); memcpy(&h->patient_orientation, buf+330, 2);
      |   ^~
ecat7r.c:131:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  131 |   if(little) swabip(buf+330, 2); memcpy(&h->patient_orientation, buf+330, 2);
      |                                  ^~~~~~
ecat7r.c:133:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  133 |   if(little) swabip(buf+352, 2); memcpy(&h->num_planes, buf+352, 2);
      |   ^~
ecat7r.c:133:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  133 |   if(little) swabip(buf+352, 2); memcpy(&h->num_planes, buf+352, 2);
      |                                  ^~~~~~
ecat7r.c:134:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  134 |   if(little) swabip(buf+354, 2); memcpy(&h->num_frames, buf+354, 2);
      |   ^~
ecat7r.c:134:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  134 |   if(little) swabip(buf+354, 2); memcpy(&h->num_frames, buf+354, 2);
      |                                  ^~~~~~
ecat7r.c:135:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  135 |   if(little) swabip(buf+356, 2); memcpy(&h->num_gates, buf+356, 2);
      |   ^~
ecat7r.c:135:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  135 |   if(little) swabip(buf+356, 2); memcpy(&h->num_gates, buf+356, 2);
      |                                  ^~~~~~
ecat7r.c:136:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  136 |   if(little) swabip(buf+358, 2); memcpy(&h->num_bed_pos, buf+358, 2);
      |   ^~
ecat7r.c:136:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  136 |   if(little) swabip(buf+358, 2); memcpy(&h->num_bed_pos, buf+358, 2);
      |                                  ^~~~~~
ecat7r.c:137:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  137 |   if(little) swawbip(buf+360, 4); memcpy(&h->init_bed_position, buf+360, 4);
      |   ^~
ecat7r.c:137:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  137 |   if(little) swawbip(buf+360, 4); memcpy(&h->init_bed_position, buf+360, 4);
      |                                   ^~~~~~
ecat7r.c:138:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  138 |   if(little) swawbip(buf+364, 15*4); memcpy(h->bed_position, buf+364, 15*4);
      |   ^~
ecat7r.c:138:38: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  138 |   if(little) swawbip(buf+364, 15*4); memcpy(h->bed_position, buf+364, 15*4);
      |                                      ^~~~~~
ecat7r.c:139:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  139 |   if(little) swawbip(buf+424, 4); memcpy(&h->plane_separation, buf+424, 4);
      |   ^~
ecat7r.c:139:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  139 |   if(little) swawbip(buf+424, 4); memcpy(&h->plane_separation, buf+424, 4);
      |                                   ^~~~~~
ecat7r.c:140:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  140 |   if(little) swabip(buf+428, 2); memcpy(&h->lwr_sctr_thres, buf+428, 2);
      |   ^~
ecat7r.c:140:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  140 |   if(little) swabip(buf+428, 2); memcpy(&h->lwr_sctr_thres, buf+428, 2);
      |                                  ^~~~~~
ecat7r.c:141:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  141 |   if(little) swabip(buf+430, 2); memcpy(&h->lwr_true_thres, buf+430, 2);
      |   ^~
ecat7r.c:141:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  141 |   if(little) swabip(buf+430, 2); memcpy(&h->lwr_true_thres, buf+430, 2);
      |                                  ^~~~~~
ecat7r.c:144:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  144 |   if(little) swabip(buf+444, 2); memcpy(&h->acquisition_mode, buf+444, 2);
      |   ^~
ecat7r.c:144:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  144 |   if(little) swabip(buf+444, 2); memcpy(&h->acquisition_mode, buf+444, 2);
      |                                  ^~~~~~
ecat7r.c:145:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  145 |   if(little) swawbip(buf+446, 4); memcpy(&h->bin_size, buf+446, 4);
      |   ^~
ecat7r.c:145:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  145 |   if(little) swawbip(buf+446, 4); memcpy(&h->bin_size, buf+446, 4);
      |                                   ^~~~~~
ecat7r.c:146:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  146 |   if(little) swawbip(buf+450, 4); memcpy(&h->branching_fraction, buf+450, 4);
      |   ^~
ecat7r.c:146:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  146 |   if(little) swawbip(buf+450, 4); memcpy(&h->branching_fraction, buf+450, 4);
      |                                   ^~~~~~
ecat7r.c:147:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  147 |   if(little) swawbip(buf+454, 4); memcpy(&h->dose_start_time, buf+454, 4);
      |   ^~
ecat7r.c:147:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  147 |   if(little) swawbip(buf+454, 4); memcpy(&h->dose_start_time, buf+454, 4);
      |                                   ^~~~~~
ecat7r.c:148:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  148 |   if(little) swawbip(buf+458, 4); memcpy(&h->dosage, buf+458, 4);
      |   ^~
ecat7r.c:148:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  148 |   if(little) swawbip(buf+458, 4); memcpy(&h->dosage, buf+458, 4);
      |                                   ^~~~~~
ecat7r.c:149:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  149 |   if(little) swawbip(buf+462, 4); memcpy(&h->well_counter_corr_factor, buf+462, 4);
      |   ^~
ecat7r.c:149:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  149 |   if(little) swawbip(buf+462, 4); memcpy(&h->well_counter_corr_factor, buf+462, 4);
      |                                   ^~~~~~
ecat7r.c:151:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  151 |   if(little) swabip(buf+498, 2); memcpy(&h->septa_state, buf+498, 2);
      |   ^~
ecat7r.c:151:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  151 |   if(little) swabip(buf+498, 2); memcpy(&h->septa_state, buf+498, 2);
      |                                  ^~~~~~
ecat7r.c: In function 'ecat7ReadImageheader':
ecat7r.c:192:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  192 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |   ^~
ecat7r.c:192:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  192 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |                                ^~~~~~
ecat7r.c:193:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  193 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |   ^~
ecat7r.c:193:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  193 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |                                ^~~~~~
ecat7r.c:194:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  194 |   if(little) swabip(buf+4, 2); memcpy(&h->x_dimension, buf+4, 2);
      |   ^~
ecat7r.c:194:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  194 |   if(little) swabip(buf+4, 2); memcpy(&h->x_dimension, buf+4, 2);
      |                                ^~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat7w.o ecat7w.c
ecat7r.c:195:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  195 |   if(little) swabip(buf+6, 2); memcpy(&h->y_dimension, buf+6, 2);
      |   ^~
ecat7r.c:195:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  195 |   if(little) swabip(buf+6, 2); memcpy(&h->y_dimension, buf+6, 2);
      |                                ^~~~~~
ecat7r.c:196:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  196 |   if(little) swabip(buf+8, 2); memcpy(&h->z_dimension, buf+8, 2);
      |   ^~
ecat7r.c:196:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  196 |   if(little) swabip(buf+8, 2); memcpy(&h->z_dimension, buf+8, 2);
      |                                ^~~~~~
ecat7r.c:197:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  197 |   if(little) swawbip(buf+10, 4); memcpy(&h->x_offset, buf+10, 4);
      |   ^~
ecat7r.c:197:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  197 |   if(little) swawbip(buf+10, 4); memcpy(&h->x_offset, buf+10, 4);
      |                                  ^~~~~~
ecat7r.c:198:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  198 |   if(little) swawbip(buf+14, 4); memcpy(&h->y_offset, buf+14, 4);
      |   ^~
ecat7r.c:198:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  198 |   if(little) swawbip(buf+14, 4); memcpy(&h->y_offset, buf+14, 4);
      |                                  ^~~~~~
ecat7r.c:199:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  199 |   if(little) swawbip(buf+18, 4); memcpy(&h->z_offset, buf+18, 4);
      |   ^~
ecat7r.c:199:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  199 |   if(little) swawbip(buf+18, 4); memcpy(&h->z_offset, buf+18, 4);
      |                                  ^~~~~~
ecat7r.c:200:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  200 |   if(little) swawbip(buf+22, 4); memcpy(&h->recon_zoom, buf+22, 4);
      |   ^~
ecat7r.c:200:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  200 |   if(little) swawbip(buf+22, 4); memcpy(&h->recon_zoom, buf+22, 4);
      |                                  ^~~~~~
ecat7r.c:201:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  201 |   if(little) swawbip(buf+26, 4); memcpy(&h->scale_factor, buf+26, 4);
      |   ^~
ecat7r.c:201:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  201 |   if(little) swawbip(buf+26, 4); memcpy(&h->scale_factor, buf+26, 4);
      |                                  ^~~~~~
ecat7r.c:202:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  202 |   if(little) swabip(buf+30, 2); memcpy(&h->image_min, buf+30, 2);
      |   ^~
ecat7r.c:202:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  202 |   if(little) swabip(buf+30, 2); memcpy(&h->image_min, buf+30, 2);
      |                                 ^~~~~~
ecat7r.c:203:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  203 |   if(little) swabip(buf+32, 2); memcpy(&h->image_max, buf+32, 2);
      |   ^~
ecat7r.c:203:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  203 |   if(little) swabip(buf+32, 2); memcpy(&h->image_max, buf+32, 2);
      |                                 ^~~~~~
ecat7r.c:204:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  204 |   if(little) swawbip(buf+34, 4); memcpy(&h->x_pixel_size, buf+34, 4);
      |   ^~
ecat7r.c:204:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  204 |   if(little) swawbip(buf+34, 4); memcpy(&h->x_pixel_size, buf+34, 4);
      |                                  ^~~~~~
ecat7r.c:205:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  205 |   if(little) swawbip(buf+38, 4); memcpy(&h->y_pixel_size, buf+38, 4);
      |   ^~
ecat7r.c:205:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  205 |   if(little) swawbip(buf+38, 4); memcpy(&h->y_pixel_size, buf+38, 4);
      |                                  ^~~~~~
ecat7r.c:206:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  206 |   if(little) swawbip(buf+42, 4); memcpy(&h->z_pixel_size, buf+42, 4);
      |   ^~
ecat7r.c:206:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  206 |   if(little) swawbip(buf+42, 4); memcpy(&h->z_pixel_size, buf+42, 4);
      |                                  ^~~~~~
ecat7r.c:207:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  207 |   if(little) swawbip(buf+46, 4); memcpy(&h->frame_duration, buf+46, 4);
      |   ^~
ecat7r.c:207:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  207 |   if(little) swawbip(buf+46, 4); memcpy(&h->frame_duration, buf+46, 4);
      |                                  ^~~~~~
ecat7r.c:208:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  208 |   if(little) swawbip(buf+50, 4); memcpy(&h->frame_start_time, buf+50, 4);
      |   ^~
ecat7r.c:208:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  208 |   if(little) swawbip(buf+50, 4); memcpy(&h->frame_start_time, buf+50, 4);
      |                                  ^~~~~~
ecat7r.c:209:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  209 |   if(little) swabip(buf+54, 2); memcpy(&h->filter_code, buf+54, 2);
      |   ^~
ecat7r.c:209:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  209 |   if(little) swabip(buf+54, 2); memcpy(&h->filter_code, buf+54, 2);
      |                                 ^~~~~~
ecat7r.c:210:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  210 |   if(little) swawbip(buf+56, 4); memcpy(&h->x_resolution, buf+56, 4);
      |   ^~
ecat7r.c:210:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  210 |   if(little) swawbip(buf+56, 4); memcpy(&h->x_resolution, buf+56, 4);
      |                                  ^~~~~~
ecat7r.c:211:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  211 |   if(little) swawbip(buf+60, 4); memcpy(&h->y_resolution, buf+60, 4);
      |   ^~
ecat7r.c:211:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  211 |   if(little) swawbip(buf+60, 4); memcpy(&h->y_resolution, buf+60, 4);
      |                                  ^~~~~~
ecat7r.c:212:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  212 |   if(little) swawbip(buf+64, 4); memcpy(&h->z_resolution, buf+64, 4);
      |   ^~
ecat7r.c:212:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  212 |   if(little) swawbip(buf+64, 4); memcpy(&h->z_resolution, buf+64, 4);
      |                                  ^~~~~~
ecat7r.c:213:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  213 |   if(little) swawbip(buf+68, 4); memcpy(&h->num_r_elements, buf+68, 4);
      |   ^~
ecat7r.c:213:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  213 |   if(little) swawbip(buf+68, 4); memcpy(&h->num_r_elements, buf+68, 4);
      |                                  ^~~~~~
ecat7r.c:214:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  214 |   if(little) swawbip(buf+72, 4); memcpy(&h->num_angles, buf+72, 4);
      |   ^~
ecat7r.c:214:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  214 |   if(little) swawbip(buf+72, 4); memcpy(&h->num_angles, buf+72, 4);
      |                                  ^~~~~~
ecat7r.c:215:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  215 |   if(little) swawbip(buf+76, 4); memcpy(&h->z_rotation_angle, buf+76, 4);
      |   ^~
ecat7r.c:215:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  215 |   if(little) swawbip(buf+76, 4); memcpy(&h->z_rotation_angle, buf+76, 4);
      |                                  ^~~~~~
ecat7r.c:216:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  216 |   if(little) swawbip(buf+80, 4); memcpy(&h->decay_corr_fctr, buf+80, 4);
      |   ^~
ecat7r.c:216:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  216 |   if(little) swawbip(buf+80, 4); memcpy(&h->decay_corr_fctr, buf+80, 4);
      |                                  ^~~~~~
ecat7r.c:217:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  217 |   if(little) swawbip(buf+84, 4); memcpy(&h->processing_code, buf+84, 4);
      |   ^~
ecat7r.c:217:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  217 |   if(little) swawbip(buf+84, 4); memcpy(&h->processing_code, buf+84, 4);
      |                                  ^~~~~~
ecat7r.c:218:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  218 |   if(little) swawbip(buf+88, 4); memcpy(&h->gate_duration, buf+88, 4);
      |   ^~
ecat7r.c:218:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  218 |   if(little) swawbip(buf+88, 4); memcpy(&h->gate_duration, buf+88, 4);
      |                                  ^~~~~~
ecat7r.c:219:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  219 |   if(little) swawbip(buf+92, 4); memcpy(&h->r_wave_offset, buf+92, 4);
      |   ^~
ecat7r.c:219:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  219 |   if(little) swawbip(buf+92, 4); memcpy(&h->r_wave_offset, buf+92, 4);
      |                                  ^~~~~~
ecat7r.c:220:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  220 |   if(little) swawbip(buf+96, 4); memcpy(&h->num_accepted_beats, buf+96, 4);
      |   ^~
ecat7r.c:220:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  220 |   if(little) swawbip(buf+96, 4); memcpy(&h->num_accepted_beats, buf+96, 4);
      |                                  ^~~~~~
ecat7r.c:221:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  221 |   if(little) swawbip(buf+100, 4); memcpy(&h->filter_cutoff_frequency, buf+100, 4);
      |   ^~
ecat7r.c:221:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  221 |   if(little) swawbip(buf+100, 4); memcpy(&h->filter_cutoff_frequency, buf+100, 4);
      |                                   ^~~~~~
ecat7r.c:222:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  222 |   if(little) swawbip(buf+104, 4); memcpy(&h->filter_resolution, buf+104, 4);
      |   ^~
ecat7r.c:222:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  222 |   if(little) swawbip(buf+104, 4); memcpy(&h->filter_resolution, buf+104, 4);
      |                                   ^~~~~~
ecat7r.c:223:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  223 |   if(little) swawbip(buf+108, 4); memcpy(&h->filter_ramp_slope, buf+108, 4);
      |   ^~
ecat7r.c:223:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  223 |   if(little) swawbip(buf+108, 4); memcpy(&h->filter_ramp_slope, buf+108, 4);
      |                                   ^~~~~~
ecat7r.c:224:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  224 |   if(little) swabip(buf+112, 2); memcpy(&h->filter_order, buf+112, 2);
      |   ^~
ecat7r.c:224:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  224 |   if(little) swabip(buf+112, 2); memcpy(&h->filter_order, buf+112, 2);
      |                                  ^~~~~~
ecat7r.c:225:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  225 |   if(little) swawbip(buf+114, 4); memcpy(&h->filter_scatter_fraction, buf+114, 4);
      |   ^~
ecat7r.c:225:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  225 |   if(little) swawbip(buf+114, 4); memcpy(&h->filter_scatter_fraction, buf+114, 4);
      |                                   ^~~~~~
ecat7r.c:226:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  226 |   if(little) swawbip(buf+118, 4); memcpy(&h->filter_scatter_slope, buf+118, 4);
      |   ^~
ecat7r.c:226:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  226 |   if(little) swawbip(buf+118, 4); memcpy(&h->filter_scatter_slope, buf+118, 4);
      |                                   ^~~~~~
ecat7r.c:228:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  228 |   if(little) swawbip(buf+162, 4); memcpy(&h->mt_1_1, buf+162, 4);
      |   ^~
ecat7r.c:228:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  228 |   if(little) swawbip(buf+162, 4); memcpy(&h->mt_1_1, buf+162, 4);
      |                                   ^~~~~~
ecat7r.c:229:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  229 |   if(little) swawbip(buf+166, 4); memcpy(&h->mt_1_2, buf+166, 4);
      |   ^~
ecat7r.c:229:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  229 |   if(little) swawbip(buf+166, 4); memcpy(&h->mt_1_2, buf+166, 4);
      |                                   ^~~~~~
ecat7r.c:230:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  230 |   if(little) swawbip(buf+170, 4); memcpy(&h->mt_1_3, buf+170, 4);
      |   ^~
ecat7r.c:230:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  230 |   if(little) swawbip(buf+170, 4); memcpy(&h->mt_1_3, buf+170, 4);
      |                                   ^~~~~~
ecat7r.c:231:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  231 |   if(little) swawbip(buf+174, 4); memcpy(&h->mt_2_1, buf+174, 4);
      |   ^~
ecat7r.c:231:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  231 |   if(little) swawbip(buf+174, 4); memcpy(&h->mt_2_1, buf+174, 4);
      |                                   ^~~~~~
ecat7r.c:232:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  232 |   if(little) swawbip(buf+178, 4); memcpy(&h->mt_2_2, buf+178, 4);
      |   ^~
ecat7r.c:232:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  232 |   if(little) swawbip(buf+178, 4); memcpy(&h->mt_2_2, buf+178, 4);
      |                                   ^~~~~~
ecat7r.c:233:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  233 |   if(little) swawbip(buf+182, 4); memcpy(&h->mt_2_3, buf+182, 4);
      |   ^~
ecat7r.c:233:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  233 |   if(little) swawbip(buf+182, 4); memcpy(&h->mt_2_3, buf+182, 4);
      |                                   ^~~~~~
ecat7r.c:234:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  234 |   if(little) swawbip(buf+186, 4); memcpy(&h->mt_3_1, buf+186, 4);
      |   ^~
ecat7r.c:234:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  234 |   if(little) swawbip(buf+186, 4); memcpy(&h->mt_3_1, buf+186, 4);
      |                                   ^~~~~~
ecat7r.c:235:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  235 |   if(little) swawbip(buf+190, 4); memcpy(&h->mt_3_2, buf+190, 4);
      |   ^~
ecat7r.c:235:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  235 |   if(little) swawbip(buf+190, 4); memcpy(&h->mt_3_2, buf+190, 4);
      |                                   ^~~~~~
ecat7r.c:236:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  236 |   if(little) swawbip(buf+194, 4); memcpy(&h->mt_3_3, buf+194, 4);
      |   ^~
ecat7r.c:236:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  236 |   if(little) swawbip(buf+194, 4); memcpy(&h->mt_3_3, buf+194, 4);
      |                                   ^~~~~~
ecat7r.c:237:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  237 |   if(little) swawbip(buf+198, 4); memcpy(&h->rfilter_cutoff, buf+198, 4);
      |   ^~
ecat7r.c:237:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  237 |   if(little) swawbip(buf+198, 4); memcpy(&h->rfilter_cutoff, buf+198, 4);
      |                                   ^~~~~~
ecat7r.c:238:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  238 |   if(little) swawbip(buf+202, 4); memcpy(&h->rfilter_resolution, buf+202, 4);
      |   ^~
ecat7r.c:238:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  238 |   if(little) swawbip(buf+202, 4); memcpy(&h->rfilter_resolution, buf+202, 4);
      |                                   ^~~~~~
ecat7r.c:239:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  239 |   if(little) swabip(buf+206, 2); memcpy(&h->rfilter_code, buf+206, 2);
      |   ^~
ecat7r.c:239:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  239 |   if(little) swabip(buf+206, 2); memcpy(&h->rfilter_code, buf+206, 2);
      |                                  ^~~~~~
ecat7r.c:240:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  240 |   if(little) swabip(buf+208, 2); memcpy(&h->rfilter_order, buf+208, 2);
      |   ^~
ecat7r.c:240:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  240 |   if(little) swabip(buf+208, 2); memcpy(&h->rfilter_order, buf+208, 2);
      |                                  ^~~~~~
ecat7r.c:241:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  241 |   if(little) swawbip(buf+210, 4); memcpy(&h->zfilter_cutoff, buf+210, 4);
      |   ^~
ecat7r.c:241:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  241 |   if(little) swawbip(buf+210, 4); memcpy(&h->zfilter_cutoff, buf+210, 4);
      |                                   ^~~~~~
ecat7r.c:242:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  242 |   if(little) swawbip(buf+214, 4); memcpy(&h->zfilter_resolution, buf+214, 4);
      |   ^~
ecat7r.c:242:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  242 |   if(little) swawbip(buf+214, 4); memcpy(&h->zfilter_resolution, buf+214, 4);
      |                                   ^~~~~~
ecat7r.c:243:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  243 |   if(little) swabip(buf+218, 2); memcpy(&h->zfilter_code, buf+218, 2);
      |   ^~
ecat7r.c:243:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  243 |   if(little) swabip(buf+218, 2); memcpy(&h->zfilter_code, buf+218, 2);
      |                                  ^~~~~~
ecat7r.c:244:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  244 |   if(little) swabip(buf+220, 2); memcpy(&h->zfilter_order, buf+220, 2);
      |   ^~
ecat7r.c:244:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  244 |   if(little) swabip(buf+220, 2); memcpy(&h->zfilter_order, buf+220, 2);
      |                                  ^~~~~~
ecat7r.c:245:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  245 |   if(little) swawbip(buf+222, 4); memcpy(&h->mt_1_4, buf+222, 4);
      |   ^~
ecat7r.c:245:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  245 |   if(little) swawbip(buf+222, 4); memcpy(&h->mt_1_4, buf+222, 4);
      |                                   ^~~~~~
ecat7r.c:246:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  246 |   if(little) swawbip(buf+226, 4); memcpy(&h->mt_2_4, buf+226, 4);
      |   ^~
ecat7r.c:246:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  246 |   if(little) swawbip(buf+226, 4); memcpy(&h->mt_2_4, buf+226, 4);
      |                                   ^~~~~~
ecat7r.c:247:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  247 |   if(little) swawbip(buf+230, 4); memcpy(&h->mt_3_4, buf+230, 4);
      |   ^~
ecat7r.c:247:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  247 |   if(little) swawbip(buf+230, 4); memcpy(&h->mt_3_4, buf+230, 4);
      |                                   ^~~~~~
ecat7r.c:248:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  248 |   if(little) swabip(buf+234, 2); memcpy(&h->scatter_type, buf+234, 2);
      |   ^~
ecat7r.c:248:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  248 |   if(little) swabip(buf+234, 2); memcpy(&h->scatter_type, buf+234, 2);
      |                                  ^~~~~~
ecat7r.c:249:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  249 |   if(little) swabip(buf+236, 2); memcpy(&h->recon_type, buf+236, 2);
      |   ^~
ecat7r.c:249:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  249 |   if(little) swabip(buf+236, 2); memcpy(&h->recon_type, buf+236, 2);
      |                                  ^~~~~~
ecat7r.c:250:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  250 |   if(little) swabip(buf+238, 2); memcpy(&h->recon_views, buf+238, 2);
      |   ^~
ecat7r.c:250:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  250 |   if(little) swabip(buf+238, 2); memcpy(&h->recon_views, buf+238, 2);
      |                                  ^~~~~~
ecat7r.c: In function 'ecat7ReadAttenheader':
ecat7r.c:282:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  282 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |   ^~
ecat7r.c:282:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  282 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |                                ^~~~~~
ecat7r.c:283:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  283 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |   ^~
ecat7r.c:283:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  283 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |                                ^~~~~~
ecat7r.c:284:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  284 |   if(little) swabip(buf+4, 2); memcpy(&h->attenuation_type, buf+4, 2);
      |   ^~
ecat7r.c:284:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  284 |   if(little) swabip(buf+4, 2); memcpy(&h->attenuation_type, buf+4, 2);
      |                                ^~~~~~
ecat7r.c:285:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  285 |   if(little) swabip(buf+6, 2); memcpy(&h->num_r_elements, buf+6, 2);
      |   ^~
ecat7r.c:285:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  285 |   if(little) swabip(buf+6, 2); memcpy(&h->num_r_elements, buf+6, 2);
      |                                ^~~~~~
ecat7r.c:286:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  286 |   if(little) swabip(buf+8, 2); memcpy(&h->num_angles, buf+8, 2);
      |   ^~
ecat7r.c:286:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  286 |   if(little) swabip(buf+8, 2); memcpy(&h->num_angles, buf+8, 2);
      |                                ^~~~~~
ecat7r.c:287:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  287 |   if(little) swabip(buf+10, 2); memcpy(&h->num_z_elements, buf+10, 2);
      |   ^~
ecat7r.c:287:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  287 |   if(little) swabip(buf+10, 2); memcpy(&h->num_z_elements, buf+10, 2);
      |                                 ^~~~~~
ecat7r.c:288:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  288 |   if(little) swabip(buf+12, 2); memcpy(&h->ring_difference, buf+12, 2);
      |   ^~
ecat7r.c:288:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  288 |   if(little) swabip(buf+12, 2); memcpy(&h->ring_difference, buf+12, 2);
      |                                 ^~~~~~
ecat7r.c:289:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  289 |   if(little) swawbip(buf+14, 4); memcpy(&h->x_resolution, buf+14, 4);
      |   ^~
ecat7r.c:289:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  289 |   if(little) swawbip(buf+14, 4); memcpy(&h->x_resolution, buf+14, 4);
      |                                  ^~~~~~
ecat7r.c:290:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  290 |   if(little) swawbip(buf+18, 4); memcpy(&h->y_resolution, buf+18, 4);
      |   ^~
ecat7r.c:290:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  290 |   if(little) swawbip(buf+18, 4); memcpy(&h->y_resolution, buf+18, 4);
      |                                  ^~~~~~
ecat7r.c:291:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  291 |   if(little) swawbip(buf+22, 4); memcpy(&h->z_resolution, buf+22, 4);
      |   ^~
ecat7r.c:291:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  291 |   if(little) swawbip(buf+22, 4); memcpy(&h->z_resolution, buf+22, 4);
      |                                  ^~~~~~
ecat7r.c:292:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  292 |   if(little) swawbip(buf+26, 4); memcpy(&h->w_resolution, buf+26, 4);
      |   ^~
ecat7r.c:292:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  292 |   if(little) swawbip(buf+26, 4); memcpy(&h->w_resolution, buf+26, 4);
      |                                  ^~~~~~
ecat7r.c:293:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  293 |   if(little) swawbip(buf+30, 4); memcpy(&h->scale_factor, buf+30, 4);
      |   ^~
ecat7r.c:293:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  293 |   if(little) swawbip(buf+30, 4); memcpy(&h->scale_factor, buf+30, 4);
      |                                  ^~~~~~
ecat7r.c:294:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  294 |   if(little) swawbip(buf+34, 4); memcpy(&h->x_offset, buf+34, 4);
      |   ^~
ecat7r.c:294:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  294 |   if(little) swawbip(buf+34, 4); memcpy(&h->x_offset, buf+34, 4);
      |                                  ^~~~~~
ecat7r.c:295:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  295 |   if(little) swawbip(buf+38, 4); memcpy(&h->y_offset, buf+38, 4);
      |   ^~
ecat7r.c:295:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  295 |   if(little) swawbip(buf+38, 4); memcpy(&h->y_offset, buf+38, 4);
      |                                  ^~~~~~
ecat7r.c:296:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  296 |   if(little) swawbip(buf+42, 4); memcpy(&h->x_radius, buf+42, 4);
      |   ^~
ecat7r.c:296:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  296 |   if(little) swawbip(buf+42, 4); memcpy(&h->x_radius, buf+42, 4);
      |                                  ^~~~~~
ecat7r.c:297:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  297 |   if(little) swawbip(buf+46, 4); memcpy(&h->y_radius, buf+46, 4);
      |   ^~
ecat7r.c:297:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  297 |   if(little) swawbip(buf+46, 4); memcpy(&h->y_radius, buf+46, 4);
      |                                  ^~~~~~
ecat7r.c:298:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  298 |   if(little) swawbip(buf+50, 4); memcpy(&h->tilt_angle, buf+50, 4);
      |   ^~
ecat7r.c:298:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  298 |   if(little) swawbip(buf+50, 4); memcpy(&h->tilt_angle, buf+50, 4);
      |                                  ^~~~~~
ecat7r.c:299:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  299 |   if(little) swawbip(buf+54, 4); memcpy(&h->attenuation_coeff, buf+54, 4);
      |   ^~
ecat7r.c:299:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  299 |   if(little) swawbip(buf+54, 4); memcpy(&h->attenuation_coeff, buf+54, 4);
      |                                  ^~~~~~
ecat7r.c:300:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  300 |   if(little) swawbip(buf+58, 4); memcpy(&h->attenuation_min, buf+58, 4);
      |   ^~
ecat7r.c:300:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  300 |   if(little) swawbip(buf+58, 4); memcpy(&h->attenuation_min, buf+58, 4);
      |                                  ^~~~~~
ecat7r.c:301:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  301 |   if(little) swawbip(buf+62, 4); memcpy(&h->attenuation_max, buf+62, 4);
      |   ^~
ecat7r.c:301:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  301 |   if(little) swawbip(buf+62, 4); memcpy(&h->attenuation_max, buf+62, 4);
      |                                  ^~~~~~
ecat7r.c:302:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  302 |   if(little) swawbip(buf+66, 4); memcpy(&h->skull_thickness, buf+66, 4);
      |   ^~
ecat7r.c:302:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  302 |   if(little) swawbip(buf+66, 4); memcpy(&h->skull_thickness, buf+66, 4);
      |                                  ^~~~~~
ecat7r.c:303:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  303 |   if(little) swabip(buf+70, 2); memcpy(&h->num_additional_atten_coeff, buf+70, 2);
      |   ^~
ecat7r.c:303:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  303 |   if(little) swabip(buf+70, 2); memcpy(&h->num_additional_atten_coeff, buf+70, 2);
      |                                 ^~~~~~
ecat7r.c:304:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  304 |   if(little) swawbip(buf+72, 8*4); memcpy(h->additional_atten_coeff, buf+72, 8*4);
      |   ^~
ecat7r.c:304:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  304 |   if(little) swawbip(buf+72, 8*4); memcpy(h->additional_atten_coeff, buf+72, 8*4);
      |                                    ^~~~~~
ecat7r.c:305:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  305 |   if(little) swawbip(buf+104, 4); memcpy(&h->edge_finding_threshold, buf+104, 4);
      |   ^~
ecat7r.c:305:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  305 |   if(little) swawbip(buf+104, 4); memcpy(&h->edge_finding_threshold, buf+104, 4);
      |                                   ^~~~~~
ecat7r.c:306:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  306 |   if(little) swabip(buf+108, 2); memcpy(&h->storage_order, buf+108, 2);
      |   ^~
ecat7r.c:306:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  306 |   if(little) swabip(buf+108, 2); memcpy(&h->storage_order, buf+108, 2);
      |                                  ^~~~~~
ecat7r.c:307:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  307 |   if(little) swabip(buf+110, 2); memcpy(&h->span, buf+110, 2);
      |   ^~
ecat7r.c:307:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  307 |   if(little) swabip(buf+110, 2); memcpy(&h->span, buf+110, 2);
      |                                  ^~~~~~
ecat7r.c:308:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  308 |   if(little) swabip(buf+112, 64*2); memcpy(h->z_elements, buf+112, 64*2);
      |   ^~
ecat7r.c:308:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  308 |   if(little) swabip(buf+112, 64*2); memcpy(h->z_elements, buf+112, 64*2);
      |                                     ^~~~~~
ecat7r.c:309:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  309 |   if(little) swabip(buf+240, 86*2); memcpy(h->fill_cti, buf+240, 86*2);
      |   ^~
ecat7r.c:309:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  309 |   if(little) swabip(buf+240, 86*2); memcpy(h->fill_cti, buf+240, 86*2);
      |                                     ^~~~~~
ecat7r.c:310:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  310 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |   ^~
ecat7r.c:310:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  310 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |                                     ^~~~~~
ecat7r.c: In function 'ecat7ReadPolmapheader':
ecat7r.c:339:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  339 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |   ^~
ecat7r.c:339:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  339 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |                                ^~~~~~
ecat7r.c:340:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  340 |   if(little) swabip(buf+2, 2); memcpy(&h->polar_map_type, buf+2, 2);
      |   ^~
ecat7r.c:340:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  340 |   if(little) swabip(buf+2, 2); memcpy(&h->polar_map_type, buf+2, 2);
      |                                ^~~~~~
ecat7r.c:341:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  341 |   if(little) swabip(buf+4, 2); memcpy(&h->num_rings, buf+4, 2);
      |   ^~
ecat7r.c:341:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  341 |   if(little) swabip(buf+4, 2); memcpy(&h->num_rings, buf+4, 2);
      |                                ^~~~~~
ecat7r.c:342:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  342 |   if(little) swabip(buf+6, 32*2); memcpy(h->sectors_per_ring, buf+6, 32*2);
      |   ^~
ecat7r.c:342:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  342 |   if(little) swabip(buf+6, 32*2); memcpy(h->sectors_per_ring, buf+6, 32*2);
      |                                   ^~~~~~
ecat7r.c:343:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  343 |   if(little) swawbip(buf+70, 32*4); memcpy(h->ring_position, buf+70, 32*4);
      |   ^~
ecat7r.c:343:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  343 |   if(little) swawbip(buf+70, 32*4); memcpy(h->ring_position, buf+70, 32*4);
      |                                     ^~~~~~
ecat7r.c:344:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  344 |   if(little) swabip(buf+198, 32*2); memcpy(h->ring_angle, buf+198, 32*2);
      |   ^~
ecat7r.c:344:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  344 |   if(little) swabip(buf+198, 32*2); memcpy(h->ring_angle, buf+198, 32*2);
      |                                     ^~~~~~
ecat7r.c:345:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  345 |   if(little) swabip(buf+262, 2); memcpy(&h->start_angle, buf+262, 2);
      |   ^~
ecat7r.c:345:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  345 |   if(little) swabip(buf+262, 2); memcpy(&h->start_angle, buf+262, 2);
      |                                  ^~~~~~
ecat7r.c:346:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  346 |   if(little) swabip(buf+264, 3*2); memcpy(h->long_axis_left, buf+264, 3*2);
      |   ^~
ecat7r.c:346:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  346 |   if(little) swabip(buf+264, 3*2); memcpy(h->long_axis_left, buf+264, 3*2);
      |                                    ^~~~~~
ecat7r.c:347:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  347 |   if(little) swabip(buf+270, 3*2); memcpy(h->long_axis_right, buf+270, 3*2);
      |   ^~
ecat7r.c:347:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  347 |   if(little) swabip(buf+270, 3*2); memcpy(h->long_axis_right, buf+270, 3*2);
      |                                    ^~~~~~
ecat7r.c:348:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  348 |   if(little) swabip(buf+276, 2); memcpy(&h->position_data, buf+276, 2);
      |   ^~
ecat7r.c:348:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  348 |   if(little) swabip(buf+276, 2); memcpy(&h->position_data, buf+276, 2);
      |                                  ^~~~~~
ecat7r.c:349:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  349 |   if(little) swabip(buf+278, 2); memcpy(&h->image_min, buf+278, 2);
      |   ^~
ecat7r.c:349:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  349 |   if(little) swabip(buf+278, 2); memcpy(&h->image_min, buf+278, 2);
      |                                  ^~~~~~
ecat7r.c:350:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  350 |   if(little) swabip(buf+280, 2); memcpy(&h->image_max, buf+280, 2);
      |   ^~
ecat7r.c:350:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  350 |   if(little) swabip(buf+280, 2); memcpy(&h->image_max, buf+280, 2);
      |                                  ^~~~~~
ecat7r.c:351:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  351 |   if(little) swawbip(buf+282, 4); memcpy(&h->scale_factor, buf+282, 4);
      |   ^~
ecat7r.c:351:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  351 |   if(little) swawbip(buf+282, 4); memcpy(&h->scale_factor, buf+282, 4);
      |                                   ^~~~~~
ecat7r.c:352:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  352 |   if(little) swawbip(buf+286, 4); memcpy(&h->pixel_size, buf+286, 4);
      |   ^~
ecat7r.c:352:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  352 |   if(little) swawbip(buf+286, 4); memcpy(&h->pixel_size, buf+286, 4);
      |                                   ^~~~~~
ecat7r.c:353:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  353 |   if(little) swawbip(buf+290, 4); memcpy(&h->frame_duration, buf+290, 4);
      |   ^~
ecat7r.c:353:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  353 |   if(little) swawbip(buf+290, 4); memcpy(&h->frame_duration, buf+290, 4);
      |                                   ^~~~~~
ecat7r.c:354:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  354 |   if(little) swawbip(buf+294, 4); memcpy(&h->frame_start_time, buf+294, 4);
      |   ^~
ecat7r.c:354:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  354 |   if(little) swawbip(buf+294, 4); memcpy(&h->frame_start_time, buf+294, 4);
      |                                   ^~~~~~
ecat7r.c:355:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  355 |   if(little) swabip(buf+298, 2); memcpy(&h->processing_code, buf+298, 2);
      |   ^~
ecat7r.c:355:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  355 |   if(little) swabip(buf+298, 2); memcpy(&h->processing_code, buf+298, 2);
      |                                  ^~~~~~
ecat7r.c:356:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  356 |   if(little) swabip(buf+300, 2); memcpy(&h->quant_units, buf+300, 2);
      |   ^~
ecat7r.c:356:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  356 |   if(little) swabip(buf+300, 2); memcpy(&h->quant_units, buf+300, 2);
      |                                  ^~~~~~
ecat7r.c:358:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  358 |   if(little) swawbip(buf+342, 4); memcpy(&h->gate_duration, buf+342, 4);
      |   ^~
ecat7r.c:358:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  358 |   if(little) swawbip(buf+342, 4); memcpy(&h->gate_duration, buf+342, 4);
      |                                   ^~~~~~
ecat7r.c:359:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  359 |   if(little) swawbip(buf+346, 4); memcpy(&h->r_wave_offset, buf+346, 4);
      |   ^~
ecat7r.c:359:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  359 |   if(little) swawbip(buf+346, 4); memcpy(&h->r_wave_offset, buf+346, 4);
      |                                   ^~~~~~
ecat7r.c:360:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  360 |   if(little) swawbip(buf+350, 4); memcpy(&h->num_accepted_beats, buf+350, 4);
      |   ^~
ecat7r.c:360:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  360 |   if(little) swawbip(buf+350, 4); memcpy(&h->num_accepted_beats, buf+350, 4);
      |                                   ^~~~~~
ecat7r.c:363:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  363 |   if(little) swabip(buf+404, 27*2); memcpy(h->fill_cti, buf+404, 27*2);
      |   ^~
ecat7r.c:363:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  363 |   if(little) swabip(buf+404, 27*2); memcpy(h->fill_cti, buf+404, 27*2);
      |                                     ^~~~~~
ecat7r.c: In function 'ecat7ReadNormheader':
ecat7r.c:392:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  392 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |   ^~
ecat7r.c:392:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  392 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |                                ^~~~~~
ecat7r.c:393:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  393 |   if(little) swabip(buf+2, 2); memcpy(&h->num_r_elements, buf+2, 2);
      |   ^~
ecat7r.c:393:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  393 |   if(little) swabip(buf+2, 2); memcpy(&h->num_r_elements, buf+2, 2);
      |                                ^~~~~~
ecat7r.c:394:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  394 |   if(little) swabip(buf+4, 2); memcpy(&h->num_transaxial_crystals, buf+4, 2);
      |   ^~
ecat7r.c:394:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  394 |   if(little) swabip(buf+4, 2); memcpy(&h->num_transaxial_crystals, buf+4, 2);
      |                                ^~~~~~
ecat7r.c:395:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  395 |   if(little) swabip(buf+6, 2); memcpy(&h->num_crystal_rings, buf+6, 2);
      |   ^~
ecat7r.c:395:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  395 |   if(little) swabip(buf+6, 2); memcpy(&h->num_crystal_rings, buf+6, 2);
      |                                ^~~~~~
ecat7r.c:396:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  396 |   if(little) swabip(buf+8, 2); memcpy(&h->crystals_per_ring, buf+8, 2);
      |   ^~
ecat7r.c:396:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  396 |   if(little) swabip(buf+8, 2); memcpy(&h->crystals_per_ring, buf+8, 2);
      |                                ^~~~~~
ecat7r.c:397:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  397 |   if(little) swabip(buf+10, 2); memcpy(&h->num_geo_corr_planes, buf+10, 2);
      |   ^~
ecat7r.c:397:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  397 |   if(little) swabip(buf+10, 2); memcpy(&h->num_geo_corr_planes, buf+10, 2);
      |                                 ^~~~~~
ecat7r.c:398:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  398 |   if(little) swabip(buf+12, 2); memcpy(&h->uld, buf+12, 2);
      |   ^~
ecat7r.c:398:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  398 |   if(little) swabip(buf+12, 2); memcpy(&h->uld, buf+12, 2);
      |                                 ^~~~~~
ecat7r.c:399:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  399 |   if(little) swabip(buf+14, 2); memcpy(&h->lld, buf+14, 2);
      |   ^~
ecat7r.c:399:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  399 |   if(little) swabip(buf+14, 2); memcpy(&h->lld, buf+14, 2);
      |                                 ^~~~~~
ecat7r.c:400:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  400 |   if(little) swabip(buf+16, 2); memcpy(&h->scatter_energy, buf+16, 2);
      |   ^~
ecat7r.c:400:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  400 |   if(little) swabip(buf+16, 2); memcpy(&h->scatter_energy, buf+16, 2);
      |                                 ^~~~~~
ecat7r.c:401:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  401 |   if(little) swawbip(buf+18, 4); memcpy(&h->norm_quality_factor, buf+18, 4);
      |   ^~
ecat7r.c:401:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  401 |   if(little) swawbip(buf+18, 4); memcpy(&h->norm_quality_factor, buf+18, 4);
      |                                  ^~~~~~
ecat7r.c:402:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  402 |   if(little) swabip(buf+22, 2); memcpy(&h->norm_quality_factor_code, buf+22, 2);
      |   ^~
ecat7r.c:402:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  402 |   if(little) swabip(buf+22, 2); memcpy(&h->norm_quality_factor_code, buf+22, 2);
      |                                 ^~~~~~
ecat7r.c:403:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  403 |   if(little) swawbip(buf+24, 32*4); memcpy(h->ring_dtcor1, buf+24, 32*4);
      |   ^~
ecat7r.c:403:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  403 |   if(little) swawbip(buf+24, 32*4); memcpy(h->ring_dtcor1, buf+24, 32*4);
      |                                     ^~~~~~
ecat7r.c:404:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  404 |   if(little) swawbip(buf+152, 32*4); memcpy(h->ring_dtcor2, buf+152, 32*4);
      |   ^~
ecat7r.c:404:38: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  404 |   if(little) swawbip(buf+152, 32*4); memcpy(h->ring_dtcor2, buf+152, 32*4);
      |                                      ^~~~~~
ecat7r.c:405:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  405 |   if(little) swawbip(buf+280, 8*4); memcpy(h->crystal_dtcor, buf+280, 8*4);
      |   ^~
ecat7r.c:405:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  405 |   if(little) swawbip(buf+280, 8*4); memcpy(h->crystal_dtcor, buf+280, 8*4);
      |                                     ^~~~~~
ecat7r.c:406:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  406 |   if(little) swabip(buf+312, 2); memcpy(&h->span, buf+312, 2);
      |   ^~
ecat7r.c:406:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  406 |   if(little) swabip(buf+312, 2); memcpy(&h->span, buf+312, 2);
      |                                  ^~~~~~
ecat7r.c:407:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  407 |   if(little) swabip(buf+314, 2); memcpy(&h->max_ring_diff, buf+314, 2);
      |   ^~
ecat7r.c:407:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  407 |   if(little) swabip(buf+314, 2); memcpy(&h->max_ring_diff, buf+314, 2);
      |                                  ^~~~~~
ecat7r.c:408:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  408 |   if(little) swabip(buf+316, 48*2); memcpy(h->fill_cti, buf+316, 48*2);
      |   ^~
ecat7r.c:408:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  408 |   if(little) swabip(buf+316, 48*2); memcpy(h->fill_cti, buf+316, 48*2);
      |                                     ^~~~~~
ecat7r.c:409:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  409 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |   ^~
ecat7r.c:409:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  409 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |                                     ^~~~~~
ecat7r.c: In function 'ecat7ReadScanheader':
ecat7r.c:438:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  438 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |   ^~
ecat7r.c:438:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  438 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |                                ^~~~~~
ecat7r.c:439:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  439 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |   ^~
ecat7r.c:439:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  439 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |                                ^~~~~~
ecat7r.c:440:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  440 |   if(little) swabip(buf+4, 2); memcpy(&h->num_r_elements, buf+4, 2);
      |   ^~
ecat7r.c:440:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  440 |   if(little) swabip(buf+4, 2); memcpy(&h->num_r_elements, buf+4, 2);
      |                                ^~~~~~
ecat7r.c:441:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  441 |   if(little) swabip(buf+6, 2); memcpy(&h->num_angles, buf+6, 2);
      |   ^~
ecat7r.c:441:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  441 |   if(little) swabip(buf+6, 2); memcpy(&h->num_angles, buf+6, 2);
      |                                ^~~~~~
ecat7r.c:442:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  442 |   if(little) swabip(buf+8, 2); memcpy(&h->corrections_applied, buf+8, 2);
      |   ^~
ecat7r.c:442:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  442 |   if(little) swabip(buf+8, 2); memcpy(&h->corrections_applied, buf+8, 2);
      |                                ^~~~~~
ecat7r.c:443:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  443 |   if(little) swabip(buf+10, 64*2); memcpy(h->num_z_elements, buf+10, 64*2);
      |   ^~
ecat7r.c:443:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  443 |   if(little) swabip(buf+10, 64*2); memcpy(h->num_z_elements, buf+10, 64*2);
      |                                    ^~~~~~
ecat7r.c:444:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  444 |   if(little) swabip(buf+138, 2); memcpy(&h->ring_difference, buf+138, 2);
      |   ^~
ecat7r.c:444:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  444 |   if(little) swabip(buf+138, 2); memcpy(&h->ring_difference, buf+138, 2);
      |                                  ^~~~~~
ecat7r.c:445:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  445 |   if(little) swabip(buf+140, 2); memcpy(&h->storage_order, buf+140, 2);
      |   ^~
ecat7r.c:445:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  445 |   if(little) swabip(buf+140, 2); memcpy(&h->storage_order, buf+140, 2);
      |                                  ^~~~~~
ecat7r.c:446:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  446 |   if(little) swabip(buf+142, 2); memcpy(&h->axial_compression, buf+142, 2);
      |   ^~
ecat7r.c:446:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  446 |   if(little) swabip(buf+142, 2); memcpy(&h->axial_compression, buf+142, 2);
      |                                  ^~~~~~
ecat7r.c:447:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  447 |   if(little) swawbip(buf+144, 4); memcpy(&h->x_resolution, buf+144, 4);
      |   ^~
ecat7r.c:447:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  447 |   if(little) swawbip(buf+144, 4); memcpy(&h->x_resolution, buf+144, 4);
      |                                   ^~~~~~
ecat7r.c:448:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  448 |   if(little) swawbip(buf+148, 4); memcpy(&h->v_resolution, buf+148, 4);
      |   ^~
ecat7r.c:448:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  448 |   if(little) swawbip(buf+148, 4); memcpy(&h->v_resolution, buf+148, 4);
      |                                   ^~~~~~
ecat7r.c:449:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  449 |   if(little) swawbip(buf+152, 4); memcpy(&h->z_resolution, buf+152, 4);
      |   ^~
ecat7r.c:449:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  449 |   if(little) swawbip(buf+152, 4); memcpy(&h->z_resolution, buf+152, 4);
      |                                   ^~~~~~
ecat7r.c:450:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  450 |   if(little) swawbip(buf+156, 4); memcpy(&h->w_resolution, buf+156, 4);
      |   ^~
ecat7r.c:450:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  450 |   if(little) swawbip(buf+156, 4); memcpy(&h->w_resolution, buf+156, 4);
      |                                   ^~~~~~
ecat7r.c:451:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  451 |   if(little) swabip(buf+160, 6*2); memcpy(h->fill_gate, buf+160, 6*2);
      |   ^~
ecat7r.c:451:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  451 |   if(little) swabip(buf+160, 6*2); memcpy(h->fill_gate, buf+160, 6*2);
      |                                    ^~~~~~
ecat7r.c:452:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  452 |   if(little) swawbip(buf+172, 4); memcpy(&h->gate_duration, buf+172, 4);
      |   ^~
ecat7r.c:452:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  452 |   if(little) swawbip(buf+172, 4); memcpy(&h->gate_duration, buf+172, 4);
      |                                   ^~~~~~
ecat7r.c:453:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  453 |   if(little) swawbip(buf+176, 4); memcpy(&h->r_wave_offset, buf+176, 4);
      |   ^~
ecat7r.c:453:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  453 |   if(little) swawbip(buf+176, 4); memcpy(&h->r_wave_offset, buf+176, 4);
      |                                   ^~~~~~
ecat7r.c:454:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  454 |   if(little) swawbip(buf+180, 4); memcpy(&h->num_accepted_beats, buf+180, 4);
      |   ^~
ecat7r.c:454:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  454 |   if(little) swawbip(buf+180, 4); memcpy(&h->num_accepted_beats, buf+180, 4);
      |                                   ^~~~~~
ecat7r.c:455:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  455 |   if(little) swawbip(buf+184, 4); memcpy(&h->scale_factor, buf+184, 4);
      |   ^~
ecat7r.c:455:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  455 |   if(little) swawbip(buf+184, 4); memcpy(&h->scale_factor, buf+184, 4);
      |                                   ^~~~~~
ecat7r.c:456:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  456 |   if(little) swabip(buf+188, 2); memcpy(&h->scan_min, buf+188, 2);
      |   ^~
ecat7r.c:456:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  456 |   if(little) swabip(buf+188, 2); memcpy(&h->scan_min, buf+188, 2);
      |                                  ^~~~~~
ecat7r.c:457:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  457 |   if(little) swabip(buf+190, 2); memcpy(&h->scan_max, buf+190, 2);
      |   ^~
ecat7r.c:457:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  457 |   if(little) swabip(buf+190, 2); memcpy(&h->scan_max, buf+190, 2);
      |                                  ^~~~~~
ecat7r.c:458:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  458 |   if(little) swawbip(buf+192, 4); memcpy(&h->prompts, buf+192, 4);
      |   ^~
ecat7r.c:458:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  458 |   if(little) swawbip(buf+192, 4); memcpy(&h->prompts, buf+192, 4);
      |                                   ^~~~~~
ecat7r.c:459:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  459 |   if(little) swawbip(buf+196, 4); memcpy(&h->delayed, buf+196, 4);
      |   ^~
ecat7r.c:459:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  459 |   if(little) swawbip(buf+196, 4); memcpy(&h->delayed, buf+196, 4);
      |                                   ^~~~~~
ecat7r.c:460:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  460 |   if(little) swawbip(buf+200, 4); memcpy(&h->multiples, buf+200, 4);
      |   ^~
ecat7r.c:460:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  460 |   if(little) swawbip(buf+200, 4); memcpy(&h->multiples, buf+200, 4);
      |                                   ^~~~~~
ecat7r.c:461:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  461 |   if(little) swawbip(buf+204, 4); memcpy(&h->net_trues, buf+204, 4);
      |   ^~
ecat7r.c:461:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  461 |   if(little) swawbip(buf+204, 4); memcpy(&h->net_trues, buf+204, 4);
      |                                   ^~~~~~
ecat7r.c:462:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  462 |   if(little) swawbip(buf+208, 4); memcpy(&h->tot_avg_cor, buf+208, 4);
      |   ^~
ecat7r.c:462:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  462 |   if(little) swawbip(buf+208, 4); memcpy(&h->tot_avg_cor, buf+208, 4);
      |                                   ^~~~~~
ecat7r.c:463:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  463 |   if(little) swawbip(buf+212, 4); memcpy(&h->tot_avg_uncor, buf+212, 4);
      |   ^~
ecat7r.c:463:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  463 |   if(little) swawbip(buf+212, 4); memcpy(&h->tot_avg_uncor, buf+212, 4);
      |                                   ^~~~~~
ecat7r.c:464:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  464 |   if(little) swawbip(buf+216, 4); memcpy(&h->total_coin_rate, buf+216, 4);
      |   ^~
ecat7r.c:464:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  464 |   if(little) swawbip(buf+216, 4); memcpy(&h->total_coin_rate, buf+216, 4);
      |                                   ^~~~~~
ecat7r.c:465:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  465 |   if(little) swawbip(buf+220, 4); memcpy(&h->frame_start_time, buf+220, 4);
      |   ^~
ecat7r.c:465:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  465 |   if(little) swawbip(buf+220, 4); memcpy(&h->frame_start_time, buf+220, 4);
      |                                   ^~~~~~
ecat7r.c:466:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  466 |   if(little) swawbip(buf+224, 4); memcpy(&h->frame_duration, buf+224, 4);
      |   ^~
ecat7r.c:466:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  466 |   if(little) swawbip(buf+224, 4); memcpy(&h->frame_duration, buf+224, 4);
      |                                   ^~~~~~
ecat7r.c:467:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  467 |   if(little) swawbip(buf+228, 4); memcpy(&h->deadtime_correction_factor, buf+228, 4);
      |   ^~
ecat7r.c:467:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  467 |   if(little) swawbip(buf+228, 4); memcpy(&h->deadtime_correction_factor, buf+228, 4);
      |                                   ^~~~~~
ecat7r.c:468:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  468 |   if(little) swabip(buf+232, 90*2); memcpy(h->fill_cti, buf+232, 90*2);
      |   ^~
ecat7r.c:468:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  468 |   if(little) swabip(buf+232, 90*2); memcpy(h->fill_cti, buf+232, 90*2);
      |                                     ^~~~~~
ecat7r.c:469:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  469 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |   ^~
ecat7r.c:469:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  469 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |                                     ^~~~~~
ecat7r.c:470:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  470 |   if(little) swawbip(buf+512, 128*4); memcpy(h->uncor_singles, buf+512, 128*4);
      |   ^~
ecat7r.c:470:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  470 |   if(little) swawbip(buf+512, 128*4); memcpy(h->uncor_singles, buf+512, 128*4);
      |                                       ^~~~~~
ecat7r.c: In function 'ecat7Read2DScanheader':
ecat7r.c:499:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  499 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |   ^~
ecat7r.c:499:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  499 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |                                ^~~~~~
ecat7r.c:500:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  500 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |   ^~
ecat7r.c:500:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  500 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |                                ^~~~~~
ecat7r.c:501:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  501 |   if(little) swabip(buf+4, 2); memcpy(&h->num_r_elements, buf+4, 2);
      |   ^~
ecat7r.c:501:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  501 |   if(little) swabip(buf+4, 2); memcpy(&h->num_r_elements, buf+4, 2);
      |                                ^~~~~~
ecat7r.c:502:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  502 |   if(little) swabip(buf+6, 2); memcpy(&h->num_angles, buf+6, 2);
      |   ^~
ecat7r.c:502:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  502 |   if(little) swabip(buf+6, 2); memcpy(&h->num_angles, buf+6, 2);
      |                                ^~~~~~
ecat7r.c:503:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  503 |   if(little) swabip(buf+8, 2); memcpy(&h->corrections_applied, buf+8, 2);
      |   ^~
ecat7r.c:503:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  503 |   if(little) swabip(buf+8, 2); memcpy(&h->corrections_applied, buf+8, 2);
      |                                ^~~~~~
ecat7r.c:504:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  504 |   if(little) swabip(buf+10, 2); memcpy(&h->num_z_elements, buf+10, 2);
      |   ^~
ecat7r.c:504:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  504 |   if(little) swabip(buf+10, 2); memcpy(&h->num_z_elements, buf+10, 2);
      |                                 ^~~~~~
ecat7r.c:505:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  505 |   if(little) swabip(buf+12, 2); memcpy(&h->ring_difference, buf+12, 2);
      |   ^~
ecat7r.c:505:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  505 |   if(little) swabip(buf+12, 2); memcpy(&h->ring_difference, buf+12, 2);
      |                                 ^~~~~~
ecat7r.c:506:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  506 |   if(little) swawbip(buf+14, 4); memcpy(&h->x_resolution, buf+14, 4);
      |   ^~
ecat7r.c:506:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  506 |   if(little) swawbip(buf+14, 4); memcpy(&h->x_resolution, buf+14, 4);
      |                                  ^~~~~~
ecat7r.c:507:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  507 |   if(little) swawbip(buf+18, 4); memcpy(&h->y_resolution, buf+18, 4);
      |   ^~
ecat7r.c:507:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  507 |   if(little) swawbip(buf+18, 4); memcpy(&h->y_resolution, buf+18, 4);
      |                                  ^~~~~~
ecat7r.c:508:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  508 |   if(little) swawbip(buf+22, 4); memcpy(&h->z_resolution, buf+22, 4);
      |   ^~
ecat7r.c:508:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  508 |   if(little) swawbip(buf+22, 4); memcpy(&h->z_resolution, buf+22, 4);
      |                                  ^~~~~~
ecat7r.c:509:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  509 |   if(little) swawbip(buf+26, 4); memcpy(&h->w_resolution, buf+26, 4);
      |   ^~
ecat7r.c:509:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  509 |   if(little) swawbip(buf+26, 4); memcpy(&h->w_resolution, buf+26, 4);
      |                                  ^~~~~~
ecat7r.c:510:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  510 |   if(little) swabip(buf+30, 6*2); memcpy(h->fill_gate, buf+30, 6*2);
      |   ^~
ecat7r.c:510:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  510 |   if(little) swabip(buf+30, 6*2); memcpy(h->fill_gate, buf+30, 6*2);
      |                                   ^~~~~~
ecat7r.c:511:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  511 |   if(little) swawbip(buf+42, 4); memcpy(&h->gate_duration, buf+42, 4);
      |   ^~
ecat7r.c:511:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  511 |   if(little) swawbip(buf+42, 4); memcpy(&h->gate_duration, buf+42, 4);
      |                                  ^~~~~~
ecat7r.c:512:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  512 |   if(little) swawbip(buf+46, 4); memcpy(&h->r_wave_offset, buf+46, 4);
      |   ^~
ecat7r.c:512:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  512 |   if(little) swawbip(buf+46, 4); memcpy(&h->r_wave_offset, buf+46, 4);
      |                                  ^~~~~~
ecat7r.c:513:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  513 |   if(little) swawbip(buf+50, 4); memcpy(&h->num_accepted_beats, buf+50, 4);
      |   ^~
ecat7r.c:513:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  513 |   if(little) swawbip(buf+50, 4); memcpy(&h->num_accepted_beats, buf+50, 4);
      |                                  ^~~~~~
ecat7r.c:514:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  514 |   if(little) swawbip(buf+54, 4); memcpy(&h->scale_factor, buf+54, 4);
      |   ^~
ecat7r.c:514:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  514 |   if(little) swawbip(buf+54, 4); memcpy(&h->scale_factor, buf+54, 4);
      |                                  ^~~~~~
ecat7r.c:515:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  515 |   if(little) swabip(buf+58, 2); memcpy(&h->scan_min, buf+58, 2);
      |   ^~
ecat7r.c:515:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  515 |   if(little) swabip(buf+58, 2); memcpy(&h->scan_min, buf+58, 2);
      |                                 ^~~~~~
ecat7r.c:516:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  516 |   if(little) swabip(buf+60, 2); memcpy(&h->scan_max, buf+60, 2);
      |   ^~
ecat7r.c:516:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  516 |   if(little) swabip(buf+60, 2); memcpy(&h->scan_max, buf+60, 2);
      |                                 ^~~~~~
ecat7r.c:517:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  517 |   if(little) swawbip(buf+62, 4); memcpy(&h->prompts, buf+62, 4);
      |   ^~
ecat7r.c:517:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  517 |   if(little) swawbip(buf+62, 4); memcpy(&h->prompts, buf+62, 4);
      |                                  ^~~~~~
ecat7r.c:518:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  518 |   if(little) swawbip(buf+66, 4); memcpy(&h->delayed, buf+66, 4);
      |   ^~
ecat7r.c:518:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  518 |   if(little) swawbip(buf+66, 4); memcpy(&h->delayed, buf+66, 4);
      |                                  ^~~~~~
ecat7r.c:519:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  519 |   if(little) swawbip(buf+70, 4); memcpy(&h->multiples, buf+70, 4);
      |   ^~
ecat7r.c:519:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  519 |   if(little) swawbip(buf+70, 4); memcpy(&h->multiples, buf+70, 4);
      |                                  ^~~~~~
ecat7r.c:520:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  520 |   if(little) swawbip(buf+74, 4); memcpy(&h->net_trues, buf+74, 4);
      |   ^~
ecat7r.c:520:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  520 |   if(little) swawbip(buf+74, 4); memcpy(&h->net_trues, buf+74, 4);
      |                                  ^~~~~~
ecat7r.c:521:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  521 |   if(little) swawbip(buf+78, 16*4); memcpy(h->cor_singles, buf+78, 16*4);
      |   ^~
ecat7r.c:521:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  521 |   if(little) swawbip(buf+78, 16*4); memcpy(h->cor_singles, buf+78, 16*4);
      |                                     ^~~~~~
ecat7r.c:522:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  522 |   if(little) swawbip(buf+142, 16*4); memcpy(h->uncor_singles, buf+142, 16*4);
      |   ^~
ecat7r.c:522:38: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  522 |   if(little) swawbip(buf+142, 16*4); memcpy(h->uncor_singles, buf+142, 16*4);
      |                                      ^~~~~~
ecat7r.c:523:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  523 |   if(little) swawbip(buf+206, 4); memcpy(&h->tot_avg_cor, buf+206, 4);
      |   ^~
ecat7r.c:523:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  523 |   if(little) swawbip(buf+206, 4); memcpy(&h->tot_avg_cor, buf+206, 4);
      |                                   ^~~~~~
ecat7r.c:524:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  524 |   if(little) swawbip(buf+210, 4); memcpy(&h->tot_avg_uncor, buf+210, 4);
      |   ^~
ecat7r.c:524:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  524 |   if(little) swawbip(buf+210, 4); memcpy(&h->tot_avg_uncor, buf+210, 4);
      |                                   ^~~~~~
ecat7r.c:525:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  525 |   if(little) swawbip(buf+214, 4); memcpy(&h->total_coin_rate, buf+214, 4);
      |   ^~
ecat7r.c:525:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  525 |   if(little) swawbip(buf+214, 4); memcpy(&h->total_coin_rate, buf+214, 4);
      |                                   ^~~~~~
ecat7r.c:526:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  526 |   if(little) swawbip(buf+218, 4); memcpy(&h->frame_start_time, buf+218, 4);
      |   ^~
ecat7r.c:526:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  526 |   if(little) swawbip(buf+218, 4); memcpy(&h->frame_start_time, buf+218, 4);
      |                                   ^~~~~~
ecat7r.c:527:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  527 |   if(little) swawbip(buf+222, 4); memcpy(&h->frame_duration, buf+222, 4);
      |   ^~
ecat7r.c:527:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  527 |   if(little) swawbip(buf+222, 4); memcpy(&h->frame_duration, buf+222, 4);
      |                                   ^~~~~~
ecat7r.c:528:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  528 |   if(little) swawbip(buf+226, 4); memcpy(&h->deadtime_correction_factor, buf+226, 4);
      |   ^~
ecat7r.c:528:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  528 |   if(little) swawbip(buf+226, 4); memcpy(&h->deadtime_correction_factor, buf+226, 4);
      |                                   ^~~~~~
ecat7r.c:529:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  529 |   if(little) swabip(buf+230, 8*2); memcpy(h->physical_planes, buf+230, 8*2);
      |   ^~
ecat7r.c:529:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  529 |   if(little) swabip(buf+230, 8*2); memcpy(h->physical_planes, buf+230, 8*2);
      |                                    ^~~~~~
ecat7r.c:530:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  530 |   if(little) swabip(buf+246, 83*2); memcpy(h->fill_cti, buf+246, 83*2);
      |   ^~
ecat7r.c:530:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  530 |   if(little) swabip(buf+246, 83*2); memcpy(h->fill_cti, buf+246, 83*2);
      |                                     ^~~~~~
ecat7r.c:531:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  531 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |   ^~
ecat7r.c:531:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  531 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |                                     ^~~~~~
ecat7r.c: In function 'ecat7Read2DNormheader':
ecat7r.c:560:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  560 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |   ^~
ecat7r.c:560:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  560 |   if(little) swabip(buf+0, 2); memcpy(&h->data_type, buf+0, 2);
      |                                ^~~~~~
ecat7r.c:561:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  561 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |   ^~
ecat7r.c:561:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  561 |   if(little) swabip(buf+2, 2); memcpy(&h->num_dimensions, buf+2, 2);
      |                                ^~~~~~
ecat7r.c:562:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  562 |   if(little) swabip(buf+4, 2); memcpy(&h->num_r_elements, buf+4, 2);
      |   ^~
ecat7r.c:562:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  562 |   if(little) swabip(buf+4, 2); memcpy(&h->num_r_elements, buf+4, 2);
      |                                ^~~~~~
ecat7r.c:563:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  563 |   if(little) swabip(buf+6, 2); memcpy(&h->num_angles, buf+6, 2);
      |   ^~
ecat7r.c:563:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  563 |   if(little) swabip(buf+6, 2); memcpy(&h->num_angles, buf+6, 2);
      |                                ^~~~~~
ecat7r.c:564:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  564 |   if(little) swabip(buf+8, 2); memcpy(&h->num_z_elements, buf+8, 2);
      |   ^~
ecat7r.c:564:32: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  564 |   if(little) swabip(buf+8, 2); memcpy(&h->num_z_elements, buf+8, 2);
      |                                ^~~~~~
ecat7r.c:565:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  565 |   if(little) swabip(buf+10, 2); memcpy(&h->ring_difference, buf+10, 2);
      |   ^~
ecat7r.c:565:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  565 |   if(little) swabip(buf+10, 2); memcpy(&h->ring_difference, buf+10, 2);
      |                                 ^~~~~~
ecat7r.c:566:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  566 |   if(little) swawbip(buf+12, 4); memcpy(&h->scale_factor, buf+12, 4);
      |   ^~
ecat7r.c:566:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  566 |   if(little) swawbip(buf+12, 4); memcpy(&h->scale_factor, buf+12, 4);
      |                                  ^~~~~~
ecat7r.c:567:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  567 |   if(little) swawbip(buf+16, 4); memcpy(&h->norm_min, buf+16, 4);
      |   ^~
ecat7r.c:567:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  567 |   if(little) swawbip(buf+16, 4); memcpy(&h->norm_min, buf+16, 4);
      |                                  ^~~~~~
ecat7r.c:568:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  568 |   if(little) swawbip(buf+20, 4); memcpy(&h->norm_max, buf+20, 4);
      |   ^~
ecat7r.c:568:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  568 |   if(little) swawbip(buf+20, 4); memcpy(&h->norm_max, buf+20, 4);
      |                                  ^~~~~~
ecat7r.c:569:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  569 |   if(little) swawbip(buf+24, 4); memcpy(&h->fov_source_width, buf+24, 4);
      |   ^~
ecat7r.c:569:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  569 |   if(little) swawbip(buf+24, 4); memcpy(&h->fov_source_width, buf+24, 4);
      |                                  ^~~~~~
ecat7r.c:570:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  570 |   if(little) swawbip(buf+28, 4); memcpy(&h->norm_quality_factor, buf+28, 4);
      |   ^~
ecat7r.c:570:34: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  570 |   if(little) swawbip(buf+28, 4); memcpy(&h->norm_quality_factor, buf+28, 4);
      |                                  ^~~~~~
ecat7r.c:571:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  571 |   if(little) swabip(buf+32, 2); memcpy(&h->norm_quality_factor_code, buf+32, 2);
      |   ^~
ecat7r.c:571:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  571 |   if(little) swabip(buf+32, 2); memcpy(&h->norm_quality_factor_code, buf+32, 2);
      |                                 ^~~~~~
ecat7r.c:572:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  572 |   if(little) swabip(buf+34, 2); memcpy(&h->storage_order, buf+34, 2);
      |   ^~
ecat7r.c:572:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  572 |   if(little) swabip(buf+34, 2); memcpy(&h->storage_order, buf+34, 2);
      |                                 ^~~~~~
ecat7r.c:573:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  573 |   if(little) swabip(buf+36, 2); memcpy(&h->span, buf+36, 2);
      |   ^~
ecat7r.c:573:33: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  573 |   if(little) swabip(buf+36, 2); memcpy(&h->span, buf+36, 2);
      |                                 ^~~~~~
ecat7r.c:574:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  574 |   if(little) swabip(buf+38, 64*2); memcpy(h->fill_cti, buf+38, 64*2);
      |   ^~
ecat7r.c:574:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  574 |   if(little) swabip(buf+38, 64*2); memcpy(h->fill_cti, buf+38, 64*2);
      |                                    ^~~~~~
ecat7r.c:575:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  575 |   if(little) swabip(buf+166, 123*2); memcpy(h->fill_cti, buf+166, 123*2);
      |   ^~
ecat7r.c:575:38: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  575 |   if(little) swabip(buf+166, 123*2); memcpy(h->fill_cti, buf+166, 123*2);
      |                                      ^~~~~~
ecat7r.c:576:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  576 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |   ^~
ecat7r.c:576:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  576 |   if(little) swabip(buf+412, 50*2); memcpy(h->fill_user, buf+412, 50*2);
      |                                     ^~~~~~
ecat7r.c: In function 'ecat7ReadScanMatrix':
ecat7r.c:868:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
  868 |   for(i=dimz=0; i<64; i++) dimz+=h->num_z_elements[i]; pxlNr*=dimz;
      |   ^~~
ecat7r.c:868:56: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
  868 |   for(i=dimz=0; i<64; i++) dimz+=h->num_z_elements[i]; pxlNr*=dimz;
      |                                                        ^~~~~
ecat7w.c: In function 'ecat7WriteScanMatrix':
ecat7w.c:870:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
  870 |   for(i=dimz=0; i<64; i++) dimz+=h->num_z_elements[i]; pxlNr*=dimz;
      |   ^~~
ecat7w.c:870:56: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
  870 |   for(i=dimz=0; i<64; i++) dimz+=h->num_z_elements[i]; pxlNr*=dimz;
      |                                                        ^~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat7p.o ecat7p.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat7ml.o ecat7ml.c
ecat7p.c: In function 'ecat7PrintImageheader':
ecat7p.c:202:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
  202 |   for(i=0; i<87; i++) fprintf(fp, " %d", h->fill_cti[i]); fprintf(fp, "\n");
      |   ^~~
ecat7p.c:202:59: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
  202 |   for(i=0; i<87; i++) fprintf(fp, " %d", h->fill_cti[i]); fprintf(fp, "\n");
      |                                                           ^~~~~~~
ecat7p.c:204:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
  204 |   for(i=0; i<49; i++) fprintf(fp, " %d", h->fill_user[i]); fprintf(fp, "\n");
      |   ^~~
ecat7p.c:204:60: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
  204 |   for(i=0; i<49; i++) fprintf(fp, " %d", h->fill_user[i]); fprintf(fp, "\n");
      |                                                            ^~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o ecat7h.o ecat7h.c
ecat7h.c: In function 'ecat7EditMHeader':
ecat7h.c:38:7: warning: variable 'ii' set but not used [-Wunused-but-set-variable]
   38 |   int ii, yy, mm, dd, ho, mi, se;
      |       ^~
In file included from /usr/include/string.h:504,
                 from ecat7h.c:16:
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:180:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 32 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:161:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 10 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:133:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 20 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:127:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 32 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:125:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 32 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:123:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 32 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:105:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 32 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:103:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 16 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:101:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 12 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:69:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 32 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:65:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 8 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:56:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 10 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:48:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 32 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat7EditMHeader' at ecat7h.c:46:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 14 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o analyze.o analyze.c
analyze.c: In function 'anaReadHeader':
analyze.c:140:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  140 |   if(!same_order) swawbip(buf1+0, 4); memcpy(&h->hk.sizeof_hdr, buf1+0, 4);
      |   ^~
analyze.c:140:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  140 |   if(!same_order) swawbip(buf1+0, 4); memcpy(&h->hk.sizeof_hdr, buf1+0, 4);
      |                                       ^~~~~~
analyze.c:143:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  143 |   if(!same_order) swawbip(buf1+32, 4); memcpy(&h->hk.extents, buf1+32, 4);
      |   ^~
analyze.c:143:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  143 |   if(!same_order) swawbip(buf1+32, 4); memcpy(&h->hk.extents, buf1+32, 4);
      |                                        ^~~~~~
analyze.c:144:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  144 |   if(!same_order) swabip(buf1+36, 2); memcpy(&h->hk.session_error, buf1+36, 2);
      |   ^~
analyze.c:144:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  144 |   if(!same_order) swabip(buf1+36, 2); memcpy(&h->hk.session_error, buf1+36, 2);
      |                                       ^~~~~~
analyze.c:149:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  149 |   if(!same_order) swabip(buf2+0, 16); memcpy(h->dime.dim, buf2+0, 16);
      |   ^~
analyze.c:149:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  149 |   if(!same_order) swabip(buf2+0, 16); memcpy(h->dime.dim, buf2+0, 16);
      |                                       ^~~~~~
analyze.c:150:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  150 |   if(!same_order) swabip(buf2+16, 2); memcpy(&h->dime.unused8, buf2+16, 2);
      |   ^~
analyze.c:150:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  150 |   if(!same_order) swabip(buf2+16, 2); memcpy(&h->dime.unused8, buf2+16, 2);
      |                                       ^~~~~~
analyze.c:151:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  151 |   if(!same_order) swabip(buf2+18, 2); memcpy(&h->dime.unused9, buf2+18, 2);
      |   ^~
analyze.c:151:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  151 |   if(!same_order) swabip(buf2+18, 2); memcpy(&h->dime.unused9, buf2+18, 2);
      |                                       ^~~~~~
analyze.c:152:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  152 |   if(!same_order) swabip(buf2+20, 2); memcpy(&h->dime.unused10, buf2+20, 2);
      |   ^~
analyze.c:152:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  152 |   if(!same_order) swabip(buf2+20, 2); memcpy(&h->dime.unused10, buf2+20, 2);
      |                                       ^~~~~~
analyze.c:153:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  153 |   if(!same_order) swabip(buf2+22, 2); memcpy(&h->dime.unused11, buf2+22, 2);
      |   ^~
analyze.c:153:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  153 |   if(!same_order) swabip(buf2+22, 2); memcpy(&h->dime.unused11, buf2+22, 2);
      |                                       ^~~~~~
analyze.c:154:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  154 |   if(!same_order) swabip(buf2+24, 2); memcpy(&h->dime.unused12, buf2+24, 2);
      |   ^~
analyze.c:154:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  154 |   if(!same_order) swabip(buf2+24, 2); memcpy(&h->dime.unused12, buf2+24, 2);
      |                                       ^~~~~~
analyze.c:155:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  155 |   if(!same_order) swabip(buf2+26, 2); memcpy(&h->dime.unused13, buf2+26, 2);
      |   ^~
analyze.c:155:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  155 |   if(!same_order) swabip(buf2+26, 2); memcpy(&h->dime.unused13, buf2+26, 2);
      |                                       ^~~~~~
analyze.c:156:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  156 |   if(!same_order) swabip(buf2+28, 2); memcpy(&h->dime.unused14, buf2+28, 2);
      |   ^~
analyze.c:156:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  156 |   if(!same_order) swabip(buf2+28, 2); memcpy(&h->dime.unused14, buf2+28, 2);
      |                                       ^~~~~~
analyze.c:157:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  157 |   if(!same_order) swabip(buf2+30, 2); memcpy(&h->dime.datatype, buf2+30, 2);
      |   ^~
analyze.c:157:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  157 |   if(!same_order) swabip(buf2+30, 2); memcpy(&h->dime.datatype, buf2+30, 2);
      |                                       ^~~~~~
analyze.c:158:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  158 |   if(!same_order) swabip(buf2+32, 2); memcpy(&h->dime.bitpix, buf2+32, 2);
      |   ^~
analyze.c:158:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  158 |   if(!same_order) swabip(buf2+32, 2); memcpy(&h->dime.bitpix, buf2+32, 2);
      |                                       ^~~~~~
analyze.c:159:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  159 |   if(!same_order) swabip(buf2+34, 2); memcpy(&h->dime.dim_un0, buf2+34, 2);
      |   ^~
analyze.c:159:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  159 |   if(!same_order) swabip(buf2+34, 2); memcpy(&h->dime.dim_un0, buf2+34, 2);
      |                                       ^~~~~~
analyze.c:160:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  160 |   if(!same_order) swawbip(buf2+36, 32); memcpy(h->dime.pixdim, buf2+36, 32);
      |   ^~
analyze.c:160:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  160 |   if(!same_order) swawbip(buf2+36, 32); memcpy(h->dime.pixdim, buf2+36, 32);
      |                                         ^~~~~~
analyze.c:161:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  161 |   if(!same_order) swawbip(buf2+68, 4); memcpy(&h->dime.vox_offset, buf2+68, 4);
      |   ^~
analyze.c:161:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  161 |   if(!same_order) swawbip(buf2+68, 4); memcpy(&h->dime.vox_offset, buf2+68, 4);
      |                                        ^~~~~~
analyze.c:162:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  162 |   if(!same_order) swawbip(buf2+72, 4); memcpy(&h->dime.funused1, buf2+72, 4);
      |   ^~
analyze.c:162:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  162 |   if(!same_order) swawbip(buf2+72, 4); memcpy(&h->dime.funused1, buf2+72, 4);
      |                                        ^~~~~~
analyze.c:163:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  163 |   if(!same_order) swawbip(buf2+76, 4); memcpy(&h->dime.funused2, buf2+76, 4);
      |   ^~
analyze.c:163:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  163 |   if(!same_order) swawbip(buf2+76, 4); memcpy(&h->dime.funused2, buf2+76, 4);
      |                                        ^~~~~~
analyze.c:164:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  164 |   if(!same_order) swawbip(buf2+80, 4); memcpy(&h->dime.funused3, buf2+80, 4);
      |   ^~
analyze.c:164:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  164 |   if(!same_order) swawbip(buf2+80, 4); memcpy(&h->dime.funused3, buf2+80, 4);
      |                                        ^~~~~~
analyze.c:165:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  165 |   if(!same_order) swawbip(buf2+84, 4); memcpy(&h->dime.cal_max, buf2+84, 4);
      |   ^~
analyze.c:165:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  165 |   if(!same_order) swawbip(buf2+84, 4); memcpy(&h->dime.cal_max, buf2+84, 4);
      |                                        ^~~~~~
analyze.c:166:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  166 |   if(!same_order) swawbip(buf2+88, 4); memcpy(&h->dime.cal_min, buf2+88, 4);
      |   ^~
analyze.c:166:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  166 |   if(!same_order) swawbip(buf2+88, 4); memcpy(&h->dime.cal_min, buf2+88, 4);
      |                                        ^~~~~~
analyze.c:167:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  167 |   if(!same_order) swawbip(buf2+92, 4); memcpy(&h->dime.compressed, buf2+92, 4);
      |   ^~
analyze.c:167:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  167 |   if(!same_order) swawbip(buf2+92, 4); memcpy(&h->dime.compressed, buf2+92, 4);
      |                                        ^~~~~~
analyze.c:168:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  168 |   if(!same_order) swawbip(buf2+96, 4); memcpy(&h->dime.verified, buf2+96, 4);
      |   ^~
analyze.c:168:40: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  168 |   if(!same_order) swawbip(buf2+96, 4); memcpy(&h->dime.verified, buf2+96, 4);
      |                                        ^~~~~~
analyze.c:169:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  169 |   if(!same_order) swawbip(buf2+100, 4); memcpy(&h->dime.glmax, buf2+100, 4);
      |   ^~
analyze.c:169:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  169 |   if(!same_order) swawbip(buf2+100, 4); memcpy(&h->dime.glmax, buf2+100, 4);
      |                                         ^~~~~~
analyze.c:170:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  170 |   if(!same_order) swawbip(buf2+104, 4); memcpy(&h->dime.glmin, buf2+104, 4);
      |   ^~
analyze.c:170:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  170 |   if(!same_order) swawbip(buf2+104, 4); memcpy(&h->dime.glmin, buf2+104, 4);
      |                                         ^~~~~~
analyze.c:183:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  183 |   if(!same_order) swawbip(buf3+168, 4); memcpy(&h->hist.views, buf3+168, 4);
      |   ^~
analyze.c:183:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  183 |   if(!same_order) swawbip(buf3+168, 4); memcpy(&h->hist.views, buf3+168, 4);
      |                                         ^~~~~~
analyze.c:184:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  184 |   if(!same_order) swawbip(buf3+172, 4); memcpy(&h->hist.vols_added, buf3+172, 4);
      |   ^~
analyze.c:184:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  184 |   if(!same_order) swawbip(buf3+172, 4); memcpy(&h->hist.vols_added, buf3+172, 4);
      |                                         ^~~~~~
analyze.c:185:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  185 |   if(!same_order) swawbip(buf3+176, 4); memcpy(&h->hist.start_field, buf3+176, 4);
      |   ^~
analyze.c:185:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  185 |   if(!same_order) swawbip(buf3+176, 4); memcpy(&h->hist.start_field, buf3+176, 4);
      |                                         ^~~~~~
analyze.c:186:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  186 |   if(!same_order) swawbip(buf3+180, 4); memcpy(&h->hist.field_skip, buf3+180, 4);
      |   ^~
analyze.c:186:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  186 |   if(!same_order) swawbip(buf3+180, 4); memcpy(&h->hist.field_skip, buf3+180, 4);
      |                                         ^~~~~~
analyze.c:187:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  187 |   if(!same_order) swawbip(buf3+184, 4); memcpy(&h->hist.omax, buf3+184, 4);
      |   ^~
analyze.c:187:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  187 |   if(!same_order) swawbip(buf3+184, 4); memcpy(&h->hist.omax, buf3+184, 4);
      |                                         ^~~~~~
analyze.c:188:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  188 |   if(!same_order) swawbip(buf3+188, 4); memcpy(&h->hist.omin, buf3+188, 4);
      |   ^~
analyze.c:188:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  188 |   if(!same_order) swawbip(buf3+188, 4); memcpy(&h->hist.omin, buf3+188, 4);
      |                                         ^~~~~~
analyze.c:189:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  189 |   if(!same_order) swawbip(buf3+192, 4); memcpy(&h->hist.smax, buf3+192, 4);
      |   ^~
analyze.c:189:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  189 |   if(!same_order) swawbip(buf3+192, 4); memcpy(&h->hist.smax, buf3+192, 4);
      |                                         ^~~~~~
analyze.c:190:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  190 |   if(!same_order) swawbip(buf3+196, 4); memcpy(&h->hist.smin, buf3+196, 4);
      |   ^~
analyze.c:190:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  190 |   if(!same_order) swawbip(buf3+196, 4); memcpy(&h->hist.smin, buf3+196, 4);
      |                                         ^~~~~~
analyze.c: In function 'anaReadImagedata':
analyze.c:401:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  401 |   if(dimNr>3) dimt=h->dime.dim[4]; if(frame>dimt) return(3);
      |   ^~
analyze.c:401:36: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  401 |   if(dimNr>3) dimt=h->dime.dim[4]; if(frame>dimt) return(3);
      |                                    ^~
analyze.c: In function 'anaRemoveFNameExtension':
analyze.c:598:6: warning: implicit declaration of function 'strcasecmp'; did you mean 'strncmp'? [-Wimplicit-function-declaration]
  598 |   if(strcasecmp(cptr, ".")==0 || strcasecmp(cptr, ".img")==0 ||
      |      ^~~~~~~~~~
      |      strncmp
analyze.c: In function 'anaDatabaseExists':
analyze.c:644:11: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  644 |           if(siffile!=NULL) strcpy(siffile, temp); return(2);
      |           ^~
analyze.c:644:52: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  644 |           if(siffile!=NULL) strcpy(siffile, temp); return(2);
      |                                                    ^~~~~~
In function 'strncpy',
    inlined from 'ecat7EditVHeader' at ecat7h.c:397:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' specified bound 40 equals destination size [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o interfile.o interfile.c
interfile.c: In function 'interfile_read':
interfile.c:118:33: warning: iteration 512 invokes undefined behavior [-Waggressive-loop-optimizations]
  118 |     for (i=0;i<516;i++) line[i] = '\0';                    /* initialise line */
      |                         ~~~~~~~~^~~~~~
interfile.c:118:5: note: within this loop
  118 |     for (i=0;i<516;i++) line[i] = '\0';                    /* initialise line */
      |     ^~~
interfile.c:118:33: warning: '__builtin_memset' forming offset [512, 515] is out of the bounds [0, 512] of object 'line' with type 'char[512]' [-Warray-bounds]
  118 |     for (i=0;i<516;i++) line[i] = '\0';                    /* initialise line */
      |                         ~~~~~~~~^~~~~~
interfile.c:76:14: note: 'line' declared here
   76 |   char       line[512];  /* max length of a line accepted in interfile header */
      |              ^~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o micropet.o micropet.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o imgfile.o imgfile.c
In file included from /usr/include/string.h:504,
                 from micropet.c:42:
In function 'strncpy',
    inlined from 'imgGetMicropetSIF' at micropet.c:738:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 8 bytes from a string of length 1023 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o img_ana.o img_ana.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o img_e63.o img_e63.c
img_ana.c: In function 'imgWriteAnalyze':
img_ana.c:289:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  289 |   if(cptr!=NULL) cptr++; if(cptr==NULL) cptr=dbname;
      |   ^~
img_ana.c:289:26: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  289 |   if(cptr!=NULL) cptr++; if(cptr==NULL) cptr=dbname;
      |                          ^~
img_ana.c: In function 'imgSetAnalyzeHeader':
img_ana.c:565:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  565 |   if(cptr!=NULL) cptr++; if(cptr==NULL) cptr=(char*)dbname;
      |   ^~
img_ana.c:565:26: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  565 |   if(cptr!=NULL) cptr++; if(cptr==NULL) cptr=(char*)dbname;
      |                          ^~
img_e63.c: In function 'ecat63ReadAllToImg':
img_e63.c:93:23: warning: variable 'iptr' set but not used [-Wunused-but-set-variable]
   93 |   int                *iptr;
      |                       ^~~~
img_e63.c:78:64: warning: variable 'pxlNr' set but not used [-Wunused-but-set-variable]
   78 |   int                 i, j, m, ret, blkNr=0, dim_x=0, dim_y=0, pxlNr=0;
      |                                                                ^~~~~
img_e63.c: In function 'ecat63ReadPlaneToImg':
img_e63.c:569:64: warning: variable 'pxlNr' set but not used [-Wunused-but-set-variable]
  569 |   int                 i, j, m, ret, blkNr=0, dim_x=0, dim_y=0, pxlNr=0, del_nr=0;
      |                                                                ^~~~~
img_e63.c: In function 'ecat63AddImg':
img_e63.c:889:37: warning: variable 'prev_frame' set but not used [-Wunused-but-set-variable]
  889 |   int                 frame, plane, prev_frame, prev_plane;
      |                                     ^~~~~~~~~~
img_e63.c: In function 'imgReadEcat63Header':
img_e63.c:1291:41: warning: variable 'del_nr' set but not used [-Wunused-but-set-variable]
 1291 |   int                 frameNr, planeNr, del_nr=0;
      |                                         ^~~~~~
img_e63.c: In function 'imgReadEcat63Frame':
img_e63.c:1478:23: warning: variable 'iptr' set but not used [-Wunused-but-set-variable]
 1478 |   int                *iptr;
      |                       ^~~~
In file included from /usr/include/string.h:504,
                 from img_ana.c:52:
In function 'strncpy',
    inlined from 'imgWriteAnalyze' at img_ana.c:318:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output truncated before terminating nul copying 10 bytes from a string of the same length [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o img_e7.o img_e7.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o imgunit.o imgunit.c
In file included from /usr/include/string.h:504,
                 from img_e63.c:48:
In function 'strncpy',
    inlined from 'ecat63ReadAllToImg' at img_e63.c:232:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 11 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat63ReadAllToImg' at img_e63.c:233:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 31 bytes from a string of length 31 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat63ReadAllToImg' at img_e63.c:234:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 15 bytes from a string of length 15 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'imgWriteAnalyze' at img_ana.c:312:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 10 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/string.h:504,
                 from img_e7.c:56:
In function 'strncpy',
    inlined from 'imgGetEcat7MHeader' at img_e7.c:705:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 11 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'imgSetEcat7MHeader' at img_e7.c:783:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 10 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o imgmax.o imgmax.c
In function 'strncpy',
    inlined from 'imgSetAnalyzeHeader' at img_ana.c:588:3,
    inlined from 'imgSetAnalyzeHeader' at img_ana.c:542:5:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 10 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strcpy',
    inlined from 'imgSetAnalyzeHeader' at img_ana.c:594:5,
    inlined from 'imgSetAnalyzeHeader' at img_ana.c:542:5:
/usr/include/bits/string_fortified.h:90:10: warning: '__builtin___strcpy_chk' writing 11 bytes into a region of size 10 [-Wstringop-overflow=]
   90 |   return __builtin___strcpy_chk (__dest, __src, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from img_ana.c:60:
img_ana.c: In function 'imgSetAnalyzeHeader':
include/analyze.h:86:8: note: at offset 0 to object 'exp_date' with size 10 declared here
   86 |   char exp_date[10];
      |        ^~~~~~~~
imgmax.c: In function 'imgReadMinMax':
imgmax.c:190:7: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
  190 |       if(fmin!=NULL) *fmin=frmin; if(fmin!=NULL) *fmax=frmax;
      |       ^~
imgmax.c:190:35: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
  190 |       if(fmin!=NULL) *fmin=frmin; if(fmin!=NULL) *fmax=frmax;
      |                                   ^~
In function 'strncpy',
    inlined from 'ecat63WriteAllImg' at img_e63.c:435:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 10 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o imgdecay.o imgdecay.c
In function 'strncpy',
    inlined from 'ecat63ReadPlaneToImg' at img_e63.c:747:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 11 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat63ReadPlaneToImg' at img_e63.c:748:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 31 bytes from a string of length 31 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'ecat63ReadPlaneToImg' at img_e63.c:749:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 15 bytes from a string of length 15 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o vol.o vol.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o img.o img.c
In function 'strncpy',
    inlined from 'ecat63AddImg' at img_e63.c:954:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 10 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'imgGetEcat63MHeader' at img_e63.c:1179:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 11 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'imgGetEcat63MHeader' at img_e63.c:1180:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 31 bytes from a string of length 31 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'imgGetEcat63MHeader' at img_e63.c:1181:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 15 bytes from a string of length 15 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In function 'strncpy',
    inlined from 'imgSetEcat63MHeader' at img_e63.c:1248:3:
/usr/include/bits/string_fortified.h:106:10: warning: '__builtin_strncpy' output may be truncated copying 10 bytes from a string of length 10 [-Wstringop-truncation]
  106 |   return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest));
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o sifio.o sifio.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o sif.o sif.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o weight.o weight.c
gcc -O2 -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -std=c99 -Iinclude/ -I/usr/include/libtpcmisc/ -D_XOPEN_SOURCE -U__STRICT_ANSI__ -fPIC -DPIC   -c -o libtpcimgiov.o libtpcimgiov.c
ar -rvs libtpcimgio.a ecat63r.o ecat63w.o ecat63p.o ecat63ml.o ecat7r.o ecat7w.o ecat7p.o ecat7ml.o ecat7h.o analyze.o interfile.o micropet.o imgfile.o img_ana.o img_e63.o img_e7.o imgunit.o imgmax.o imgdecay.o vol.o img.o sifio.o sif.o weight.o libtpcimgiov.o
gcc -shared -o libtpcimgio.so.0.0.0 ecat63r.o ecat63w.o ecat63p.o ecat63ml.o ecat7r.o ecat7w.o ecat7p.o ecat7ml.o ecat7h.o analyze.o interfile.o micropet.o imgfile.o img_ana.o img_e63.o img_e7.o imgunit.o imgmax.o imgdecay.o vol.o img.o sifio.o sif.o weight.o libtpcimgiov.o -Wl,-soname=libtpcimgio.so.0
ar: creating libtpcimgio.a
/usr/bin/ld: ecat63w.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: ecat63w.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: ecat63p.o: in function `.LANCHOR1':
/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: ecat63p.o: in function `.LANCHOR1':
/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: ecat7w.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: ecat7w.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: ecat7p.o: in function `.LANCHOR1':
/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: ecat7p.o: in function `.LANCHOR1':
/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: ecat7ml.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: ecat7ml.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: ecat7ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: ecat7h.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: ecat7h.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: micropet.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: micropet.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: micropet.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: micropet.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: micropet.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: multiple definition of `ANALYZE_TEST'; analyze.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: first defined here
/usr/bin/ld: micropet.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
a - ecat63r.o
a - ecat63w.o
a - ecat63p.o
a - ecat63ml.o
a - ecat7r.o
a - ecat7w.o
a - ecat7p.o
a - ecat7ml.o
a - ecat7h.o
a - analyze.o
a - interfile.o
a - micropet.o
a - imgfile.o
a - img_ana.o
a - img_e63.o
a - img_e7.o
a - imgunit.o
a - imgmax.o
a - imgdecay.o
a - vol.o
a - img.o
a - sifio.o
a - sif.o
a - weight.o
a - libtpcimgiov.o
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: multiple definition of `SIF_TEST'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: first defined here
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: multiple definition of `siferrmsg'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: first defined here
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: multiple definition of `ANALYZE_TEST'; analyze.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: first defined here
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: imgfile.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: multiple definition of `SIF_TEST'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: multiple definition of `siferrmsg'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: first defined here
/usr/bin/ld: img_ana.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: multiple definition of `ANALYZE_TEST'; analyze.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: multiple definition of `ANALYZE_TEST'; analyze.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: multiple definition of `SIF_TEST'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: multiple definition of `siferrmsg'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: img_e63.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: img_e7.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: img_e7.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: img_e7.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: img_e7.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: multiple definition of `ANALYZE_TEST'; analyze.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: first defined here
/usr/bin/ld: img_e7.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: img_e7.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: imgunit.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: imgunit.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: imgunit.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: imgmax.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: imgmax.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: multiple definition of `ANALYZE_TEST'; analyze.o:/builddir/build/BUILD/libtpcimgio/include/analyze.h:41: first defined here
/usr/bin/ld: imgmax.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: multiple definition of `ECAT63_TEST'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:52: first defined here
/usr/bin/ld: imgmax.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: multiple definition of `ecat63errmsg'; ecat63r.o:/builddir/build/BUILD/libtpcimgio/include/ecat63.h:50: first defined here
/usr/bin/ld: imgmax.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: imgmax.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: imgdecay.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: vol.o:/builddir/build/BUILD/libtpcimgio/include/vol.h:20: multiple definition of `VOL_TEST'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/vol.h:20: first defined here
/usr/bin/ld: vol.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: img.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: multiple definition of `IMG_TEST'; ecat63ml.o:/builddir/build/BUILD/libtpcimgio/include/img.h:128: first defined here
/usr/bin/ld: img.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: multiple definition of `ECAT7_TEST'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:101: first defined here
/usr/bin/ld: img.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: multiple definition of `ecat7errmsg'; ecat7r.o:/builddir/build/BUILD/libtpcimgio/include/ecat7.h:99: first defined here
/usr/bin/ld: sifio.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: multiple definition of `SIF_TEST'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: first defined here
/usr/bin/ld: sifio.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: multiple definition of `siferrmsg'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: first defined here
/usr/bin/ld: sif.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: multiple definition of `SIF_TEST'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: first defined here
/usr/bin/ld: sif.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: multiple definition of `siferrmsg'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: first defined here
/usr/bin/ld: weight.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: multiple definition of `SIF_TEST'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:63: first defined here
/usr/bin/ld: weight.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: multiple definition of `siferrmsg'; micropet.o:/builddir/build/BUILD/libtpcimgio/include/sif.h:33: first defined here
collect2: error: ld returned 1 exit status
make: *** [Makefile:105: libtpcimgio.so.0.0.0] Error 1
RPM build errors:
error: Bad exit status from /var/tmp/rpm-tmp.FeypgC (%build)
    Bad exit status from /var/tmp/rpm-tmp.FeypgC (%build)
Child return code was: 1
EXCEPTION: [Error()]
Traceback (most recent call last):
  File "/usr/lib/python3.8/site-packages/mockbuild/trace_decorator.py", line 95, in trace
    result = func(*args, **kw)
  File "/usr/lib/python3.8/site-packages/mockbuild/util.py", line 746, in do_with_status
    raise exception.Error("Command failed: \n # %s\n%s" % (command, output), child.returncode)
mockbuild.exception.Error: Command failed: 
 # bash --login -c /usr/bin/rpmbuild -bb --target riscv64 --nodeps /builddir/build/SPECS/libtpcimgio.spec