Attachment 1252486 Details for Bug 1423711 – build.log

build.log

<fdopen> (text/plain), 554.25 KB, created by Fedora Release Engineering on 2017-02-17 14:26:52 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Fedora Release Engineering

Created: 2017-02-17 14:26:52 UTC

Size: 554.25 KB

patch

obsolete

>Mock Version: 1.3.3
>Mock Version: 1.3.3
>ENTER ['do'](['bash', '--login', '-c', '/usr/bin/rpmbuild -bs --target ppc64 --nodeps /builddir/build/SPECS/hmmer.spec'], env={'LANG': 'en_US.UTF-8', 'HOSTNAME': 'mock', 'HOME': '/builddir', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'SHELL': '/bin/bash', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'TERM': 'vt100'}uid=1000timeout=172800gid=425user='mockbuild'logger=<mockbuild.trace_decorator.getLog object at 0x3fff84b82358>chrootPath='/var/lib/mock/f26-build-7623084-694261/root'shell=FalseprintOutput=False)
>Executing command: ['bash', '--login', '-c', '/usr/bin/rpmbuild -bs --target ppc64 --nodeps /builddir/build/SPECS/hmmer.spec'] with env {'LANG': 'en_US.UTF-8', 'HOSTNAME': 'mock', 'HOME': '/builddir', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'SHELL': '/bin/bash', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'TERM': 'vt100'} and shell False
>Building target platforms: ppc64
>Building for target ppc64
>Wrote: /builddir/build/SRPMS/hmmer-3.1b2-5.fc26.src.rpm
>Child return code was: 0
>ENTER ['do'](['bash', '--login', '-c', '/usr/bin/rpmbuild -bb --target ppc64 --nodeps /builddir/build/SPECS/hmmer.spec'], env={'LANG': 'en_US.UTF-8', 'HOSTNAME': 'mock', 'HOME': '/builddir', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'SHELL': '/bin/bash', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'TERM': 'vt100'}uid=1000timeout=172800gid=425user='mockbuild'logger=<mockbuild.trace_decorator.getLog object at 0x3fff84b82358>chrootPath='/var/lib/mock/f26-build-7623084-694261/root'shell=FalseprintOutput=Falseprivate_network=True)
>Executing command: ['bash', '--login', '-c', '/usr/bin/rpmbuild -bb --target ppc64 --nodeps /builddir/build/SPECS/hmmer.spec'] with env {'LANG': 'en_US.UTF-8', 'HOSTNAME': 'mock', 'HOME': '/builddir', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'SHELL': '/bin/bash', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'TERM': 'vt100'} and shell False
>Building target platforms: ppc64
>Building for target ppc64
>Executing(%prep): /bin/sh -e /var/tmp/rpm-tmp.jZbW3k
>+ umask 022
>+ cd /builddir/build/BUILD
>+ cd /builddir/build/BUILD
>+ rm -rf hmmer-3.1b2
>+ /usr/bin/gzip -dc /builddir/build/SOURCES/hmmer-3.1b2.tar.gz
>+ /usr/bin/tar -xof -
>+ STATUS=0
>+ '[' 0 -ne 0 ']'
>+ cd hmmer-3.1b2
>+ /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w .
>+ sed -i '/impl_choice=vmx;;/d' configure
>+ exit 0
>Executing(%build): /bin/sh -e /var/tmp/rpm-tmp.q8Nulm
>+ umask 022
>+ cd /builddir/build/BUILD
>+ cd hmmer-3.1b2
>+ CFLAGS='-O2 -g -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -m64'
>+ export CFLAGS
>+ CXXFLAGS='-O2 -g -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -m64'
>+ export CXXFLAGS
>+ FFLAGS='-O2 -g -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -m64 -I/usr/lib64/gfortran/modules'
>+ export FFLAGS
>+ FCFLAGS='-O2 -g -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -m64 -I/usr/lib64/gfortran/modules'
>+ export FCFLAGS
>+ LDFLAGS='-Wl,-z,relro -specs=/usr/lib/rpm/redhat/redhat-hardened-ld'
>+ export LDFLAGS
>+ '[' 1 = 1 ']'
>+++ dirname ./configure
>++ find . -name config.guess -o -name config.sub
>+ for i in $(find $(dirname ./configure) -name config.guess -o -name config.sub)
>++ basename ./config.guess
>+ '[' -f /usr/lib/rpm/redhat/config.guess ']'
>+ /usr/bin/rm -f ./config.guess
>++ basename ./config.guess
>+ /usr/bin/cp -fv /usr/lib/rpm/redhat/config.guess ./config.guess
>'/usr/lib/rpm/redhat/config.guess' -> './config.guess'
>+ for i in $(find $(dirname ./configure) -name config.guess -o -name config.sub)
>++ basename ./config.sub
>+ '[' -f /usr/lib/rpm/redhat/config.sub ']'
>+ /usr/bin/rm -f ./config.sub
>++ basename ./config.sub
>+ /usr/bin/cp -fv /usr/lib/rpm/redhat/config.sub ./config.sub
>'/usr/lib/rpm/redhat/config.sub' -> './config.sub'
>+ for i in $(find $(dirname ./configure) -name config.guess -o -name config.sub)
>++ basename ./easel/config.guess
>+ '[' -f /usr/lib/rpm/redhat/config.guess ']'
>+ /usr/bin/rm -f ./easel/config.guess
>++ basename ./easel/config.guess
>+ /usr/bin/cp -fv /usr/lib/rpm/redhat/config.guess ./easel/config.guess
>'/usr/lib/rpm/redhat/config.guess' -> './easel/config.guess'
>+ for i in $(find $(dirname ./configure) -name config.guess -o -name config.sub)
>++ basename ./easel/config.sub
>+ '[' -f /usr/lib/rpm/redhat/config.sub ']'
>+ /usr/bin/rm -f ./easel/config.sub
>++ basename ./easel/config.sub
>+ /usr/bin/cp -fv /usr/lib/rpm/redhat/config.sub ./easel/config.sub
>'/usr/lib/rpm/redhat/config.sub' -> './easel/config.sub'
>+ '[' 1 = 1 ']'
>+ '[' x '!=' x-specs=/usr/lib/rpm/redhat/redhat-hardened-ld ']'
>++ find . -name ltmain.sh
>+ ./configure --build=ppc64-redhat-linux-gnu --host=ppc64-redhat-linux-gnu --program-prefix= --disable-dependency-tracking --prefix=/usr --exec-prefix=/usr --bindir=/usr/bin --sbindir=/usr/sbin --sysconfdir=/etc --datadir=/usr/share --includedir=/usr/include --libdir=/usr/lib64 --libexecdir=/usr/libexec --localstatedir=/var --sharedstatedir=/var/lib --mandir=/usr/share/man --infodir=/usr/share/info
>configure: WARNING: unrecognized options: --disable-dependency-tracking
>configure: Configuring HMMER for your system.
>checking build system type... powerpc64-redhat-linux-gnu
>checking host system type... powerpc64-redhat-linux-gnu
>configure: Full HMMER source distribution - using full configuration
>checking for ppc64-redhat-linux-gnu-gcc... no
>checking for gcc... gcc
>checking whether the C compiler works... yes
>checking for C compiler default output file name... a.out
>checking for suffix of executables... 
>checking whether we are cross compiling... no
>checking for suffix of object files... o
>checking whether we are using the GNU C compiler... yes
>checking whether gcc accepts -g... yes
>checking for gcc option to accept ISO C89... none needed
>checking for C compiler vendor... gnu
>checking for the pthreads library -lpthreads... no
>checking whether pthreads work without any flags... no
>checking whether pthreads work with -Kthread... no
>checking whether pthreads work with -kthread... no
>checking for the pthreads library -llthread... no
>checking whether pthreads work with -pthread... yes
>checking for joinable pthread attribute... PTHREAD_CREATE_JOINABLE
>checking if more special flags are required for pthreads... no
>checking for cc_r... gcc
>configure: WARNING: It appears your platform will not fully support H3.
>configure: WARNING: We'll use the 'dummy' implementation, a slow reference implementation.
>checking for ppc64-redhat-linux-gnu-gcc... gcc
>checking whether we are using the GNU C compiler... (cached) yes
>checking whether gcc accepts -g... (cached) yes
>checking for gcc option to accept ISO C89... (cached) none needed
>checking for a BSD-compatible install... /usr/bin/install -c
>checking how to run the C preprocessor... gcc -E
>checking for C compiler vendor... (cached) gnu
>checking for gcc option to accept ISO C99... none needed
>checking for gcc option to accept ISO Standard C... (cached) none needed
>checking for ppc64-redhat-linux-gnu-ranlib... no
>checking for ranlib... ranlib
>checking for ar... /usr/bin/ar
>checking whether you have a GNU make... yes, you do; and we assume you will use it!
>checking for a sed that does not truncate output... /usr/bin/sed
>checking for gcc option to produce PIC... -fPIC
>configure: Activating "dummy" implementation
>checking compiler support --start-group... yes
>checking for gzip... /usr/bin/gzip
>checking for grep that handles long lines and -e... /usr/bin/grep
>checking for egrep... /usr/bin/grep -E
>checking for ANSI C header files... yes
>checking for sys/types.h... yes
>checking for sys/stat.h... yes
>checking for stdlib.h... yes
>checking for string.h... yes
>checking for memory.h... yes
>checking for strings.h... yes
>checking for inttypes.h... yes
>checking for stdint.h... yes
>checking for unistd.h... yes
>checking endian.h usability... yes
>checking endian.h presence... yes
>checking for endian.h... yes
>checking for inttypes.h... (cached) yes
>checking for stdint.h... (cached) yes
>checking for unistd.h... (cached) yes
>checking for sys/types.h... (cached) yes
>checking netinet/in.h usability... yes
>checking netinet/in.h presence... yes
>checking for netinet/in.h... yes
>checking sys/param.h usability... yes
>checking sys/param.h presence... yes
>checking for sys/param.h... yes
>checking for sys/sysctl.h... yes
>checking whether byte ordering is bigendian... yes
>checking for uint8_t... yes
>checking for uint16_t... yes
>checking for uint32_t... yes
>checking for uint64_t... yes
>checking for off_t... yes
>checking for mkstemp... yes
>checking for popen... yes
>checking for strcasecmp... yes
>checking for times... yes
>checking for getpid... yes
>checking for sysctl... yes
>checking for sysconf... yes
>checking for getcwd... yes
>checking for stat... yes
>checking for fstat... yes
>checking for ntohs... yes
>checking for ntohl... yes
>checking for htons... yes
>checking for htonl... yes
>checking for _LARGEFILE_SOURCE value needed for large files... no
>checking for special C compiler options needed for large files... no
>checking for _FILE_OFFSET_BITS value needed for large files... no
>configure: creating ./config.status
>config.status: creating documentation/Makefile
>config.status: creating documentation/man/Makefile
>config.status: creating src/Makefile
>config.status: creating testsuite/Makefile
>config.status: creating profmark/Makefile
>config.status: creating src/impl_dummy/Makefile
>config.status: creating easel/miniapps/Makefile
>config.status: creating easel/testsuite/Makefile
>config.status: creating easel/Makefile
>config.status: creating libdivsufsort/Makefile
>config.status: creating Makefile
>config.status: creating src/p7_config.h
>config.status: creating easel/esl_config.h
>config.status: creating libdivsufsort/divsufsort.h
>config.status: linking src/impl_dummy to src/impl
>configure: WARNING: unrecognized options: --disable-dependency-tracking
>HMMER configuration:
>     compiler:             gcc -O2 -g -pipe -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -m64  -pthread -fPIC
>     host:                 powerpc64-redhat-linux-gnu
>     linker:               -Wl,-z,relro -specs=/usr/lib/rpm/redhat/redhat-hardened-ld
>     libraries:              
>     DP implementation:    dummy
>configure: WARNING: We will compile the "dummy", a portable ANSI C reference implementation.
>configure: WARNING: It is slow, about 100x slower than real H3, and is NOT intended for production use!
>configure: WARNING: It only intended to show the basics of how HMMER3 works, portably.
>+ make -j4
>     SUBDIR easel
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/easel'
>     CC easel.o
>     CC esl_alphabet.o
>     CC esl_buffer.o
>     CC esl_cluster.o
>In file included from easel.c:39:0:
>easel.c: In function 'esl_strdup':
>easel.c:579:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(new, sizeof(char) * (n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>easel.c: In function 'esl_vsprintf':
>easel.c:974:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (n1+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c: In function 'esl_alphabet_Create':
>esl_alphabet.c:54:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>In file included from esl_alphabet.c:21:0:
>esl_alphabet.c: In function 'esl_alphabet_CreateCustom':
>esl_alphabet.c:124:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->sym,    sizeof(char)   * (Kp+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c:125:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->degen,  sizeof(char *) * Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c:126:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->ndegen, sizeof(int)    * Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c:131:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->degen[0], sizeof(char) * (Kp*K));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c:107:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>easel.c: In function 'esl_str_IsInteger':
>easel.c:1178:9: warning: variable 'val' set but not used [-Wunused-but-set-variable]
>   long  val;
>         ^~~
>In file included from esl_alphabet.c:21:0:
>esl_alphabet.c: In function 'set_complementarity':
>esl_alphabet.c:360:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->complement, sizeof(ESL_DSQ) * a->Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from easel.c:39:0:
>easel.c: In function 'esl_FileTail':
>easel.c:1320:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tail, sizeof(char) * (strlen(path)+1)); /* a little overkill */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c: In function 'esl_abc_CreateDsq':
>esl_alphabet.c:634:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>easel.c: In function 'esl_FileConcat':
>easel.c:1413:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(path, sizeof(char) * (nd+nf+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c: In function 'esl_abc_dsqdup':
>esl_alphabet.c:824:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(new, sizeof(ESL_DSQ) * (L+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_alphabet.c: In function 'esl_abc_dsqcat':
>esl_alphabet.c:925:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(*dsq, sizeof(ESL_DSQ)     * (n+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>easel.c: In function 'esl_FileNewSuffix':
>easel.c:1469:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(new, sizeof(char) * (nf+strlen(sfx)+2)); /* '.' too */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>easel.c: In function 'esl_FileEnvOpen':
>easel.c:1543:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(path, sizeof(char) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from esl_buffer.c:37:0:
>esl_buffer.c: In function 'esl_buffer_OpenPipe':
>esl_buffer.c:348:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * bf->pagesize);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_buffer.c: In function 'esl_buffer_OpenStream':
>easel.c: In function 'esl_getcwd':
>esl_buffer.c:478:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * bf->pagesize);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>easel.c:1771:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(cwd, sizeof(char) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_buffer.c: In function 'esl_buffer_FetchLine':
>esl_buffer.c:1082:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(p, sizeof(char) * nc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_buffer.c: In function 'esl_buffer_FetchLineAsStr':
>esl_buffer.c:1148:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (nc+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_buffer.c: In function 'esl_buffer_FetchToken':
>esl_buffer.c:1345:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tok, sizeof(char) * nc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_buffer.c: In function 'esl_buffer_FetchTokenAsStr':
>     CC esl_composition.o
>esl_buffer.c:1428:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tok, sizeof(char) * (nc+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_buffer.c: In function 'buffer_init_file_slurped':
>esl_buffer.c:1603:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * filesize);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_buffer.c: In function 'buffer_init_file_basic':
>esl_buffer.c:1626:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * bf->pagesize);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_dirichlet.o
>esl_alphabet.c: In function 'esl_alphabet_CreateCustom':
>esl_alphabet.c:171:3: warning: 'a' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   esl_alphabet_Destroy(a);
>   ^~~~~~~~~~~~~~~~~~~~~~~
>In file included from esl_dirichlet.c:21:0:
>esl_dirichlet.c: In function 'esl_mixdchlet_Create':
>esl_dirichlet.c:60:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pri->pq,    sizeof(double)   * N);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c:61:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pri->alpha, sizeof(double *) * N);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c:64:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pri->alpha[0], sizeof(double) * N * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c:52:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_dirichlet.c:21:0:
>esl_dirichlet.c: In function 'esl_mixdchlet_Compare':
>esl_dirichlet.c:181:22: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A, d1->N * sizeof(int*));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c:183:27: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(A[i], d1->N * sizeof(int) );
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c: In function 'esl_dirichlet_LogProbData_Mixture':
>esl_dirichlet.c:512:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mixq, sizeof(double)*d->N);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c: In function 'esl_mixdchlet_Fit':
>esl_dirichlet.c:857:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c:858:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(u,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dirichlet.c:859:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(wrk, sizeof(double) * np * 4);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_distance.o
>esl_dirichlet.c: In function 'esl_mixdchlet_Fit_Multipass':
>esl_dirichlet.c:986:10: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   return status;
>          ^~~~~~
>esl_distance.c: In function 'esl_dst_CPairIdMx':
>esl_distance.c:354:7: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int status;
>       ^~~~~~
>esl_distance.c: In function 'esl_dst_CJukesCantorMx':
>esl_distance.c:467:16: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int          status;
>                ^~~~~~
>esl_distance.c: In function 'esl_dst_XPairIdMx':
>esl_distance.c:539:7: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int status;
>       ^~~~~~
>     CC esl_dmatrix.o
>     CC esl_exponential.o
>     CC esl_fileparser.o
>esl_distance.c: In function 'esl_dst_XJukesCantorMx':
>esl_distance.c:653:16: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int          status;
>                ^~~~~~
>In file included from esl_dmatrix.c:30:0:
>esl_dmatrix.c: In function 'esl_dmatrix_Create':
>esl_dmatrix.c:64:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A->mx, sizeof(double *) * n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dmatrix.c:67:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A->mx[0], sizeof(double) * n * m);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dmatrix.c:57:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_dmatrix.c:30:0:
>esl_dmatrix.c: In function 'esl_dmatrix_CreateUpper':
>esl_dmatrix.c:113:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A->mx, sizeof(double *) * n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dmatrix.c:101:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_dmatrix.c:30:0:
>esl_dmatrix.c: In function 'esl_permutation_Create':
>esl_dmatrix.c:454:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(P->pi, sizeof(int) * n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dmatrix.c:448:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>esl_dmatrix.c: In function 'esl_dmx_AddScale':
>esl_dmatrix.c:893:15: warning: self-comparison always evaluates to false [-Wtautological-compare]
>   if (A->type != A->type) ESL_EXCEPTION(eslEINVAL, "matrices of different type");
>               ^~
>In file included from esl_dmatrix.c:30:0:
>esl_dmatrix.c: In function 'esl_dmx_Invert':
>esl_dmatrix.c:1087:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b, sizeof(double) * A->n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_dmatrix.c:1088:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(y, sizeof(double) * A->n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_gamma.o
>esl_fileparser.c: In function 'esl_fileparser_Create':
>esl_fileparser.c:103:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     CC esl_getopts.o
>     CC esl_gev.o
>     CC esl_gumbel.o
>In file included from esl_getopts.c:22:0:
>esl_getopts.c: In function 'esl_getopts_Create':
>esl_getopts.c:109:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(g->val,    sizeof(char *) * g->nopts);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_getopts.c:110:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(g->setby,  sizeof(int)    * g->nopts);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_getopts.c:111:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(g->valloc, sizeof(int)    * g->nopts);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_getopts.c:65:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_getopts.c:22:0:
>esl_getopts.c: In function 'esl_opt_SpoofCmdline':
>esl_getopts.c:736:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cmdline, sizeof(char) * (ntot+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_getopts.c: In function 'set_option':
>esl_getopts.c:1218:77: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>        if (g->valloc[opti] == 0) ESL_ALLOC (g->val[opti],      sizeof(char) * (arglen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_histogram.o
>esl_dmatrix.c: In function 'esl_dmx_LUP_decompose':
>esl_dmatrix.c:976:37: warning: 'kpiv' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       j = P->pi[k]; P->pi[k] = P->pi[kpiv]; P->pi[kpiv] = j;
>                                     ^
>In file included from esl_histogram.c:19:0:
>esl_histogram.c: In function 'esl_histogram_Create':
>esl_histogram.c:111:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->obs, sizeof(uint64_t) * h->nb);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_histogram.c:74:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_histogram.c:19:0:
>esl_histogram.c: In function 'esl_histogram_CreateFull':
>esl_histogram.c:139:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->x, sizeof(double) * h->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_histogram.c:133:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_histogram.c:19:0:
>esl_histogram.c: In function 'esl_histogram_SetExpect':
>esl_histogram.c:758:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(h->expect, sizeof(double) * h->nb);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_histogram.c: In function 'esl_histogram_SetExpectedTail':
>esl_histogram.c:814:63: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (h->expect == NULL)  ESL_ALLOC(h->expect, sizeof(double) * h->nb);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_histogram.c: In function 'esl_histogram_Goodness':
>esl_histogram.c:1262:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(obs,  sizeof(uint64_t) * (nb*2+1)); /* final nb must be <= 2*nb+1 */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_histogram.c:1263:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(exp,  sizeof(double)   * (nb*2+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_histogram.c:1264:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(topx, sizeof(double)   * (nb*2+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_hmm.o
>     CC esl_hyperexp.o
>In file included from esl_hmm.c:9:0:
>esl_hmm.c: In function 'esl_hmm_Create':
>esl_hmm.c:37:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->t,  sizeof(float *) * M);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:38:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->e,  sizeof(float *) * M);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:39:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->eo, sizeof(float *) * abc->Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:44:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->t[0],  sizeof(float) * M * (M+1));  /* state M is the implicit end state */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:45:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->e[0],  sizeof(float) * M * abc->K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:46:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->eo[0], sizeof(float) * abc->Kp * M);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:47:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->pi,    sizeof(float) * (M+1));      /* initial transition to state M means a L=0 sequence */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:31:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from esl_hmm.c:9:0:
>esl_hmm.c: In function 'esl_hmx_Create':
>esl_hmm.c:196:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mx->dp_mem, sizeof(float) * (allocL+1) * allocM);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:199:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mx->dp, sizeof (float *) * (allocL+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:200:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mx->sc, sizeof (float)   * (allocL+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hmm.c:189:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from esl_hyperexp.c:9:0:
>esl_hyperexp.c: In function 'esl_hyperexp_Create':
>esl_hyperexp.c:61:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->q,         sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:62:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->lambda,    sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:63:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->wrk,       sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:64:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->fixlambda, sizeof(char)   * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:51:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>In file included from esl_hyperexp.c:9:0:
>esl_hyperexp.c: In function 'esl_hxp_FitComplete':
>esl_hyperexp.c:867:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:868:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(u,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:869:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(wrk, sizeof(double) * np * 4);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c: In function 'esl_hxp_FitCompleteBinned':
>esl_hyperexp.c:1095:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:1096:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(u,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_hyperexp.c:1097:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(wrk, sizeof(double) * np * 4);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_getopts.c: In function 'esl_opt_ProcessCmdline':
>esl_getopts.c:1393:9: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int   opti;  /* option number found                               */
>         ^~~~
>In file included from esl_getopts.c:22:0:
>esl_getopts.c: In function 'esl_opt_VerifyConfig':
>esl_getopts.c:648:39: warning: '%.24s' directive output may be truncated writing up to 24 bytes into a region of size between 21 and 54 [-Wformat-truncation=]
>       ESL_FAIL(eslESYNTAX, g->errbuf, "Option %.24s (set by cfg file %d) requires (or has no effect without) option(s) %.24s",
>                                       ^
>easel.h:57:57: note: in definition of macro 'ESL_FAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from esl_getopts.c:18:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output between 75 and 132 bytes into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>esl_getopts.c: In function 'esl_opt_IsDefault':
>esl_getopts.c:789:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>esl_getopts.c: In function 'esl_opt_IsOn':
>esl_getopts.c:821:8: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    int opti;
>        ^~~~
>esl_getopts.c: In function 'esl_opt_IsUsed':
>esl_getopts.c:849:13: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (g->val[opti] == NULL)          return FALSE;
>             ^
>esl_getopts.c: In function 'esl_opt_GetSetter':
>esl_getopts.c:869:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>esl_getopts.c: In function 'esl_opt_GetBoolean':
>esl_getopts.c:885:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>esl_getopts.c: In function 'esl_opt_GetInteger':
>esl_getopts.c:905:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>esl_getopts.c: In function 'esl_opt_GetReal':
>esl_getopts.c:923:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>esl_getopts.c: In function 'esl_opt_GetChar':
>esl_getopts.c:942:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>esl_getopts.c: In function 'esl_opt_GetString':
>esl_getopts.c:965:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>     CC esl_keyhash.o
>In file included from esl_keyhash.c:22:0:
>esl_keyhash.c: In function 'keyhash_create':
>esl_keyhash.c:381:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->hashtable, sizeof(int) * kh->hashsize);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_keyhash.c:384:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->key_offset, sizeof(int) * kh->kalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_keyhash.c:385:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->nxt,        sizeof(int) * kh->kalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_keyhash.c:388:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->smem,   sizeof(char) * kh->salloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_keyhash.c:369:8: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int  status;
>        ^~~~~~
>esl_keyhash.c: In function 'key_upsize':
>esl_keyhash.c:460:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>     CC esl_mem.o
>In file included from esl_mem.c:23:0:
>esl_mem.c: In function 'esl_memstrdup':
>esl_mem.c:392:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mem.c: In function 'esl_memtod':
>esl_mem.c:451:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(bigbuf, sizeof(char) * (n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mem.c: In function 'esl_memtof':
>esl_mem.c:492:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(bigbuf, sizeof(char) * (n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_minimizer.o
>     CC esl_mixgev.o
>esl_minimizer.c: In function 'esl_min_ConjugateGradientDescent':
>esl_minimizer.c:316:31: warning: 'e' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       if (fabs(p) < fabs(0.5*q*r) || p < q*(a-x) || p < q*(b-x))
>                          ~~~~~^~
>esl_minimizer.c:286:12: note: 'e' was declared here
>   double d,e;                   /* last, next-to-last values of p/q  */
>            ^
>esl_minimizer.c:290:18: warning: 'cx' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   x=v=w= a + c*(b-a);           /* initial guess of x by golden section */
>                ~~^~~
>esl_minimizer.c:427:16: note: 'cx' was declared here
>   double ax,bx,cx;
>                ^~
>esl_minimizer.c:290:8: warning: 'ax' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   x=v=w= a + c*(b-a);           /* initial guess of x by golden section */
>       ~^~~~~~~~~~~~~
>esl_minimizer.c:427:10: note: 'ax' was declared here
>   double ax,bx,cx;
>          ^~
>     CC esl_mpi.o
>In file included from esl_mixgev.c:13:0:
>esl_mixgev.c: In function 'esl_mixgev_Create':
>esl_mixgev.c:66:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mg->q,        sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:67:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mg->mu,       sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:68:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mg->lambda,   sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:69:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mg->alpha,    sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:70:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mg->wrk,      sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:71:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mg->isgumbel, sizeof(int)    * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:59:15: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int         status;
>               ^~~~~~
>In file included from esl_mixgev.c:13:0:
>esl_mixgev.c: In function 'esl_mixgev_FitComplete':
>esl_mixgev.c:645:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:646:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(u,   sizeof(double) * np);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_mixgev.c:647:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(wrk, sizeof(double) * np * 4);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_msa.o
>     CC esl_msacluster.o
>     CC esl_msafile.o
>In file included from esl_msa.c:30:0:
>esl_msa.c: In function 'esl_msa_Create':
>esl_msa.c:107:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->aseq,   sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:114:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->aseq[i], sizeof(char) * (alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:100:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from esl_msacluster.c:23:0:
>esl_msacluster.c: In function 'esl_msacluster_SingleLinkage':
>esl_msacluster.c:135:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(workspace,  sizeof(int) * msa->nseq * 2);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from esl_msa.c:30:0:
>esl_msa.c: In function 'esl_msa_Copy':
>esl_msa.c:309:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->sqacc, sizeof(char **) * new->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:314:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->sqdesc, sizeof(char **) * new->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:319:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->ss, sizeof(char **) * new->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:324:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->sa, sizeof(char **) * msa->nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:329:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->pp, sizeof(char **) * msa->nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:340:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->comment, sizeof(char **) * msa->ncomment);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:348:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gf_tag, sizeof(char **) * msa->ngf);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msacluster.c:136:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(assignment, sizeof(int) * msa->nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msacluster.c:155:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(nin, sizeof(int) * nc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:349:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gf,     sizeof(char **) * msa->ngf);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:359:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gs_tag, sizeof(char **)  * msa->ngs);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:360:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gs,     sizeof(char ***) * msa->ngs);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:363:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(new->gs[i], sizeof(char **) * msa->nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:371:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gc_tag, sizeof(char **) * msa->ngc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:372:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gc,     sizeof(char **) * msa->ngc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:381:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gr_tag, sizeof(char **)  * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:382:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gr,     sizeof(char ***) * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:385:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(new->gr[i], sizeof(char **) * msa->nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'msa_create_mostly':
>esl_msa.c:622:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqname, sizeof(char *) * nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:623:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->wgt,    sizeof(double) * nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:624:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqlen,  sizeof(int64_t)* nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:542:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from esl_msa.c:30:0:
>esl_msa.c: In function 'esl_msa_CreateDigital':
>esl_msa.c:784:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->ax,   sizeof(ESL_DSQ *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:791:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->ax[i], sizeof(ESL_DSQ) * (alen+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:777:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from esl_msa.c:30:0:
>esl_msa.c: In function 'esl_msa_Digitize':
>esl_msa.c:858:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->ax, msa->sqalloc * sizeof(ESL_DSQ *));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:861:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->ax[i], (msa->alen+2) * sizeof(ESL_DSQ));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_Textize':
>esl_msa.c:913:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->aseq, msa->sqalloc * sizeof(char *));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:916:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->aseq[i], (msa->alen+1) * sizeof(char));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_SetSeqAccession':
>esl_msa.c:1162:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqacc, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_SetSeqDescription':
>esl_msa.c:1214:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqdesc, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_FormatSeqAccession':
>esl_msa.c:1437:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqacc, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_FormatSeqDescription':
>esl_msa.c:1478:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqdesc, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_AddGS':
>esl_msa.c:1621:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->gs[0],  sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:1644:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(msa->gs[tagidx], sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_AppendGR':
>esl_msa.c:1795:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->gr[0],  sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:1815:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(msa->gr[msa->ngr], sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'msa_set_seq_ss':
>esl_msa.c:1892:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->ss, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'msa_set_seq_sa':
>esl_msa.c:1919:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->sa, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'msa_set_seq_pp':
>esl_msa.c:1946:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->pp, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_ReasonableRF':
>esl_msa.c:2032:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(counts, msa->abc->K * sizeof(float));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_MinimGaps':
>esl_msa.c:2419:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is just to deal w/ alen=0 special case */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_MinimGapsText':
>esl_msa.c:2496:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is just to deal w/ alen=0 special case */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_NoGaps':
>esl_msa.c:2566:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is only to deal with alen=0 special case */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_NoGapsText':
>esl_msa.c:2629:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is only to deal with alen=0 special case */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c: In function 'esl_msa_RemoveBrokenBasepairsFromSS':
>esl_msa.c:2806:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct,          sizeof(int)  * (len+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msa.c:2807:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss_nopseudo, sizeof(char) * (len+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_msafile2.o
>At top level:
>esl_msa.c:2879:1: warning: 'msa_get_rlen' defined but not used [-Wunused-function]
> msa_get_rlen(const ESL_MSA *msa, int seqidx)
> ^~~~~~~~~~~~
>In file included from esl_alphabet.h:7:0,
>                 from esl_msa.h:8,
>                 from esl_msafile2.c:26:
>esl_msafile2.c: In function 'msafile2_open':
>esl_msafile2.c:220:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cmd, sizeof(char) * (n+1+strlen("gzip -dc ")));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c: In function 'esl_msafile2_ReadInfoPfam':
>esl_msafile2.c:422:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(spos_ct, sizeof(int) * known_alen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:423:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(epos_ct, sizeof(int) * known_alen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:431:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ct,  sizeof(int)  * (known_alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:432:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ss_nopseudo, sizeof(char) * (known_alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:435:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(bp_ct,  sizeof(double **) * known_alen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:439:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(bp_ct[apos], sizeof(double *) * (abc->Kp));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:441:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(bp_ct[apos][x], sizeof(double) * (abc->Kp));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:531:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(pp_ct, sizeof(double *) * alen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:533:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>         ESL_ALLOC(pp_ct[apos], sizeof(double) * nppvals);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:537:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>         ESL_ALLOC(tmp_dsq, (alen+2) * sizeof(ESL_DSQ));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:540:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>         ESL_ALLOC(abc_ct, sizeof(double *) * alen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:542:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(abc_ct[apos], sizeof(double) * (abc->K+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:579:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp_dsq, (alen+2) * sizeof(ESL_DSQ));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:582:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(abc_ct, sizeof(double *) * alen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:584:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(abc_ct[apos], sizeof(double) * (abc->K+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:589:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pp_ct, sizeof(double *) * alen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:591:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(pp_ct[apos], sizeof(double) * nppvals);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_msafile_a2m.o
>esl_msafile2.c: In function 'gapize_string':
>esl_msafile2.c:1116:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dst_str, sizeof(char) * (dst_len+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c:1110:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_msafile_a2m.c:19:0:
>esl_msafile_a2m.c: In function 'esl_msafile_a2m_Read':
>esl_msafile_a2m.c:245:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(csflag, sizeof(char *) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_a2m.c:316:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(nins, sizeof(int) * (ncons+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_a2m.c: In function 'esl_msafile_a2m_Write':
>esl_msafile_a2m.c:413:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_a2m.c: In function 'a2m_padding_digital':
>esl_msafile_a2m.c:524:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->rf, sizeof(char) * (alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_a2m.c:534:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ax, sizeof(ESL_DSQ) * (alen + 2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_a2m.c: In function 'a2m_padding_text':
>esl_msafile_a2m.c:577:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->rf, sizeof(char) * (alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_a2m.c:587:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(aseq, sizeof(char) * (alen + 1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile2.c: In function 'msafile2_open':
>esl_msafile2.c:272:10: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   return status;
>          ^~~~~~
>     CC esl_msafile_afa.o
>     CC esl_msafile_clustal.o
>esl_msafile_clustal.c: In function 'esl_msafile_clustal_Read':
>esl_msafile_clustal.c:237:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = 0;     pos < n; pos++) if (! isspace(p[pos])) break;  name_start = pos;
>       ^~~
>esl_msafile_clustal.c:237:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = 0;     pos < n; pos++) if (! isspace(p[pos])) break;  name_start = pos;
>                                                                        ^~~~~~~~~~
>esl_msafile_clustal.c:238:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < n; pos++) if (  isspace(p[pos])) break;  name_len   = pos - name_start;
>       ^~~
>esl_msafile_clustal.c:238:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < n; pos++) if (  isspace(p[pos])) break;  name_len   = pos - name_start;
>                                                                        ^~~~~~~~
>esl_msafile_clustal.c:239:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < n; pos++) if (! isspace(p[pos])) break;  seq_start  = pos;
>       ^~~
>esl_msafile_clustal.c:239:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < n; pos++) if (! isspace(p[pos])) break;  seq_start  = pos;
>                                                                        ^~~~~~~~~
>esl_msafile_clustal.c:241:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = n-1; pos > 0; pos--)   if (! isspace(p[pos])) break;  seq_len    = pos - seq_start + 1;
>       ^~~
>esl_msafile_clustal.c:241:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = n-1; pos > 0; pos--)   if (! isspace(p[pos])) break;  seq_len    = pos - seq_start + 1;
>                                                                        ^~~~~~~
>In file included from esl_msafile_clustal.c:21:0:
>esl_msafile_clustal.c: In function 'esl_msafile_clustal_Write':
>esl_msafile_clustal.c:351:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_clustal.c: In function 'make_text_consensus_line':
>esl_msafile_clustal.c:471:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(consline, sizeof(char)     * (msa->alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_clustal.c:472:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(v,        sizeof(uint32_t) * (msa->alen));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_clustal.c: In function 'make_digital_consensus_line':
>esl_msafile_clustal.c:537:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(v,        sizeof(uint32_t) * (msa->alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_clustal.c:538:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(consline, sizeof(char)     * (msa->alen+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_clustal.c:532:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>     CC esl_msafile_phylip.o
>In file included from esl_msafile_phylip.c:23:0:
>esl_msafile_phylip.c: In function 'phylip_interleaved_Read':
>esl_msafile_phylip.c:415:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(namebuf, sizeof(char) * (namewidth+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_phylip.c: In function 'phylip_interleaved_Write':
>esl_msafile_phylip.c:492:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (rpl+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_phylip.c: In function 'phylip_sequential_Read':
>esl_msafile_phylip.c:549:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(namebuf, sizeof(char) * (namewidth+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_phylip.c: In function 'phylip_sequential_Write':
>esl_msafile_phylip.c:612:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (rpl+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_clustal.c: In function 'esl_msafile_clustal_Read':
>esl_msafile_clustal.c:248:5: warning: 'block_seq_len' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if (seq_len   != block_seq_len)   ESL_XFAIL(eslEFORMAT, afp->errmsg, "sequence end is misaligned");
>     ^
>In file included from esl_msafile_clustal.c:21:0:
>In function 'make_text_consensus_line',
>    inlined from 'esl_msafile_clustal_Write' at esl_msafile_clustal.c:364:18:
>easel.h:146:8: warning: argument 1 value '18446744073709551612' exceeds maximum object size 9223372036854775807 [-Walloc-size-larger-than=]
>     if (((p) = malloc(size)) == NULL && (size)) { \
>        ^
>esl_msafile_clustal.c:472:3: note: in expansion of macro 'ESL_ALLOC'
>   ESL_ALLOC(v,        sizeof(uint32_t) * (msa->alen));
>   ^~~~~~~~~
>In file included from esl_msafile_clustal.c:17:0:
>esl_msafile_clustal.c: In function 'esl_msafile_clustal_Write':
>/usr/include/stdlib.h:443:14: note: in a call to allocation function 'malloc' declared here
> extern void *malloc (size_t __size) __THROW __attribute_malloc__ __wur;
>              ^~~~~~
>esl_msafile_phylip.c: In function 'esl_msafile_phylip_Read':
>esl_msafile_phylip.c:589:6: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (status == eslOK) eslx_msafile_PutLine(afp);
>      ^
>esl_msafile_phylip.c:547:13: note: 'status' was declared here
>   int       status;
>             ^~~~~~
>esl_msa.c: In function 'esl_msa_ReasonableRF':
>esl_msa.c:2041:9: warning: 'counts' may be used uninitialized in this function [-Wmaybe-uninitialized]
>         esl_vec_FSet(counts, msa->abc->K, 0.0);
>         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>     CC esl_msafile_psiblast.o
>esl_msafile_psiblast.c: In function 'esl_msafile_psiblast_Read':
>esl_msafile_psiblast.c:219:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = 0;     pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  name_start = pos;
>       ^~~
>esl_msafile_psiblast.c:219:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = 0;     pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  name_start = pos;
>                                                                                     ^~~~~~~~~~
>esl_msafile_psiblast.c:220:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < afp->n; pos++) if (  isspace(afp->line[pos])) break;  name_len   = pos - name_start;
>       ^~~
>esl_msafile_psiblast.c:220:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < afp->n; pos++) if (  isspace(afp->line[pos])) break;  name_len   = pos - name_start;
>                                                                                     ^~~~~~~~
>esl_msafile_psiblast.c:221:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  seq_start  = pos;
>       ^~~
>esl_msafile_psiblast.c:221:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  seq_start  = pos;
>                                                                                     ^~~~~~~~~
>esl_msafile_psiblast.c:223:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = afp->n-1; pos > 0; pos--)   if (! isspace(afp->line[pos])) break;  seq_len    = pos - seq_start + 1;
>       ^~~
>esl_msafile_psiblast.c:223:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = afp->n-1; pos > 0; pos--)   if (! isspace(afp->line[pos])) break;  seq_len    = pos - seq_start + 1;
>                                                                                     ^~~~~~~
>In file included from esl_msafile_psiblast.c:16:0:
>esl_msafile_psiblast.c: In function 'esl_msafile_psiblast_Write':
>esl_msafile_psiblast.c:341:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_phylip.c: In function 'esl_msafile_phylip_CheckFileFormat':
>esl_msafile_phylip.c:872:20: warning: 'nw_max' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (nw_min <= 10 && nw_max >= 10) *ret_namewidth = 10;
>       ~~~~~~~~~~~~~^~~~~~~~~~~~~~~
>esl_msafile_phylip.c:812:31: note: 'nw_max' was declared here
>   int       nwA, nwB, nw_min, nw_max;
>                               ^~~~~~
>esl_msafile_phylip.c:873:52: warning: 'nw_min' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   else                              *ret_namewidth = nw_min;
>                                     ~~~~~~~~~~~~~~~^~~~~~~~
>esl_msafile_phylip.c:812:23: note: 'nw_min' was declared here
>   int       nwA, nwB, nw_min, nw_max;
>                       ^~~~~~
>esl_msafile_phylip.c:853:18: warning: 'n0' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       for (c = n0-1; nres1 && c >= 0; c--)
>                ~~^~
>esl_msafile_phylip.c:808:17: note: 'n0' was declared here
>   esl_pos_t n,  n0;
>                 ^~
>esl_msafile_phylip.c:860:8: warning: 'p0' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if (p0[c] != ' ') break;
>        ^
>esl_msafile_phylip.c:807:17: note: 'p0' was declared here
>   char     *p, *p0;
>                 ^~
>     CC esl_msafile_selex.o
>In file included from esl_msafile_selex.c:35:0:
>esl_msafile_selex.c: In function 'esl_msafile_selex_Write':
>esl_msafile_selex.c:304:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c: In function 'selex_block_Create':
>esl_msafile_selex.c:364:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->line,    sizeof(char *)    * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:365:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->llen,    sizeof(esl_pos_t) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:366:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->offsets, sizeof(esl_pos_t) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:367:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->linenum, sizeof(int64_t)   * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:368:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->ltype,   sizeof(int)       * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:369:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->lpos,    sizeof(esl_pos_t) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:370:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->rpos,    sizeof(esl_pos_t) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:351:20: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int              status;
>                    ^~~~~~
>In file included from esl_msafile_selex.c:35:0:
>esl_msafile_selex.c: In function 'selex_first_block':
>esl_msafile_selex.c:577:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->ss, sizeof(char *) * nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c:581:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sa, sizeof(char *) * nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_selex.c: In function 'selex_append_block':
>esl_msafile_selex.c:657:27: warning: variable 'nright' set but not used [-Wunused-but-set-variable]
>   esl_pos_t nleft, ntext, nright;
>                           ^~~~~~
>     CC esl_msafile_stockholm.o
>esl_msafile_selex.c: In function 'esl_msafile_selex_Read':
>esl_msafile_selex.c:250:26: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       if      (! nblocks &&  (status = selex_first_block(afp, b, &msa)) != eslOK) goto ERROR;
>     CC esl_msashuffle.o
>In file included from esl_msafile_stockholm.c:20:0:
>esl_msafile_stockholm.c: In function 'stockholm_parsedata_Create':
>esl_msafile_stockholm.c:422:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pd->sqlen,     sizeof(int64_t) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c:387:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_msafile_stockholm.c:20:0:
>esl_msafile_stockholm.c: In function 'stockholm_parse_gr':
>esl_msafile_stockholm.c:806:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->ss,   sizeof(char *)  * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c:807:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pd->sslen, sizeof(int64_t) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c:817:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->pp,   sizeof(char *)  * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c:818:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pd->pplen, sizeof(int64_t) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c:828:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->sa,   sizeof(char *)  * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c:829:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pd->salen, sizeof(int64_t) * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c: In function 'stockholm_get_gr_tagidx':
>esl_msafile_stockholm.c:1031:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->gr[tagidx],     sizeof(char *)    * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c:1032:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pd->ogr_len[tagidx], sizeof(int64_t)   * msa->sqalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msafile_stockholm.c: In function 'stockholm_write':
>esl_msafile_stockholm.c:1167:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_msaweight.o
>In file included from esl_msashuffle.c:12:0:
>esl_msashuffle.c: In function 'esl_msashuffle_XQRNA':
>esl_msashuffle.c:289:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xycol, sizeof(int) * L);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msashuffle.c:290:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xcol,  sizeof(int) * L);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msashuffle.c:291:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ycol,  sizeof(int) * L);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msashuffle.c: In function 'esl_msashuffle_CQRNA':
>esl_msashuffle.c:387:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xycol, sizeof(int) * L);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msashuffle.c:388:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xcol,  sizeof(int) * L);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msashuffle.c:389:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ycol,  sizeof(int) * L);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from esl_msaweight.c:26:0:
>esl_msaweight.c: In function 'esl_msaweight_GSC':
>esl_msaweight.c:139:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(x, sizeof(double) * (T->N-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msaweight.c: In function 'esl_msaweight_PB':
>esl_msaweight.c:276:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     { ESL_ALLOC(nres, sizeof(int) * msa->abc->K); K = msa->abc->K; }
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msaweight.c: In function 'esl_msaweight_BLOSUM':
>esl_msaweight.c:413:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nmem, sizeof(int) * nc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msaweight.c: In function 'esl_msaweight_IDFilter':
>esl_msaweight.c:476:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(list,  sizeof(int) * msa->nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msaweight.c:477:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_msaweight.c: In function 'esl_msaweight_PB':
>esl_msaweight.c:307:5: warning: 'ntotal' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if (ntotal > 0) msa->wgt[idx] /= (double) rlen;
>     ^
>     CC esl_normal.o
>     CC esl_paml.o
>     CC esl_random.o
>     CC esl_randomseq.o
>     CC esl_ratematrix.o
>esl_random.c: In function 'esl_randomness_Create':
>esl_random.c:87:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;
>                   ^~~~~~
>esl_random.c: In function 'esl_randomness_CreateFast':
>esl_random.c:151:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;
>                   ^~~~~~
>In file included from esl_randomseq.c:25:0:
>esl_randomseq.c: In function 'esl_rsq_Sample':
>esl_randomseq.c:110:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (L+1)); /* +\0 */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c: In function 'esl_rsq_CShuffleDP':
>esl_randomseq.c:283:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(E[x], sizeof(char) * (len-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c: In function 'esl_rsq_CShuffleKmers':
>esl_randomseq.c:475:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(swap, sizeof(char) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c: In function 'esl_rsq_XShuffleDP':
>esl_randomseq.c:864:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nE, sizeof(int)       * K);  for (x = 0; x < K; x++) nE[x] = 0;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c:865:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(E,  sizeof(ESL_DSQ *) * K);  for (x = 0; x < K; x++) E[x]  = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c:866:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(iE, sizeof(int)       * K);  for (x = 0; x < K; x++) iE[x] = 0;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c:867:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(Z,  sizeof(ESL_DSQ)   * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c:869:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(E[x], sizeof(ESL_DSQ) * (L-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c: In function 'esl_rsq_XShuffleKmers':
>esl_randomseq.c:979:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(swap, sizeof(char) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c: In function 'esl_rsq_XMarkov0':
>esl_randomseq.c:1114:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p, sizeof(double) * K);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c: In function 'esl_rsq_XMarkov1':
>esl_randomseq.c:1195:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p0, sizeof(double)   * K);  for (x = 0; x < K; x++) p0[x] = 0.;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c:1196:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,  sizeof(double *) * K);  for (x = 0; x < K; x++) p[x]  = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_randomseq.c:1198:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     { ESL_ALLOC(p[x], sizeof(double) * K); for (y = 0; y < K; y++) p[x][y] = 0.; }
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_recorder.o
>In file included from esl_recorder.c:18:0:
>esl_recorder.c: In function 'esl_recorder_Create':
>esl_recorder.c:58:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rc->line,   sizeof(char *) * rc->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_recorder.c:61:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rc->lalloc, sizeof(int)    * rc->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_recorder.c:64:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rc->offset, sizeof(off_t)  * rc->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_recorder.c:45:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>     CC esl_regexp.o
>esl_regexp.c: In function 'esl_regexp_Create':
>esl_regexp.c:91:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_regexp.c:59:0:
>esl_regexp.c: In function 'esl_regexp_SubmatchDup':
>esl_regexp.c:237:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (len+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_regexp.c:229:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>esl_regexp.c: In function 'regcomp':
>esl_regexp.c:579:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>         int status;
>             ^~~~~~
>esl_regexp.c: In function 'reg':
>esl_regexp.c:667:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>esl_regexp.c: In function 'regpiece':
>esl_regexp.c:779:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>         int status;
>             ^~~~~~
>esl_regexp.c: In function 'regatom':
>esl_regexp.c:855:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>esl_msafile_stockholm.c: In function 'esl_msafile_stockholm_Read':
>esl_msafile_stockholm.c:306:47: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    else if (esl_memstrpfx(p, n, "#=GS")) { if ((status = stockholm_parse_gs     (afp, pd, msa, p, n)) != eslOK) goto ERROR; }
>                                               ^
>esl_regexp.c: In function 'regescape':
>esl_regexp.c:1612:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>esl_randomseq.c: In function 'esl_rsq_XShuffleDP':
>esl_randomseq.c:949:19: warning: 'Z' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (Z  != NULL) free(Z);
>                   ^~~~~~~
>     CC esl_rootfinder.o
>esl_rootfinder.c: In function 'esl_rootfinder_Create':
>esl_rootfinder.c:51:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>esl_rootfinder.c: In function 'esl_rootfinder_CreateFDF':
>esl_rootfinder.c:105:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>esl_randomseq.c: In function 'esl_rsq_XMarkov1':
>esl_randomseq.c:1235:3: warning: 'p' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   esl_Free2D((void**)p, K);
>   ^~~~~~~~~~~~~~~~~~~~~~~~
>esl_randomseq.c:1236:19: warning: 'p0' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (p0 != NULL) free(p0);
>                   ^~~~~~~~
>     CC esl_scorematrix.o
>     CC esl_sq.o
>In file included from esl_scorematrix.c:23:0:
>esl_scorematrix.c: In function 'esl_scorematrix_Create':
>esl_scorematrix.c:68:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->s, sizeof(int *) * abc->Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_scorematrix.c:70:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->isval, sizeof(char) * abc->Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_scorematrix.c:72:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->outorder, sizeof(char) * (abc->Kp+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_scorematrix.c:75:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->s[0], sizeof(int) * abc->Kp * abc->Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_scorematrix.c:54:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_scorematrix.c:23:0:
>esl_scorematrix.c: In function 'esl_scorematrix_Read':
>esl_scorematrix.c:1060:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(map, sizeof(int) * S->nc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from esl_sq.c:21:0:
>esl_sq.c: In function 'esl_sq_Copy':
>esl_sq.c:274:76: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (src->ss != NULL && dst->ss  == NULL) ESL_ALLOC(dst->ss, sizeof(char) * dst->salloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:288:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(dst->xr_tag, sizeof(char *) * dst->nxr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:289:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(dst->xr,     sizeof(char *) * dst->nxr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:292:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(dst->xr_tag[x], sizeof(char) * src->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:293:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(dst->xr[x],     sizeof(char) * src->salloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c: In function 'esl_sq_CreateDigitalFrom':
>esl_sq.c:715:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->ss, sizeof(char) * (sq->n+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c: In function 'esl_sq_Digitize':
>esl_sq.c:790:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->dsq, (sq->salloc) * sizeof(ESL_DSQ));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c: In function 'esl_sq_Textize':
>esl_sq.c:845:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->seq, sq->salloc * sizeof(char));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_scorematrix.c: In function 'esl_scorematrix_Probify':
>esl_scorematrix.c:1669:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fi, sizeof(double) * S->Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_scorematrix.c:1670:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fj, sizeof(double) * S->Kp);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c: In function 'esl_sq_GetFromMSA':
>esl_sq.c:1712:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xr_tag, sizeof(char *) * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1713:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xr,     sizeof(char *) * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1725:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(sq->xr_tag, sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr_tag[x] = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1726:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(sq->xr,     sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr[x]     = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1756:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(sq->ss, sizeof(char) * (strlen(ss)+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1764:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr[x], sizeof(char) * (strlen(xr[x])+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1793:7: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>       if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>       ^~
>esl_sq.c:1793:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>       if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>                                         ^~
>In file included from esl_sq.c:21:0:
>esl_sq.c: In function 'esl_sq_FetchFromMSA':
>esl_sq.c:1845:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(xr_tag, sizeof(char *) * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1846:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(xr,     sizeof(char *) * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1865:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr_tag, sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr_tag[x] = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1866:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr,     sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr[x] = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1888:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr_tag, sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr_tag[x] = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1889:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr,     sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr[x] = NULL;
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1893:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>        ESL_ALLOC(sq->xr[x], sizeof(char) * (sq->n+2));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1897:6: warning: this 'else' clause does not guard... [-Wmisleading-indentation]
>      else strcpy(sq->xr[x]+1, xr[x]); sq->xr[x][0] = '\0';
>      ^~~~
>esl_sq.c:1897:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'else'
>      else strcpy(sq->xr[x]+1, xr[x]); sq->xr[x][0] = '\0';
>                                       ^~
>esl_sq.c:1926:5: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>     if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>     ^~
>esl_sq.c:1926:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>     if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>                                       ^~
>esl_sq.c: In function 'sq_create':
>esl_sq.c:1950:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_sq.c:21:0:
>esl_sq.c: In function 'sq_createblock':
>esl_sq.c:1979:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(block->list, sizeof(ESL_SQ) * count);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1970:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status = eslOK;
>       ^~~~~~
>In file included from esl_sq.c:21:0:
>esl_sq.c: In function 'sq_init':
>esl_sq.c:2015:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->name,   sizeof(char) * sq->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2016:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->acc,    sizeof(char) * sq->aalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2017:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->desc,   sizeof(char) * sq->dalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2018:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->source, sizeof(char) * sq->srcalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2019:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (do_digital) ESL_ALLOC(sq->dsq,  sizeof(ESL_DSQ) * sq->salloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2020:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   else            ESL_ALLOC(sq->seq,  sizeof(char)    * sq->salloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:1998:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_sq.c:21:0:
>esl_sq.c: In function 'sq_create_from':
>esl_sq.c:2055:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->name, sizeof(char) * n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2062:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->name, sizeof(char) * sq->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2069:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->desc, sizeof(char) * n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2076:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->desc, sizeof(char) * sq->dalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2083:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->acc, sizeof(char) * n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2090:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->acc,  sizeof(char) * sq->aalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2096:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->source, sizeof(char) * sq->srcalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sq.c:2042:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>     CC esl_sqio.o
>In file included from esl_sqio.c:34:0:
>esl_sqio.c: In function 'sqfile_open':
>esl_sqio.c:213:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sqfp->filename, sizeof(char) * (strlen(filename) + 1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio.c:237:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(list, sizeof(char) * (strlen(s1) + 1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio.c:240:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(path, sizeof(char) * (strlen(filename) + strlen(list) + 3));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio.c: In function 'esl_sqfile_Cache':
>esl_sqio.c:483:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cache->sq_list, sizeof(ESL_SQ) * (count + 1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio.c: In function 'convert_sq_to_msa':
>esl_sqio.c:1450:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->gr,     sizeof(char **) * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio.c:1451:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->gr_tag, sizeof(char  *) * msa->ngr);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_sqio_ascii.o
>In file included from esl_sqio_ascii.c:31:0:
>esl_sqio_ascii.c: In function 'esl_sqascii_Open':
>esl_sqio_ascii.c:229:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>         ESL_ALLOC(cmd, sizeof(char) * (n+1+strlen("gzip -dc ")));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio_ascii.c: In function 'sqascii_ReadWindow':
>esl_sqio_ascii.c:1218:77: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     if (tmpsq->ss != NULL && sq->ss == NULL) ESL_ALLOC(sq->ss, sizeof(char) * (sq->salloc)); /* this *must* be for salloc  */
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_scorematrix.c: In function 'esl_scorematrix_SetWAG':
>esl_scorematrix.c:947:7: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int status;
>       ^~~~~~
>     CC esl_sqio_ncbi.o
>In file included from esl_sqio_ncbi.c:26:0:
>esl_sqio_ncbi.c: In function 'sqncbi_ParseIndexFile':
>esl_sqio_ncbi.c:228:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ncbi->title, sizeof(char) * (len + 1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio_ncbi.c:235:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ncbi->timestamp, sizeof(char) * (len + 1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio_ncbi.c: In function 'sqncbi_DbOpen':
>esl_sqio_ncbi.c:270:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(name, sizeof(char) * (len+5));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio_ncbi.c: In function 'sqncbi_AliasOpen':
>esl_sqio_ncbi.c:339:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(name, sizeof(char) * (len+5));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio_ncbi.c:352:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dbname, sizeof(char) * dbsize);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_sqio_ncbi.c: In function 'read_dna':
>esl_sqio_ncbi.c:1648:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>esl_sqio_ascii.c: In function 'loadmem':
>esl_sqio_ascii.c:2074:27: warning: 'n' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   return (n == 0 ? eslEOF : eslOK);
>          ~~~~~~~~~~~~~~~~~^~~~~~~~
>esl_sqio_ncbi.c: In function 'read_nres_dna':
>esl_sqio_ncbi.c:1965:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>     CC esl_sse.o
>     CC esl_ssi.o
>esl_sq.c: In function 'esl_sq_GetFromMSA':
>esl_sq.c:1698:11: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int     status;
>           ^~~~~~
>In file included from esl_ssi.c:15:0:
>esl_ssi.c: In function 'esl_ssi_Open':
>esl_ssi.c:111:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->filename,   sizeof(char *) * ssi->nfiles);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c:113:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->fileformat, sizeof(uint32_t) * ssi->nfiles);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c:114:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->fileflags,  sizeof(uint32_t) * ssi->nfiles);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c:115:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->bpl,        sizeof(uint32_t) * ssi->nfiles);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c:116:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->rpl,        sizeof(uint32_t) * ssi->nfiles);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c:121:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ssi->filename[i], sizeof(char)* ssi->flen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c: In function 'esl_ssi_FindName':
>esl_ssi.c:197:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pkey, sizeof(char) * ssi->plen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c: In function 'esl_ssi_FindNumber':
>esl_ssi.c:261:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pkey, sizeof(char) * ssi->plen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c: In function 'binary_search':
>esl_ssi.c:567:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(name, (sizeof(char)*klen));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c: In function 'esl_newssi_Write':
>esl_ssi.c:999:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fk, sizeof(char) * ns->flen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c:1000:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pk, sizeof(char) * ns->plen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_ssi.c:1001:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (ns->slen) ESL_ALLOC(sk, sizeof(char) * ns->slen);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_stack.o
>In file included from esl_stack.c:26:0:
>esl_stack.c: In function 'esl_stack_ICreate':
>esl_stack.c:59:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ns->idata, sizeof(int) * ns->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_stack.c:53:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_stack.c:26:0:
>esl_stack.c: In function 'esl_stack_CCreate':
>esl_stack.c:95:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cs->cdata, sizeof(char) * cs->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_stack.c:89:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_stack.c:26:0:
>esl_stack.c: In function 'esl_stack_PCreate':
>esl_stack.c:131:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ps->pdata, sizeof(void *) * ps->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_stack.c:125:14: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int        status;
>              ^~~~~~
>esl_stack.c: In function 'esl_stack_Convert2String':
>esl_stack.c:477:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>esl_stack.c: In function 'esl_stack_DiscardSelected':
>esl_stack.c:583:8: warning: 'npos' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   s->n = npos;
>   ~~~~~^~~~~~
>     CC esl_stats.o
>In file included from esl_stats.c:20:0:
>esl_stats.c: In function 'esl_stats_LinearRegression':
>esl_stats.c:528:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(t, sizeof(double) * n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_stopwatch.o
>esl_stopwatch.c: In function 'esl_stopwatch_Create':
>esl_stopwatch.c:27:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     CC esl_stretchexp.o
>     CC esl_threads.o
>esl_stretchexp.c: In function 'esl_sxp_invcdf':
>esl_stretchexp.c:166:10: warning: variable 'f1' set but not used [-Wunused-but-set-variable]
>   double f1, f2, fm;
>          ^~
>esl_stretchexp.c: In function 'esl_sxp_FitComplete':
>esl_stretchexp.c:353:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>esl_stretchexp.c: In function 'esl_sxp_FitCompleteBinned':
>esl_stretchexp.c:441:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>     CC esl_translate.o
>esl_threads.c: In function 'esl_threads_Create':
>esl_threads.c:57:16: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int          status;
>                ^~~~~~
>In file included from esl_translate.c:17:0:
>esl_translate.c: In function 'esl_trans_orf':
>esl_translate.c:160:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(*out, totalStops * sizeof(ESL_SQ*));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_translate.c: In function 'esl_trans_s2p':
>esl_translate.c:278:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(aaseq, (in->n+1) * sizeof(char));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_translate.c:239:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl_translate.c:17:0:
>esl_translate.c: In function 'esl_trans_seq_stop_split':
>esl_translate.c:378:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buff, (in->n+1) * sizeof(char));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_translate.c:393:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(*out, sizeof(ESL_SQ*) * *outCount);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_translate.c:432:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(*out, sizeof(ESL_SQ*) * *outCount);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_translate.c:369:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>esl_sqio_ncbi.c: In function 'sqncbi_ReadBlock':
>esl_sqio_ncbi.c:1307:6: warning: 'tmpsq' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    if(tmpsq != NULL) esl_sq_Destroy(tmpsq);
>      ^
>esl_translate.c: In function 'esl_trans_s2p':
>esl_translate.c:338:21: warning: 'aaseq' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if(aaseq != NULL) free(aaseq);
>                     ^~~~~~~~~~~
>     CC esl_tree.o
>     CC esl_vectorops.o
>In file included from esl_tree.c:21:0:
>esl_tree.c: In function 'esl_tree_Create':
>esl_tree.c:64:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->parent, sizeof(int)    * (ntaxa-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:65:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->left,   sizeof(int)    * (ntaxa-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:66:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->right,  sizeof(int)    * (ntaxa-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:67:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->ld,     sizeof(double) * (ntaxa-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:68:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->rd,     sizeof(double) * (ntaxa-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:49:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>esl_tree.c: In function 'esl_tree_Grow':
>esl_tree.c:179:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>In file included from esl_tree.c:21:0:
>esl_tree.c: In function 'esl_tree_SetTaxaParents':
>esl_tree.c:263:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->taxaparent, sizeof(int) * T->N);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'esl_tree_SetCladesizes':
>esl_tree.c:298:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->cladesize, sizeof(int) * (T->N-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'esl_tree_SetTaxonlabels':
>esl_tree.c:344:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->taxonlabel, sizeof(char **) * T->nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'esl_tree_RenumberNodes':
>esl_tree.c:395:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(map, sizeof(int) * (T->N-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:413:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(T2->nodelabel,  sizeof(char *) * (T2->nalloc-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:417:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(T2->taxaparent, sizeof(int)    * (T2->nalloc));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'esl_tree_VerifyUltrametric':
>esl_tree.c:482:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(d, sizeof(double) * T->N);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'newick_parse_quoted_label':
>esl_tree.c:1005:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(label, sizeof(char) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'newick_parse_unquoted_label':
>esl_tree.c:1062:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(label, sizeof(char) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'newick_parse_branchlength':
>esl_tree.c:1106:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(branch, sizeof(char) * nalloc);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'esl_tree_Compare':
>esl_tree.c:1482:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(Mg,  sizeof(int) * (T1->N-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:1483:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(Mgt, sizeof(int) * (T1->N));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'cluster_engine':
>esl_tree.c:1608:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(idx,    sizeof(int)    *  D->n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:1609:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nin,    sizeof(int)    *  D->n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:1610:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(height, sizeof(double) * (D->n-1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c: In function 'esl_tree_Simulate':
>esl_tree.c:1849:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(branchpapa, sizeof(int) * N);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_tree.c:1850:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(branchside, sizeof(int) * N);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from esl_vectorops.c:20:0:
>esl_vectorops.c: In function 'esl_vec_DLogValidate':
>esl_vectorops.c:1216:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(expvec, sizeof(double)*n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_vectorops.c: In function 'esl_vec_FLogValidate':
>esl_vectorops.c:1236:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(expvec, sizeof(float)*n);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl_vmx.o
>     CC esl_weibull.o
>     CC esl_workqueue.o
>esl_tree.c: In function 'newick_parse_branchlength':
>esl_tree.c:1103:9: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int   status;
>         ^~~~~~
>In file included from esl_workqueue.c:18:0:
>esl_workqueue.c: In function 'esl_workqueue_Create':
>esl_workqueue.c:63:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(queue->readerQueue, sizeof(void *) * size);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_workqueue.c:64:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(queue->workerQueue, sizeof(void *) * size);
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_workqueue.c:42:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;
>                   ^~~~~~
>     CC esl_wuss.o
>In file included from esl_wuss.c:8:0:
>esl_wuss.c: In function 'esl_ct2wuss':
>esl_wuss.c:169:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cct, sizeof(int)*(n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_wuss.c: In function 'esl_ct2simplewuss':
>esl_wuss.c:393:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cct, sizeof(int)*(n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_wuss.c: In function 'esl_wuss_full':
>esl_wuss.c:632:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct,  sizeof(int)  * (n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_wuss.c:633:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp, sizeof(char) * (n+1));
>easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl_wuss.c: In function 'esl_wuss2ct':
>esl_wuss.c:119:10: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   return status;
>          ^~~~~~
>     AR libeasel.a
>     SUBDIR miniapps
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/easel/miniapps'
>     CC esl-afetch.o
>     CC esl-alimanip.o
>     CC esl-alimap.o
>     CC esl-alimask.o
>In file included from esl-alimap.c:15:0:
>esl-alimap.c: In function 'map_msas':
>esl-alimap.c:236:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(seq1, sizeof(char) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:237:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(seq2, sizeof(char) * (alen2+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:238:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(one2two, sizeof(int *) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:240:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(one2two[apos1], sizeof(int) * (alen2+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:285:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mx, sizeof(int *) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:286:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tb, sizeof(int *) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:288:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(mx[apos1], sizeof(int) * (alen2+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:289:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(tb[apos1], sizeof(int) * (alen2+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:297:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(res1_per_apos, sizeof(int) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:363:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(one2two_map, sizeof(int) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c: In function 'map_sub_msas':
>esl-alimap.c:477:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mask, sizeof(char) * (msa1->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:481:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa1_to_msa2_map, sizeof(int) * (msa1->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c: In function 'map_rfpos_to_apos':
>esl-alimap.c:539:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rf2a_map, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:540:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a2rf_map, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c: In function 'map2masks':
>esl-alimap.c:593:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(mask, sizeof(char) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from esl-alimanip.c:12:0:
>esl-alimanip.c: In function 'write_rf_given_alen':
>esl-alimap.c:614:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(mask, sizeof(char) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:640:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(mask, sizeof(char) * (rflen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c:664:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(mask, sizeof(char) * (alen1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:763:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->rf, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'individualize_consensus':
>esl-alimanip.c:839:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cct, sizeof(int)  * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:840:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct,  sizeof(int)  * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:841:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss,  sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:842:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss_cons_nopseudo, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'map_rfpos_to_apos':
>esl-alimanip.c:909:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(i_am_rf, sizeof(int) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:910:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rf2a_map, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'read_sqfile':
>esl-alimanip.c:946:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq, sizeof(ESL_SQ *) * (nseq + 1)); /* +1 for the last guy we allocate but don't use */
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'trim_msa':
>esl-alimanip.c:999:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(aseq,  sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1006:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(a2ua_map, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1016:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ua2a_map, sizeof(int) * (ualen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1022:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(uasubseq, sizeof(char) * (sq[i]->n+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'get_tree_order':
>esl-alimanip.c:1273:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(order, sizeof(int) * T->N);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'reorder_msa':
>esl-alimanip.c:1306:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp, sizeof(char *) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1312:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(covered, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1326:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(tmp_dsq, sizeof(ESL_DSQ *) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'read_mask_file':
>esl-alimanip.c:1411:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mask, sizeof(char) * (toklen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'expand_msa2mask':
>esl-alimanip.c:1461:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nzeroesA, sizeof(int) * (masklen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'msa_median_length':
>esl-alimanip.c:1500:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(len, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1493:8: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int  status;
>        ^~~~~~
>In file included from esl-alimanip.c:12:0:
>esl-alimanip.c: In function 'msa_remove_seqs_below_minlen':
>esl-alimanip.c:1542:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'msa_remove_seqs_above_maxlen':
>esl-alimanip.c:1578:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'msa_remove_truncated_seqs':
>esl-alimanip.c:1619:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'msa_remove_seqs_with_ambiguities':
>esl-alimanip.c:1675:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'number_columns':
>esl-alimanip.c:1723:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tag, sizeof(char) * (tagwidth+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1724:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(numstring, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1761:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(numstring, sizeof(char) * (msa->alen + 1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1706:8: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int  status;
>        ^~~~~~
>In file included from esl-alimanip.c:12:0:
>esl-alimanip.c: In function 'read_seq_name_file':
>esl-alimanip.c:1852:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(seqlist, sizeof(char *) * nalloc);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'msa_keep_or_remove_seqs':
>esl-alimanip.c:1893:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme,     sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1894:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(order_all, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:1895:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(order_new, sizeof(int) * seqlist_n);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'MSADivide':
>esl-alimanip.c:2229:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(diff,  (sizeof(double) * (T->N - 1)));  /* one for each node */
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2230:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(minld, (sizeof(double) * (T->N - 1)));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2231:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(minrd, (sizeof(double) * (T->N - 1)));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2285:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(csize, (sizeof(int) * (nc)));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2292:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cmsa, (sizeof(ESL_MSA *) * (nc)));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2295:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, (sizeof(int *) * (nc+1)));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2297:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(useme[m], (sizeof(int)) * mmsa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'select_node':
>esl-alimanip.c:2393:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(clust, (sizeof(int) * T->N));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'determine_first_last_consensus_columns':
>esl-alimanip.c:2573:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fA, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2574:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(lA, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'find_seqs_with_given_insert':
>esl-alimanip.c:2723:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme,sizeof(int) * (msa->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2724:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ict,  sizeof(int *) * (msa->alen+2));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2727:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ict[i],  sizeof(int) * (msa->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'minorize_msa':
>esl-alimanip.c:2807:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(which_minor, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2808:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(minorA, sizeof(char *) * nalloc);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2837:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(minor_msaA, sizeof(ESL_MSA *) * nmin);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2838:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from esl-alimask.c:8:0:
>esl-alimask.c: In function 'main':
>esl-alimask.c:348:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(i_am_eligible, sizeof(int) * (int) msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2880:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(order, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c:401:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme_final, sizeof(int) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c:460:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(gap_ct, sizeof(double) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c: In function 'read_mask_file':
>esl-alimask.c:663:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     if(mlen == 0) ESL_ALLOC (useme, sizeof(int) * toklen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c: In function 'map_rfpos_to_apos':
>esl-alimask.c:716:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(i_am_rf, sizeof(int) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c:717:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rf2a_map, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'add_gap_columns_to_msa':
>esl-alimanip.c:2985:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(newmsa->ss_cons, sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c: In function 'count_gaps_in_msa':
>esl-alimask.c:790:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gap_ct, sizeof(double) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2990:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(newmsa->sa_cons, sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c: In function 'mask_based_on_gapfreq':
>esl-alimask.c:836:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:2995:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(newmsa->pp_cons, sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3000:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(newmsa->rf, sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3010:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(newmsa->ss, sizeof(char *) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3015:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(newmsa->ss[i], sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3023:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(newmsa->sa, sizeof(char *) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3028:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(newmsa->sa[i], sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c: In function 'count_postprobs_in_msa':
>esl-alimask.c:929:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pp_ct, sizeof(double *) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c:931:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(pp_ct[apos], sizeof(double) * nppvals);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3036:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(newmsa->pp, sizeof(char *) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3041:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(newmsa->pp[i], sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c: In function 'mask_based_on_postprobs':
>esl-alimask.c:1044:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3079:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>        ESL_ALLOC(newstr, sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimask.c: In function 'output_mask':
>esl-alimask.c:1138:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mask, sizeof(char) * (mlen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3095:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(newstr, sizeof(char) * (msa->alen+nnew+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c: In function 'convert_post_to_pp':
>esl-alimanip.c:3190:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->pp, sizeof(char *) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3192:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->pp[i], sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimanip.c:3161:8: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int  status;
>        ^~~~~~
>In file included from esl-alimanip.c:12:0:
>esl-alimanip.c: In function 'write_rf_gapthresh':
>esl-alimanip.c:3262:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->rf, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimap.c: In function 'main':
>esl-alimap.c:506:90: warning: ' (msa2->alen: ' directive output may be truncated writing 14 bytes into a region of size between 0 and 26 [-Wformat-truncation=]
>   if((apos1 != (msa1->alen+1)) || (apos2 != (msa2->alen+1))) ESL_FAIL(eslEINVAL, errbuf, "in map_sub_msas(), failure mapping alignments, end of loop apos1-1 = %d (msa1->alen: %" PRId64 ") and apos2-1 = %d (msa2->alen: %" PRId64 ")\n", apos1-1, msa1->alen, apos2-1, msa2->alen);
>                                                                                          ^
>../easel.h:57:57: note: in definition of macro 'ESL_FAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from esl-alimap.c:9:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output between 120 and 176 bytes into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>     CC esl-alimerge.o
>In file included from esl-alimerge.c:29:0:
>esl-alimerge.c: In function 'main':
>esl-alimerge.c:225:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(alifile_list, sizeof(char *) * nalifile);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:245:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(namedashes, sizeof(char) * (namewidth+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:257:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msaA,   sizeof(ESL_MSA *) * nalloc);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:258:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(alenA,  sizeof(int64_t) * nalloc);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:259:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if(do_rfonly) ESL_ALLOC(usemeA, sizeof(int *) * nalloc);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:277:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nali_per_file, sizeof(int) * nalifile);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:337:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(maxgap, sizeof(int) * (clen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:339:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(maxmis, sizeof(int) * (clen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:350:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(usemeA[ai], sizeof(int) * (msaA[ai]->alen));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c: In function 'read_list_file':
>esl-alimerge.c:604:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(alifile_list, sizeof(char *) * nalloc);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c: In function 'add_msa':
>esl-alimerge.c:1182:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(mmsa->sqacc, sizeof(char *) * (nseq_existing + msa_to_add->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1211:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(mmsa->sqdesc, sizeof(char *) * (nseq_existing + msa_to_add->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1240:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(mmsa->pp, sizeof(char *) * (nseq_existing + msa_to_add->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1269:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(mmsa->ss, sizeof(char *) * (nseq_existing + msa_to_add->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1298:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(mmsa->sa, sizeof(char *) * (nseq_existing + msa_to_add->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c: In function 'inflate_string_with_gaps_and_missing':
>esl-alimerge.c:1401:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dst_str, sizeof(char) * (dst_len+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1395:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl-alimerge.c:29:0:
>esl-alimerge.c: In function 'inflate_seq_with_gaps':
>esl-alimerge.c:1468:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dst_str, sizeof(char) * (dst_len+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1458:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl-alimerge.c:29:0:
>esl-alimerge.c: In function 'determine_gap_columns_to_add':
>esl-alimerge.c:1593:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ngapA,    sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1594:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nmisA,    sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alimerge.c:1595:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(neitherA, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl-alipid.o
>esl-alimerge.c: In function 'validate_and_copy_msa_annotation':
>esl-alimerge.c:1085:44: warning: ' de-gapped RF annotation differs from that of alignment 1.
>   ' directive output truncated writing 59 bytes into a region of size between 15 and 25 [-Wformat-truncation=]
>       ESL_XFAIL(eslEINCONCEIVABLE, errbuf, "All alignments must have identical #=GC RF annotation, once gaps (\".\",\"-\",\"_\") are removed.\nAlignment %d de-gapped RF annotation differs from that of alignment 1.\n%s\n%s", ai+1, dealigned, dealigned2);
>                                            ^
>../easel.h:63:57: note: in definition of macro 'ESL_XFAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from esl-alimerge.c:26:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output 164 or more bytes into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>     CC esl-alistat.o
>esl-alimerge.c:920:4: warning: 'found_tag' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if(found_tag && do_add) {
>    ^
>In file included from esl-alistat.c:8:0:
>esl-alistat.c: In function 'count_msa':
>esl-alistat.c:469:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(pp_ct, sizeof(double *) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:471:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(pp_ct[apos], sizeof(double) * nppvals);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:478:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(bp_ct,  sizeof(double **) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:480:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ct,  sizeof(int)  * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:481:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ss_nopseudo, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:487:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(bp_ct[apos], sizeof(double *) * (msa->abc->Kp));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:489:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(bp_ct[apos][x], sizeof(double) * (msa->abc->Kp));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:499:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(abc_ct, sizeof(double *) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:501:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(abc_ct[apos], sizeof(double) * (msa->abc->K+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c: In function 'dump_infocontent_info':
>esl-alistat.c:606:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg, sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:611:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(abc_freq, sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c: In function 'dump_insert_info':
>esl-alistat.c:872:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(total_ict, sizeof(double) * (msa->alen+2));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:875:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ict,  sizeof(double *) * (msa->alen+2));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:878:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ict[i],  sizeof(double) * (msa->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c: In function 'dump_basepair_counts':
>esl-alistat.c:1011:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct,  sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:1012:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss_nopseudo, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c: In function 'map_rfpos_to_apos':
>esl-alistat.c:1098:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(i_am_rf, sizeof(int) * alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-alistat.c:1099:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rf2a_map, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl-cluster.o
>esl-alimanip.c: In function 'minorize_msa':
>esl-alimanip.c:2862:82: warning: ', but the major alignment has a gap there! cmalign will choke on this.
>   ' directive output truncated writing 71 bytes into a region of size between 50 and 59 [-Wformat-truncation=]
>      if (esl_abc_CIsGap(msa->abc, msa->rf[apos])) ESL_FAIL(eslEINCOMPAT, errbuf, "'#=GF %s <RF sequence>' markup has a non-gap (%c char) at aln position %d, but the major alignment has a gap there! cmalign will choke on this.\n", msa->gf_tag[f], minor_msaA[m]->rf[(apos-1)], apos);
>                                                                                  ^
>../easel.h:57:57: note: in definition of macro 'ESL_FAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from esl-alimanip.c:6:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output 141 or more bytes (assuming 150) into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>     CC esl-compalign.o
>esl-alimerge.c: In function 'main':
>esl-alimerge.c:405:22: warning: 'clen' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   alen_mmsa = clen + esl_vec_ISum(maxgap, clen+1) + esl_vec_ISum(maxmis, clen+1);
>                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
>esl-alimerge.c:221:7: warning: 'nalifile' may be used uninitialized in this function [-Wmaybe-uninitialized]
>     if(nalifile == 0) esl_fatal("Failed to read a single alignment file name from %s\n", listfile);
>       ^
>In file included from esl-compalign.c:10:0:
>esl-compalign.c: In function 'main':
>esl-compalign.c:192:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(seqlen, sizeof(int) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:195:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(ks, sizeof(ESL_DSQ) * (ka->alen+2));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:199:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(ts, sizeof(ESL_DSQ) * (ta->alen+2));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:235:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(ptm,     sizeof(int) * npostvals);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:236:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pti,     sizeof(int) * npostvals);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:237:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(cor_ptm, sizeof(int) * npostvals);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:238:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(cor_pti, sizeof(int) * npostvals);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:246:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(kp, sizeof(int *) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:247:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(tp, sizeof(int *) * ta->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:249:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(kp[i], sizeof(int) * (seqlen[i]+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:250:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(tp[i], sizeof(int) * (seqlen[i]+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:255:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(km_pos, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:256:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ki_pos, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:257:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(tm_pos, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:258:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ti_pos, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:259:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cor_tm_pos, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:260:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cor_ti_pos, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:268:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(km_seq, sizeof(int) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:269:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ki_seq, sizeof(int) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:270:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(tm_seq, sizeof(int) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:271:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ti_seq, sizeof(int) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:272:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cor_tm_seq, sizeof(int) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:273:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cor_ti_seq, sizeof(int) * ka->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c:107:66: warning: variable 'tot_incor_pti' set but not used [-Wunused-but-set-variable]
>   int tot_cor_ptm, tot_cor_pti, tot_ptm, tot_pti, tot_incor_ptm, tot_incor_pti; /* total counts of posteriors */
>                                                                  ^~~~~~~~~~~~~
>esl-compalign.c:107:51: warning: variable 'tot_incor_ptm' set but not used [-Wunused-but-set-variable]
>   int tot_cor_ptm, tot_cor_pti, tot_ptm, tot_pti, tot_incor_ptm, tot_incor_pti; /* total counts of posteriors */
>                                                   ^~~~~~~~~~~~~
>In file included from esl-compalign.c:10:0:
>esl-compalign.c: In function 'read_mask_file':
>esl-compalign.c:561:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mask, sizeof(char) * (toklen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compalign.c: In function 'main':
>esl-compalign.c:330:37: warning: 'ppidx' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if(do_post_for_this_rfpos) cor_ptm[ppidx]++;
>                                     ^
>esl-compalign.c:231:6: warning: 'masklen' may be used uninitialized in this function [-Wmaybe-uninitialized]
>      esl_fatal("Length of mask in %s (%d) not equal to non-gap RF len of alignments (%d)\n", esl_opt_GetString(go, "--p-mask"), masklen, rflen);
>      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>In file included from esl-alimanip.c:12:0:
>esl-alimanip.c: In function 'main':
>esl-alimanip.c:3178:33: warning: '--post2pp requires "#=GR POST", "#=GR Post", "#=GR post", "#=GR POSTX.", or "#=GR POSTX." and "#=GR POST.X" annotation, it's missing from alignment ' directive output truncated writing 148 bytes into a region of size 128 [-Wformat-truncation=]
>     ESL_FAIL(eslEINVAL, errbuf, "--post2pp requires \"#=GR POST\", \"#=GR Post\", \"#=GR post\", \"#=GR POSTX.\", or \"#=GR POSTX.\" and \"#=GR POST.X\" annotation, it's missing from alignment %d\n", nali);
>                                 ^
>../easel.h:57:57: note: in definition of macro 'ESL_FAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>esl-alimanip.c:3178:33: note: directive argument in the range [1, 2147483647]
>     ESL_FAIL(eslEINVAL, errbuf, "--post2pp requires \"#=GR POST\", \"#=GR Post\", \"#=GR post\", \"#=GR POSTX.\", or \"#=GR POSTX.\" and \"#=GR POST.X\" annotation, it's missing from alignment %d\n", nali);
>                                 ^
>../easel.h:57:57: note: in definition of macro 'ESL_FAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from esl-alimanip.c:6:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output between 151 and 160 bytes into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>In file included from esl-alimanip.c:12:0:
>esl-alimanip.c:3209:67: warning: ', post 'tens' value '*' but post 'ones' value != '*'.
>   ' directive output may be truncated writing 54 bytes into a region of size between 46 and 73 [-Wformat-truncation=]
>    if(msa->gr[ridx2][i][apos] != '*') ESL_FAIL(eslEINVAL, errbuf, "reading post annotation for aln %d, seq: %d aln column: %d, post 'tens' value '*' but post 'ones' value != '*'.\n", nali, i, apos);
>                                                                   ^
>../easel.h:57:57: note: in definition of macro 'ESL_FAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from esl-alimanip.c:6:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output between 110 and 137 bytes into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>esl-alimanip.c:545:6: warning: 'order' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    if((status = reorder_msa(msa, order, errbuf)) != eslOK) esl_fatal(errbuf);
>      ^
>     CC esl-compstruct.o
>In file included from esl-compstruct.c:9:0:
>esl-compstruct.c: In function 'main':
>esl-compstruct.c:180:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(kct, sizeof(int) * (klen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-compstruct.c:181:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(tct, sizeof(int) * (tlen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl-construct.o
>In file included from esl-construct.c:16:0:
>esl-construct.c: In function 'main':
>esl-construct.c:240:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sscons, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:241:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cur_ct, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:242:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cons_ct, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:243:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(xcons_ct, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:244:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(bp, sizeof(int *) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:245:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(removebp, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:246:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(has_conflict, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:247:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(nmates_l2r, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:248:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(nmates_r2l, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:257:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(nconflictsA, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:258:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(noverlapsA, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:259:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(nconsistentA, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:260:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(nbpsA, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:269:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(bp[i], sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-construct.c:82:17: warning: variable 'indi2cons' set but not used [-Wunused-but-set-variable]
>   char         *indi2cons;
>                 ^~~~~~~~~
>In file included from esl-construct.c:16:0:
>esl-construct.c: In function 'get_gaps_per_column':
>esl-construct.c:700:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ngaps, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl-histplot.o
>     CC esl-mask.o
>esl-construct.c: In function 'main':
>esl-construct.c:577:17: warning: 'fmin' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if(do_fmin)  { printf("#\n# <x> determined to be %.3f\n", fthresh); }
>                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>     CC esl-reformat.o
>In file included from esl-reformat.c:10:0:
>esl-reformat.c: In function 'parse_replace_string':
>esl-reformat.c:923:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(from, sizeof(char) * (mid+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-reformat.c:924:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(to,   sizeof(char) * (mid+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl-selectn.o
>     CC esl-seqrange.o
>esl-reformat.c: In function 'main':
>esl-reformat.c:416:9: warning: 'mapfp' may be used uninitialized in this function [-Wmaybe-uninitialized]
>         fclose(mapfp);
>         ^~~~~~~~~~~~~
>esl-reformat.c:212:6: warning: 'reached_eof' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    if(! reached_eof) esl_fatal("Input file contains >1 alignments, but afa formatted output file can only contain 1");
>      ^
>esl-reformat.c:426:23: warning: 'rto' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if(rto != NULL)     free(rto);
>                       ^~~~~~~~~
>esl-reformat.c:425:23: warning: 'rfrom' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if(rfrom != NULL)   free(rfrom);
>                       ^~~~~~~~~~~
>In file included from esl-seqrange.c:12:0:
>esl-seqrange.c: In function 'range_by_seqnum':
>esl-seqrange.c:144:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(final_sqidx, sizeof(int64_t) * nproc);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-seqrange.c:134:15: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int         status;
>               ^~~~~~
>esl-seqrange.c: In function 'main':
>esl-seqrange.c:118:97: warning: 'final_sqidx' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   printf("%" PRId64 "-%" PRId64 "\n", (procidx == 1) ? 1 : final_sqidx[procidx-2]+1, final_sqidx[procidx-1]); /* careful: final_sqidx runs 0..nproc-1 */
>                                                                                                 ^
>     CC esl-seqstat.o
>In file included from esl-seqstat.c:20:0:
>esl-seqstat.c: In function 'main':
>esl-seqstat.c:137:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(monoc,     (abc->Kp) * sizeof(double));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-seqstat.c:138:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(monoc_all, (abc->Kp) * sizeof(double));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl-sfetch.o
>     CC esl-shuffle.o
>     CC esl-ssdraw.o
>In file included from esl-shuffle.c:13:0:
>esl-shuffle.c: In function 'seq_generation':
>esl-shuffle.c:194:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fq, sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-shuffle.c: In function 'seq_shuffling':
>esl-shuffle.c:271:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(targ, sizeof(char) * (L+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'main':
>esl-ssdraw.c:858:115: warning: operation on '**(*(hc_scheme + 40) + 16)' may be undefined [-Wsequence-point]
>   hc_scheme[RB_6_RL_SCHEME][2][ICYAN] = hc_scheme[RB_6_RH_SCHEME][3][ICYAN] = hc_scheme[RB_5_RL_SCHEME][2][ICYAN] = hc_scheme[RB_5_RL_SCHEME][2][ICYAN] = RED2BLUE_3_OF_6_C;
>                                                                                                                   ^
>esl-ssdraw.c:859:115: warning: operation on '*(*(*(hc_scheme + 40) + 16) + 4)' may be undefined [-Wsequence-point]
>   hc_scheme[RB_6_RL_SCHEME][2][IMGTA] = hc_scheme[RB_6_RH_SCHEME][3][IMGTA] = hc_scheme[RB_5_RL_SCHEME][2][IMGTA] = hc_scheme[RB_5_RL_SCHEME][2][IMGTA] = RED2BLUE_3_OF_6_M;
>                                                                                                                   ^
>esl-ssdraw.c:860:115: warning: operation on '*(*(*(hc_scheme + 40) + 16) + 8)' may be undefined [-Wsequence-point]
>   hc_scheme[RB_6_RL_SCHEME][2][IYELW] = hc_scheme[RB_6_RH_SCHEME][3][IYELW] = hc_scheme[RB_5_RL_SCHEME][2][IYELW] = hc_scheme[RB_5_RL_SCHEME][2][IYELW] = RED2BLUE_3_OF_6_Y;
>                                                                                                                   ^
>esl-ssdraw.c:861:115: warning: operation on '*(*(*(hc_scheme + 40) + 16) + 12)' may be undefined [-Wsequence-point]
>   hc_scheme[RB_6_RL_SCHEME][2][IBLCK] = hc_scheme[RB_6_RH_SCHEME][3][IBLCK] = hc_scheme[RB_5_RL_SCHEME][2][IBLCK] = hc_scheme[RB_5_RL_SCHEME][2][IBLCK] = RED2BLUE_3_OF_6_K;
>                                                                                                                   ^
>esl-ssdraw.c: In function 'create_sspostscript':
>esl-ssdraw.c:1322:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>esl-ssdraw.c: In function 'setup_sspostscript':
>esl-ssdraw.c:1399:9: warning: variable 'header_fontwidth' set but not used [-Wunused-but-set-variable]
>   float header_fontwidth, header_max_chars;
>         ^~~~~~~~~~~~~~~~
>esl-ssdraw.c: In function 'create_onecell_colorlegend':
>esl-ssdraw.c:1588:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'create_text_legend':
>esl-ssdraw.c:1637:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tl->text_per_line, sizeof(char *) * nlines);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'create_text_legend_for_consensus_sequence':
>esl-ssdraw.c:1668:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(text, sizeof(char *) * nlines);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:1671:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(text[1], sizeof(char) * (strlen("as the least ambiguous nt that represents >= 1.00") + 1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:1679:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(text, sizeof(char *) * nlines);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:1683:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(text[2], sizeof(char) * (strlen("Capitalized nts occur in >= 1.00 fraction of sequences") + 1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'create_scheme_colorlegend':
>esl-ssdraw.c:1722:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(scl->limits, sizeof(float) * (nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:1725:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(counts, sizeof(int) * nbins);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:1726:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(counts_masked, sizeof(int) * nbins);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:1708:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'add_text_to_scheme_colorlegend':
>esl-ssdraw.c:1780:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(scl->text1, sizeof(char) * (idx+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC esl-stranslate.o
>esl-ssdraw.c:1787:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(scl->text2, sizeof(char) * (len - idx+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'add_procedure_to_onecell_colorlegend':
>esl-ssdraw.c:1852:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(occl->procstack, sizeof(float) * nprocstack);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'add_page_desc_to_sspostscript':
>esl-ssdraw.c:1902:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->descA[page], sizeof(char) * (textlen + 3)); /* +3 so we have space for the extra '-' and '\n' */
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:1917:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->descA[page], sizeof(char) * (max_both_lines + 2)); /* +2 so we have space for the extra '\n' (which we won't print), and the '\0' */
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'draw_legend_column_headers':
>esl-ssdraw.c:2057:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cur_string, sizeof(char) * (cur_width+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:2034:15: warning: variable 'legend_fontsize' set but not used [-Wunused-but-set-variable]
>   float x, y, legend_fontsize;
>               ^~~~~~~~~~~~~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'draw_onecell_colorlegend':
>esl-ssdraw.c:2172:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(cur_string, sizeof(char) * (cur_width+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:2095:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'draw_text_section_in_legend':
>esl-ssdraw.c:2401:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(cur_string, sizeof(char) * (cur_width+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:2377:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     CC esl-weight.o
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'draw_sspostscript':
>esl-ssdraw.c:2443:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(page_orderA, sizeof(int) * ps->npage);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'parse_modelname_section':
>esl-ssdraw.c:2883:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ps->modelname, sizeof(char) * (curlen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'parse_regurgitate_section':
>esl-ssdraw.c:3080:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(newstr, sizeof(char) * (curlen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'individuals_sspostscript':
>esl-ssdraw.c:3397:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rAA[p],    sizeof(char) *  (ps->rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3398:62: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     if(do_rescol)  ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3400:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->otypeAA[p], sizeof(char) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3403:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3408:63: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->occlAAA[p], sizeof(OneCellColorLegend_t **) * noccl);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3417:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p], sizeof(char) *  (ps->rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3418:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3421:65: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       if(do_prob_res) ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3430:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits_s, sizeof(float) * (hc_nbins_s+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3439:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits_p, sizeof(float) * (hc_nbins_p+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3450:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ps->uaseqlenA, sizeof(int) * msa->nseq);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl-afetch
>esl-ssdraw.c: In function 'cons_seq_sspostscript':
>esl-ssdraw.c:3840:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rAA[p], sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3866:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rcolAAA[pp], sizeof(float *) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'rf_seq_sspostscript':
>esl-ssdraw.c:3982:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rAA[p], sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:3995:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rcolAAA[pp], sizeof(float *) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'count_msa':
>esl-ssdraw.c:4105:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(pp_ct, sizeof(double *) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4107:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(pp_ct[apos], sizeof(double) * nppvals);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4113:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct,  sizeof(int)  * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4114:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss_nopseudo, sizeof(char) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4118:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp_dsq, (msa->alen+2) * sizeof(ESL_DSQ));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4119:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(abc_ct, sizeof(double *) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4120:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bp_ct,  sizeof(double **) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4122:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(abc_ct[apos], sizeof(double) * (abc->K+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4126:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(bp_ct[apos], sizeof(double *) * (abc->Kp));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4128:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(bp_ct[apos][x], sizeof(double) * (abc->Kp));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4136:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(spos_ct, sizeof(int) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4137:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(epos_ct, sizeof(int) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl-alimanip
>esl-ssdraw.c: In function 'infocontent_sspostscript':
>esl-ssdraw.c:4220:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4224:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p],     sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4225:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4236:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ent, sizeof(double) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4237:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg, sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4239:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp_obs, sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4245:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'delete_sspostscript':
>esl-ssdraw.c:4394:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(int *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4398:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p],     sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4399:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4413:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'insertfreq_sspostscript':
>esl-ssdraw.c:4615:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4619:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p],     sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4620:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4633:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4596:7: warning: variable 'apos' set but not used [-Wunused-but-set-variable]
>   int apos;
>       ^~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'insertavglen_sspostscript':
>esl-ssdraw.c:4791:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4795:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p],     sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4796:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4809:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl-alimap
>     GEN esl-alimask
>esl-ssdraw.c:4777:7: warning: variable 'apos' set but not used [-Wunused-but-set-variable]
>   int apos;
>       ^~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'span_sspostscript':
>esl-ssdraw.c:4961:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4965:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p],     sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4966:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:4980:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'avg_posteriors_sspostscript':
>esl-ssdraw.c:5136:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5140:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p],     sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5141:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5152:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'colormask_sspostscript':
>esl-ssdraw.c:5303:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rAA[p], sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5304:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'diffmask_sspostscript':
>esl-ssdraw.c:5378:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rAA[p], sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5379:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'add_pages_sspostscript':
>esl-ssdraw.c:5444:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rAA,    sizeof(char *)   * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5445:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->rcolAAA, sizeof(float **) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5446:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA, sizeof(float **) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl-alimerge
>esl-ssdraw.c:5447:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->otypeAA, sizeof(char *) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5448:61: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->occlAAA, sizeof(OneCellColorLegend_t ***) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5449:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->nocclA,  sizeof(int) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5450:53: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->tlAAA,   sizeof(TextLegend_t ***) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5451:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->ntlA,    sizeof(int) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5452:59: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->sclAA,   sizeof(SchemeColorLegend_t **) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5453:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->descA,   sizeof(char *) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5454:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->modeA,   sizeof(int) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5455:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->seqidxA, sizeof(int) * (ps->npage + ntoadd));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'read_mask_file':
>esl-ssdraw.c:5526:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mask, sizeof(char) * (toklen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'mutual_information_sspostscript':
>esl-ssdraw.c:5594:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5598:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rAA[p],     sizeof(char) *  ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5599:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ps->rcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5612:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5666:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg,        sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5667:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg_pair,   sizeof(double) * abc->K*abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5675:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(obs_left,  sizeof(double) * (abc->K));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5676:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(obs_right, sizeof(double) * (abc->K));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5677:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(obs_pair,  sizeof(double) * (abc->K*abc->K));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'PairCount':
>esl-ssdraw.c:5853:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(left,  sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5854:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(right, sizeof(double) * abc->K);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:5844:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     GEN esl-alipid
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'validate_and_update_sspostscript_given_msa':
>esl-ssdraw.c:6098:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rf2a_map, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6099:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a2rf_map, sizeof(int) * msa->alen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6111:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp_ct, sizeof(int) * (msa->alen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6114:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa_ct, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'draw_header_and_footer':
>esl-ssdraw.c:6191:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(model_dashes, sizeof(char) * (model_width+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl-alistat
>esl-ssdraw.c:6247:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(desc_dashes, sizeof(char) * (desc_column_width+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6259:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(desc2print, sizeof(char) * (split_idx+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6267:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(desc2print, sizeof(char) * ((desc_width - split_idx) -1+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'get_insert_info_from_msa':
>esl-ssdraw.c:6352:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nseq_with_ins_ct, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6354:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nins_ct, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6356:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(per_seq_ins_ct, sizeof(int *) * (msa->nseq));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6358:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(per_seq_ins_ct[i],  sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6341:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;
>                   ^~~~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'get_insert_info_from_ifile':
>esl-ssdraw.c:6520:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nseq_with_ins_ct, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6523:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nins_ct, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6527:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(srfoff_ct, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6531:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(erfoff_ct, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6535:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(per_seq_ins_ct, sizeof(int *) * (nseq2store));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6537:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(per_seq_ins_ct[i],  sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl-cluster
>esl-ssdraw.c: In function 'get_insert_info_from_abc_ct':
>esl-ssdraw.c:6730:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nseq_with_ins_ct, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6732:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nins_ct, sizeof(int) * (rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6723:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;
>                   ^~~~~~
>     GEN esl-compalign
>     GEN esl-compstruct
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'get_span_ct':
>esl-ssdraw.c:6833:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(span_ct, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6834:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nseq_start_after_rfpos, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6835:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nseq_end_before_rfpos, sizeof(int) * rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:6825:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from esl-ssdraw.c:16:0:
>esl-ssdraw.c: In function 'drawfile2sspostscript':
>esl-ssdraw.c:6924:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(limits, sizeof(float) * (hc_nbins+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl-construct
>     GEN esl-histplot
>esl-ssdraw.c:6990:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'expertfile2sspostscript':
>esl-ssdraw.c:7066:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(ps->rAA[p], sizeof(char) *  (ps->rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:7067:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c: In function 'get_consensus_seqs_from_abc_ct':
>esl-ssdraw.c:7307:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cseq_maj, sizeof(char) * (ps->rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:7308:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cseq_amb, sizeof(char) * (ps->rflen+1));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:7311:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sorted_ntfreq, sizeof(nt2sort_t) * (abc->K));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:7312:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nt_is_used, sizeof(int) * (abc->K));
>../easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>esl-ssdraw.c:7291:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;          /* the Easel return status */
>                   ^~~~~~
>     GEN esl-mask
>     GEN esl-reformat
>     GEN esl-selectn
>     GEN esl-seqrange
>     GEN esl-seqstat
>     GEN esl-sfetch
>     GEN esl-shuffle
>     GEN esl-stranslate
>     GEN esl-weight
>esl-ssdraw.c: In function 'count_msa':
>esl-ssdraw.c:4159:12: warning: 'epos' may be used uninitialized in this function [-Wmaybe-uninitialized]
>     epos_ct[epos]++;
>            ^
>esl-ssdraw.c: In function 'parse_template_file.isra.12':
>esl-ssdraw.c:3113:9: warning: 'nalloc' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int   nalloc;
>         ^~~~~~
>esl-ssdraw.c:6051:8: warning: 'ps' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if(ps->modelname == NULL) ESL_FAIL(eslEINVAL, errbuf, "Error, failed to read modelname from template file.");
>      ~~^~~~~~~~~~~
>esl-ssdraw.c:2698:19: note: 'ps' was declared here
>   SSPostscript_t *ps;
>                   ^~
>esl-ssdraw.c: In function 'get_insert_info_from_ifile.constprop':
>esl-ssdraw.c:6661:32: warning: 'rfpos' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if(! seen_end_of_model_line) esl_fatal("Error reading insert file, didn't read the special '//' line at the end of file %s.\n", rfpos, efp->linenumber, ifile);
>                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>esl-ssdraw.c: In function 'draw_sspostscript.isra.24':
>esl-ssdraw.c:6260:2: warning: 'split_idx' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  for(i = 0; i < split_idx; i++) desc2print[i] = ps->descA[page][i];
>  ^~~
>esl-ssdraw.c:6160:10: note: 'split_idx' was declared here
>   int i, split_idx;
>          ^~~~~~~~~
>In file included from esl-ssdraw.c:16:0:
>In function 'expertfile2sspostscript',
>    inlined from 'main' at esl-ssdraw.c:1229:7:
>../easel.h:146:16: warning: argument 1 value '18446744073709551608' exceeds maximum object size 9223372036854775807 [-Walloc-size-larger-than=]
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                ^~~~~~~~~~~~
>esl-ssdraw.c:7067:4: note: in expansion of macro 'ESL_ALLOC'
>    ESL_ALLOC(ps->bcolAAA[p], sizeof(float *) * ps->rflen);
>    ^~~~~~~~~
>In file included from esl-ssdraw.c:9:0:
>esl-ssdraw.c: In function 'main':
>/usr/include/stdlib.h:443:14: note: in a call to allocation function 'malloc' declared here
> extern void *malloc (size_t __size) __THROW __attribute_malloc__ __wur;
>              ^~~~~~
>     GEN esl-ssdraw
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/easel/miniapps'
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/easel'
>     SUBDIR libdivsufsort
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/libdivsufsort'
>     CC divsufsort.o
>     AR libdivsufsort.a
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/libdivsufsort'
>     SUBDIR src
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/src'
>     CC build.o
>     CC alimask.o
>     CC emit.o
>     CC cachedb.o
>In file included from emit.c:15:0:
>emit.c: In function 'sample_endpoints':
>emit.c:418:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pstart, sizeof(float) * (gm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from cachedb.c:16:0:
>cachedb.c: In function 'p7_seqcache_Open':
>cachedb.c:110:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cache->list, sizeof(HMMER_SEQ) * seq_cnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>cachedb.c:114:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(db, sizeof(SEQ_DB) * db_cnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>cachedb.c:119:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(db[i].list, sizeof(HMMER_SEQ *) * db[i].count);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from build.c:29:0:
>build.c: In function 'p7_Handmodelmaker':
>build.c:92:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matassign, sizeof(int) * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c: In function 'p7_Fastmodelmaker':
>build.c:170:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matassign, sizeof(int)     * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c: In function 'matassign2hmm':
>build.c:284:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr, sizeof(P7_TRACE *) * msa->nseq);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c:312:57: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (msa->rf == NULL)  ESL_ALLOC(msa->rf, sizeof(char) * (msa->alen + 1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c: In function 'annotate_model':
>build.c:354:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->rf, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c:364:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->mm, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c:374:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->cs, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c:384:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->ca, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>build.c:393:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->map, sizeof(int) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from alimask.c:11:0:
>alimask.c: In function 'main':
>alimask.c:393:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(map, sizeof(int)     * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>alimask.c:381:9: warning: variable 'L' set but not used [-Wunused-but-set-variable]
>     int L;
>         ^
>     CC errors.o
>     CC evalues.o
>     CC eweight.o
>     CC generic_decoding.o
>In file included from evalues.c:15:0:
>evalues.c: In function 'p7_MSVMu':
>evalues.c:253:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xv,  sizeof(double)  * N);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>evalues.c:254:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>evalues.c: In function 'p7_ViterbiMu':
>evalues.c:326:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xv,  sizeof(double)  * N);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>evalues.c:327:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>evalues.c: In function 'p7_Tau':
>evalues.c:432:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xv,  sizeof(double)  * N);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>evalues.c:433:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC generic_fwdback.o
>     CC generic_fwdback_chk.o
>     CC generic_fwdback_banded.o
>     CC generic_null2.o
>     CC generic_msv.o
>     CC generic_optacc.o
>     CC generic_stotrace.o
>In file included from generic_stotrace.c:17:0:
>generic_stotrace.c: In function 'p7_GStochasticTrace':
>generic_stotrace.c:63:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sc, sizeof(float) * (2*M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>generic_stotrace.c:178:27: warning: 'scur' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       if ( (scur == p7T_N || scur == p7T_J || scur == p7T_C) && scur == sprv) i--;
>             ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~
>     CC generic_viterbi.o
>     CC generic_vtrace.o
>     CC h2_io.o
>     CC heatmap.o
>     CC hmmlogo.o
>     CC hmmdmstr.o
>     CC hmmdwrkr.o
>hmmlogo.c: In function 'hmmlogo_ScoreHeights':
>hmmlogo.c:110:9: warning: variable 'pos_scoresum' set but not used [-Wunused-but-set-variable]
>   float pos_scoresum;
>         ^~~~~~~~~~~~
>In file included from hmmer.h:43:0,
>                 from hmmlogo.c:10:
>hmmlogo.c: In function 'main':
>hmmlogo.c:243:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rel_ents, (hmm->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmlogo.c:244:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(heights,  (hmm->M+1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmlogo.c:245:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(probs,    (hmm->M+1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmlogo.c:248:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(heights[i], abc->K * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmlogo.c:249:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(probs[i],   abc->K * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmlogo.c:287:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ins_P, (hmm->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmlogo.c:288:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ins_expL, (hmm->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmlogo.c:289:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(occupancy, (hmm->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from hmmdwrkr.c:27:0:
>hmmdwrkr.c: In function 'process_SearchCmd':
>hmmdwrkr.c:205:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * env->ncpus);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmdwrkr.c:189:20: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int              status;
>                    ^~~~~~
>     CC hmmdutils.o
>In file included from hmmdutils.c:27:0:
>hmmdutils.c: In function 'hmmpgmd_GetRanges':
>hmmdutils.c:255:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(list->starts, list->N * sizeof(int));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmdutils.c:256:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(list->ends,   list->N * sizeof(int));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC hmmer.o
>     CC logsum.o
>     CC modelconfig.o
>     CC modelstats.o
>In file included from modelstats.c:9:0:
>modelstats.c: In function 'p7_MeanPositionRelativeEntropy':
>modelstats.c:172:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mocc, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>modelstats.c: In function 'p7_hmm_CompositionKLDist':
>modelstats.c:235:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(occ, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>modelstats.c:236:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(float) * K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC mpisupport.o
>In file included from modelconfig.c:23:0:
>modelconfig.c: In function 'p7_ProfileConfig':
>modelconfig.c:92:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(occ, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC seqmodel.o
>     CC tracealign.o
>     CC p7_alidisplay.o
>In file included from tracealign.c:14:0:
>tracealign.c: In function 'p7_tracealign_getMSAandStats':
>tracealign.c:410:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr, sizeof(P7_TRACE *) * N);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c: In function 'map_new_msa':
>tracealign.c:524:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(inscount, sizeof(int) * (M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c:525:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(insnum,   sizeof(int) * (M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c:526:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matuse,   sizeof(int) * (M+1)); matuse[0] = 0;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c:527:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matmap,   sizeof(int) * (M+1)); matmap[0] = 0;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c: In function 'annotate_rf':
>tracealign.c:825:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->rf, sizeof(char) * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c: In function 'annotate_mm':
>tracealign.c:869:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->mm, sizeof(char) * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c: In function 'annotate_posterior_probability':
>tracealign.c:901:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matuse, sizeof(double) * (msa->alen)); esl_vec_ISet(matuse, msa->alen, 0);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c:902:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(totp,   sizeof(double) * (msa->alen)); esl_vec_DSet(totp,   msa->alen, 0.0);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c:904:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->pp, sizeof(char *) * msa->sqalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c:909:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->pp[idx], sizeof(char) * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>tracealign.c:952:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->pp_cons, sizeof(char) * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC p7_bg.o
>p7_alidisplay.c: In function 'p7_alidisplay_Create':
>p7_alidisplay.c:68:18: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int            status;
>                  ^~~~~~
>In file included from p7_alidisplay.c:21:0:
>p7_alidisplay.c: In function 'p7_alidisplay_Clone':
>p7_alidisplay.c:243:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ad2->mem, sizeof(char) * ad->memsize);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_alidisplay.c:232:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>p7_alidisplay.c: In function 'p7_alidisplay_Serialize':
>p7_alidisplay.c:385:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (ad->mem) free(ad->mem); ad->mem = NULL;
>   ^~
>p7_alidisplay.c:385:31: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (ad->mem) free(ad->mem); ad->mem = NULL;
>                               ^~
>In file included from p7_alidisplay.c:21:0:
>p7_alidisplay.c: In function 'p7_alidisplay_Deserialize':
>p7_alidisplay.c:423:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->hmmname,  sizeof(char) * n); memcpy(ad->hmmname,  ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_alidisplay.c:424:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->hmmacc,   sizeof(char) * n); memcpy(ad->hmmacc,   ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_alidisplay.c:425:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->hmmdesc,  sizeof(char) * n); memcpy(ad->hmmdesc,  ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_alidisplay.c:426:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->sqname,   sizeof(char) * n); memcpy(ad->sqname,   ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_alidisplay.c:427:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->sqacc,    sizeof(char) * n); memcpy(ad->sqacc,    ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_alidisplay.c:428:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->sqdesc,   sizeof(char) * n); memcpy(ad->sqdesc,   ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_alidisplay.c: In function 'p7_alidisplay_Print':
>p7_alidisplay.c:598:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (aliwidth+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from p7_bg.c:19:0:
>p7_bg.c: In function 'p7_bg_Create':
>p7_bg.c:64:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg->f,     sizeof(float) * abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_bg.c:58:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from p7_bg.c:19:0:
>p7_bg.c: In function 'p7_bg_CreateUniform':
>p7_bg.c:101:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg->f,     sizeof(float) * abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_bg.c:95:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from p7_bg.c:19:0:
>p7_bg.c: In function 'p7_bg_Clone':
>p7_bg.c:136:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dup->f, sizeof(float) * bg->abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_bg.c:129:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from p7_bg.c:19:0:
>p7_bg.c: In function 'p7_bg_Read':
>p7_bg.c:267:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fq, sizeof(float) * bg->abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC p7_builder.o
>     CC p7_domaindef.o
>In file included from p7_domaindef.c:41:0:
>p7_domaindef.c: In function 'p7_domaindef_Create':
>p7_domaindef.c:88:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ddef->mocc, sizeof(float) * (Lalloc+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_domaindef.c:89:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ddef->btot, sizeof(float) * (Lalloc+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_domaindef.c:90:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ddef->etot, sizeof(float) * (Lalloc+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_domaindef.c:91:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ddef->n2sc, sizeof(float) * (Lalloc+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_domaindef.c:98:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ddef->dcl, sizeof(P7_DOMAIN) * nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_domaindef.c:77:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>In file included from p7_domaindef.c:41:0:
>p7_domaindef.c: In function 'p7_domaindef_Reuse':
>p7_domaindef.c:197:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ddef->dcl, sizeof(P7_DOMAIN) * ddef->nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_builder.c: In function 'p7_builder_Create':
>p7_builder.c:57:15: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int         status;
>               ^~~~~~
>In file included from p7_builder.c:14:0:
>p7_builder.c: In function 'p7_builder_LoadScoreSystem':
>p7_builder.c:214:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(f, sizeof(double) * bg->abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_builder.c: In function 'p7_builder_SetScoreSystem':
>p7_builder.c:314:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(f, sizeof(double) * bg->abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_builder.c: In function 'p7_Builder_MaxLength':
>p7_builder.c:672:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(I, (model_len+1) * sizeof(double*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_builder.c:673:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(M, (model_len+1) * sizeof(double*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_builder.c:674:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(D, (model_len+1) * sizeof(double*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_builder.c: In function 'p7_builder_SetScoreSystem':
>p7_builder.c:308:110: warning: '%s' directive output may be truncated writing up to 127 bytes into a region of size 99 [-Wformat-truncation=]
>       if ((status = esl_scorematrix_Read(efp, bld->abc, &(bld->S))) != eslOK) ESL_XFAIL(status, bld->errbuf, "Failed to read matrix from %s:\n%s",    mxfile, efp->errbuf);
>                                                                                                              ^
>../easel/easel.h:63:57: note: in definition of macro 'ESL_XFAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from p7_builder.c:12:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output 30 or more bytes (assuming 157) into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>     CC p7_gbands.o
>In file included from p7_gbands.c:3:0:
>p7_gbands.c: In function 'p7_gbands_Create':
>p7_gbands.c:26:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bnd->imem, sizeof(int) * init_segalloc * 2); /* *2: for ia, ib pairs */
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gbands.c:27:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bnd->kmem, sizeof(int) * init_rowalloc * p7_GBANDS_NK);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gbands.c:14:14: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int        status;
>              ^~~~~~
>     CC p7_gmx.o
>     CC p7_gmxb.o
>     CC p7_gmxchk.o
>In file included from hmmer.h:43:0,
>                 from p7_gmx.c:12:
>p7_gmx.c: In function 'p7_gmx_Create':
>p7_gmx.c:45:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gx->dp,      sizeof(float *) * (allocL+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gmx.c:46:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gx->xmx,     sizeof(float)   * (allocL+1) * p7G_NXCELLS);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gmx.c:47:68: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gx->dp_mem,  sizeof(float)   * (allocL+1) * (allocM+1) * p7G_NSCELLS);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gmx.c:34:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from hmmer.h:43:0,
>                 from p7_gmxchk.c:20:
>p7_gmxchk.c: In function 'p7_gmxchk_Create':
>p7_gmxchk.c:96:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( gxc->dp_mem, sizeof(float)   * gxc->ncells);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gmxchk.c:97:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( gxc->dp,     sizeof(float *) * gxc->allocR);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gmxchk.c:74:14: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int        status;
>              ^~~~~~
>In file included from p7_gmxb.c:2:0:
>p7_gmxb.c: In function 'p7_gmxb_Create':
>p7_gmxb.c:21:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gxb->dp,  sizeof(float) * bnd->ncell * p7G_NSCELLS); /* i.e. *3, for MID (0..2)   */
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gmxb.c:22:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gxb->xmx, sizeof(float) * bnd->nrow  * p7G_NXCELLS); /* i.e. *5, for ENJBC (0..4) */
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_gmxb.c:12:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>     CC p7_hmm.o
>     CC p7_hmmcache.o
>     CC p7_hmmfile.o
>     CC p7_hmmwindow.o
>p7_hmm.c: In function 'p7_hmm_CreateShell':
>In file included from p7_hmmcache.c:14:0:
>p7_hmmcache.c: In function 'p7_hmmcache_Open':
>p7_hmm.c:82:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from p7_hmm.c:21:0:
>p7_hmm.c: In function 'p7_hmm_CreateBody':
>p7_hmmcache.c:67:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cache->list, sizeof(P7_OPROFILE *) * cache->lalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:141:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->t,    (M+1) * sizeof(float *));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:142:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->mat,  (M+1) * sizeof(float *));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:143:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->ins,  (M+1) * sizeof(float *));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:149:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->t[0],   (p7H_NTRANSITIONS*(M+1)) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:150:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->mat[0], (abc->K*(M+1))           * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:151:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->ins[0], (abc->K*(M+1))           * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:166:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_RF)    ESL_ALLOC(hmm->rf,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:167:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_MMASK) ESL_ALLOC(hmm->mm,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:168:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_CONS)  ESL_ALLOC(hmm->consensus,  (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:169:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_CS)    ESL_ALLOC(hmm->cs,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:170:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_CA)    ESL_ALLOC(hmm->ca,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:171:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_MAP)   ESL_ALLOC(hmm->map,        (M+1) * sizeof(int));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c: In function 'p7_hmm_Clone':
>p7_hmm.c:282:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->map, sizeof(int) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c: In function 'p7_hmm_AppendComlog':
>p7_hmm.c:528:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->comlog, sizeof(char)* (n+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c: In function 'p7_hmm_SetComposition':
>p7_hmm.c:634:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mocc, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c:635:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(iocc, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmm.c: In function 'p7_hmm_SetConsensus':
>p7_hmm.c:711:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (! hmm->consensus) ESL_ALLOC(hmm->consensus, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from hmmer.h:43:0,
>                 from p7_hmmwindow.c:12:
>p7_hmmwindow.c: In function 'p7_hmmwindow_init':
>p7_hmmwindow.c:31:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(list->windows, list->size * sizeof(P7_HMM_WINDOW));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_hmmwindow.c:28:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>p7_hmmwindow.c: In function 'p7_hmmwindow_new':
>p7_hmmwindow.c:55:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     CC p7_null3.o
>     CC p7_pipeline.o
>In file included from p7_null3.c:23:0:
>p7_null3.c: In function 'p7_null3_score':
>p7_null3.c:73:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(freq, sizeof(float) * abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_null3.c:67:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from p7_hmmfile.c:25:0:
>p7_hmmfile.c: In function 'read_bin_string':
>p7_hmmfile.c:2229:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(s,  (sizeof(char) * len));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_pipeline.c: In function 'p7_pipeline_Create':
>p7_pipeline.c:103:16: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int          status;
>                ^~~~~~
>In file included from p7_pipeline.c:17:0:
>p7_pipeline.c: In function 'p7_pli_computeAliScores':
>p7_pipeline.c:930:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( dom->scores_per_pos, sizeof(float) * dom->ad->N );
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_pipeline.c:925:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from p7_pipeline.c:17:0:
>p7_pipeline.c: In function 'p7_Pipeline_LongTarget':
>p7_pipeline.c:1496:58: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pli_tmp->scores, sizeof(float) * om->abc->Kp * 4); //allocation of space to store scores that will be used in p7_oprofile_Update(Fwd|Vit|MSV)EmissionScores
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_pipeline.c:1497:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pli_tmp->fwd_emissions_arr, sizeof(float) *  om->abc->Kp * (om->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC p7_prior.o
>p7_prior.c: In function 'p7_prior_CreateAmino':
>p7_prior.c:44:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>p7_prior.c: In function 'p7_prior_CreateNucleic':
>p7_prior.c:184:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>p7_prior.c: In function 'p7_prior_CreateLaplace':
>p7_prior.c:273:14: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int        status;
>              ^~~~~~
>     CC p7_profile.o
>     CC p7_spensemble.o
>In file included from p7_profile.c:20:0:
>p7_profile.c: In function 'p7_profile_Create':
>p7_profile.c:68:53: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->tsc,       sizeof(float)   * allocM * p7P_NTRANS);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:69:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->rsc,       sizeof(float *) * abc->Kp);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:70:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->rf,        sizeof(char)    * (allocM+2)); /* yes, +2: each is (0)1..M, +trailing \0  */
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:71:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->mm,        sizeof(char)    * (allocM+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:72:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->cs,        sizeof(char)    * (allocM+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:73:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->consensus, sizeof(char)    * (allocM+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:77:62: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->rsc[0], sizeof(float) * abc->Kp * (allocM+1) * p7P_NR);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:56:15: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int         status;
>               ^~~~~~
>In file included from p7_profile.c:20:0:
>p7_profile.c: In function 'p7_profile_Validate':
>p7_profile.c:511:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pstart, sizeof(double) * (gm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_profile.c:507:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from p7_spensemble.c:8:0:
>p7_spensemble.c: In function 'p7_spensemble_Create':
>p7_spensemble.c:60:57: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sp->sp,         sizeof(struct p7_spcoord_s) * sp->nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_spensemble.c:61:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sp->workspace,  sizeof(int)                 * sp->nalloc * 2); /* workspace is 2n */
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_spensemble.c:62:57: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sp->assignment, sizeof(int)                 * sp->nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_spensemble.c:63:57: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sp->epc,        sizeof(int)                 * sp->epc_alloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_spensemble.c:64:57: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sp->sigc,       sizeof(struct p7_spcoord_s) * sp->nsigc_alloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_spensemble.c:47:18: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int            status;
>                  ^~~~~~
>In file included from p7_spensemble.c:8:0:
>p7_spensemble.c: In function 'p7_spensemble_Cluster':
>p7_spensemble.c:307:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ninc, sizeof(int) * sp->nc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_spensemble.c:295:25: warning: 'mmax' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int imax, jmax, kmax, mmax;
>                         ^~~~
>p7_spensemble.c:364:7: warning: 'kmax' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       for (best_k = kmin; best_k <= kmax; best_k++) if (sp->epc[best_k-kmin] >= epc_threshold) break;
>       ^~~
>p7_spensemble.c:295:13: warning: 'jmax' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int imax, jmax, kmax, mmax;
>             ^~~~
>p7_spensemble.c:358:7: warning: 'imax' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       for (best_i = imin; best_i <= imax; best_i++) if (sp->epc[best_i-imin] >= epc_threshold) break;
>       ^~~
>p7_spensemble.c:294:25: warning: 'mmin' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int imin, jmin, kmin, mmin;
>                         ^~~~
>p7_spensemble.c:363:82: warning: 'kmin' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       for (h = 0; h < sp->n; h++) if (sp->assignment[h] == c) sp->epc[sp->sp[h].k-kmin]++;
>                                                                       ~~~~~~~~~~~^~~~~
>p7_spensemble.c:294:13: warning: 'jmin' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int imin, jmin, kmin, mmin;
>             ^~~~
>     CC p7_tophits.o
>In file included from p7_tophits.c:17:0:
>p7_tophits.c: In function 'p7_tophits_Create':
>p7_tophits.c:43:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->hit,   sizeof(P7_HIT *) * default_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_tophits.c:44:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->unsrt, sizeof(P7_HIT)   * default_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_tophits.c:37:15: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int         status;
>               ^~~~~~
>p7_tophits.c: In function 'p7_tophits_Grow':
>p7_tophits.c:78:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from p7_tophits.c:17:0:
>p7_tophits.c: In function 'p7_tophits_Merge':
>p7_tophits.c:419:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (new_hit, sizeof(P7_HIT *)    * Nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC p7_trace.o
>p7_tophits.c: In function 'p7_tophits_Targets':
>p7_tophits.c:1108:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>   for (h = 0; h < th->N; h++)
>   ^~~
>p7_tophits.c:1176:5: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>     if (th->nreported == 0)
>     ^~
>p7_tophits.c: In function 'p7_tophits_Domains':
>p7_tophits.c:1282:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (d = 0; d < th->hit[h]->ndom; d++)
>       ^~~
>p7_tophits.c:1338:11: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>           if (pli->show_alignments)
>           ^~
>In file included from p7_tophits.c:17:0:
>p7_tophits.c: In function 'p7_tophits_Alignment':
>p7_tophits.c:1455:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sqarr, sizeof(ESL_SQ *)   * (ndom + inc_n));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_tophits.c:1456:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(trarr, sizeof(P7_TRACE *) * (ndom + inc_n));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from p7_trace.c:22:0:
>p7_trace.c: In function 'trace_create_engine':
>p7_trace.c:93:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->st, sizeof(char) * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:94:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->k,  sizeof(int)  * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:95:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->i,  sizeof(int)  * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:97:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(tr->pp, sizeof(float) * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:102:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->tfrom,   sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:103:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->tto,     sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:104:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->sqfrom,  sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:105:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->sqto,    sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:106:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->hmmfrom, sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:107:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->hmmto,   sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_trace.c:79:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>In file included from p7_trace.c:22:0:
>p7_trace.c: In function 'p7_trace_SetPP':
>p7_trace.c:933:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (tr->pp == NULL) ESL_ALLOC(tr->pp, sizeof(float) * tr->nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC p7_scoredata.o
>In file included from p7_scoredata.c:18:0:
>p7_scoredata.c: In function 'scoredata_GetSSVScoreArrays':
>p7_scoredata.c:70:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->ssv_scores, (om->M + 1) * K * sizeof(uint8_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:75:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->ssv_scores_f, (om->M + 1) * K * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:76:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(max_scores, (om->M + 1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:89:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->opt_ext_fwd, (om->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:90:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->opt_ext_rev, (om->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:60:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int i, j, status;
>             ^~~~~~
>p7_scoredata.c: In function 'p7_hmm_ScoreDataCreate':
>p7_scoredata.c:180:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from p7_scoredata.c:18:0:
>p7_scoredata.c: In function 'p7_hmm_ScoreDataClone':
>p7_scoredata.c:242:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->ssv_scores, (src->M + 1) * Kp * sizeof(uint8_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:245:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->ssv_scores_f, (src->M + 1) * Kp * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:251:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->prefix_lengths, (src->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:255:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->suffix_lengths, (src->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:259:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->fwd_scores, (src->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:265:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->opt_ext_fwd, (src->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:272:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->opt_ext_rev, (src->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:281:53: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>        ESL_ALLOC(new->fwd_transitions[i], (src->M+1)* sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:224:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from p7_scoredata.c:18:0:
>p7_scoredata.c: In function 'p7_hmm_ScoreDataComputeRest':
>p7_scoredata.c:324:60: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(data->fwd_scores, sizeof(float) *  om->abc->Kp * (om->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:331:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->fwd_transitions[i], sizeof(float) * (om->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:337:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(data->prefix_lengths, (om->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:338:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(data->suffix_lengths, (om->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>p7_scoredata.c:318:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>     CC hmmpgmd2msa.o
>In file included from ./hmmer.h:43:0,
>                 from hmmpgmd2msa.c:14:
>hmmpgmd2msa.c: In function 'hmmpgmd2msa':
>hmmpgmd2msa.c:137:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.unsrt, sizeof(P7_HIT) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:139:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.hit, sizeof(P7_HIT*) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:158:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC( th.hit[i]->dcl, sizeof(P7_DOMAIN) *  th.hit[i]->ndom);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c: In function 'hmmpgmd2stats':
>hmmpgmd2msa.c:321:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( *statsOut,   sizeof(float) * hmm->M * 3);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:324:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( cover,   sizeof(int) * hmm->M);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:325:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( id,      sizeof(int) * hmm->M);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:326:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( similar, sizeof(int) * hmm->M);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:357:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.unsrt, sizeof(P7_HIT) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:359:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.hit, sizeof(P7_HIT*) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmpgmd2msa.c:378:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC( th.hit[i]->dcl, sizeof(P7_DOMAIN) *  th.hit[i]->ndom);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC fm_alphabet.o
>In file included from fm_alphabet.c:5:0:
>fm_alphabet.c: In function 'fm_alphabetCreate':
>fm_alphabet.c:49:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(meta->alph, (1+meta->alph_size)*sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_alphabet.c:53:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(meta->compl_alph, (1+meta->alph_size)*sizeof(int));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_alphabet.c:32:6: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>  int status;
>      ^~~~~~
>     CC fm_general.o
>     CC fm_sse.o
>     CC fm_ssv.o
>fm_sse.c: In function 'fm_configInit':
>fm_sse.c:160:1: warning: label 'ERROR' defined but not used [-Wunused-label]
> ERROR:
> ^~~~~
>fm_sse.c:66:7: warning: unused variable 'trim_chunk_count' [-Wunused-variable]
>   int trim_chunk_count;
>       ^~~~~~~~~~~~~~~~
>fm_sse.c:65:9: warning: unused variable 'j' [-Wunused-variable]
>   int i,j;
>         ^
>fm_sse.c:65:7: warning: unused variable 'i' [-Wunused-variable]
>   int i,j;
>       ^
>fm_sse.c:64:7: warning: unused variable 'status' [-Wunused-variable]
>   int status;
>       ^~~~~~
>fm_sse.c: In function 'fm_getOccCount':
>fm_sse.c:201:13: warning: unused variable 'sb_pos' [-Wunused-variable]
>   const int sb_pos         = (pos+1) / meta->freq_cnt_sb; //floor(pos/sb_size) : the sb count element preceding pos
>             ^~~~~~
>fm_sse.c:200:20: warning: unused variable 'occCnts_sb' [-Wunused-variable]
>   const uint32_t * occCnts_sb = fm->occCnts_sb;
>                    ^~~~~~~~~~
>fm_sse.c:199:20: warning: unused variable 'occCnts_b' [-Wunused-variable]
>   const uint16_t * occCnts_b  = fm->occCnts_b;
>                    ^~~~~~~~~
>fm_sse.c:194:7: warning: unused variable 'i' [-Wunused-variable]
>   int i;
>       ^
>fm_sse.c: In function 'fm_getOccCountLT':
>fm_sse.c:382:9: warning: unused variable 'j' [-Wunused-variable]
>   int i,j;
>         ^
>fm_sse.c: In function 'fm_getOccCount':
>fm_sse.c:352:10: warning: 'cnt' is used uninitialized in this function [-Wuninitialized]
>   return cnt ;
>          ^~~
>In file included from fm_general.c:17:0:
>fm_general.c: In function 'fm_initSeeds':
>fm_general.c:31:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(list->diags, list->size * sizeof(FM_DIAG));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:29:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>fm_general.c: In function 'fm_newSeed':
>fm_general.c:51:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from fm_general.c:17:0:
>fm_general.c: In function 'fm_initAmbiguityList':
>fm_general.c:79:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(list->ranges, list->size * sizeof(FM_INTERVAL));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:75:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>fm_general.c: In function 'fm_addAmbiguityRange':
>fm_general.c:102:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from fm_general.c:17:0:
>fm_general.c: In function 'fm_FM_read':
>fm_general.c:538:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (getAll) ESL_ALLOC (fm->T, sizeof(uint8_t) * compressed_bytes );
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:539:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (fm->BWT_mem,  sizeof(uint8_t) * (compressed_bytes + 31) ); // +31 for manual 16-byte alignment  ( typically only need +15, but this allows offset in memory, plus offset in case of <16 bytes of characters at the end)
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:541:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (getAll) ESL_ALLOC (fm->SA, num_SA_samples * sizeof(uint32_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:542:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (fm->C, (1+meta->alph_size) * sizeof(int64_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:543:68: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (fm->occCnts_b,  num_freq_cnts_b *  (meta->alph_size ) * sizeof(uint16_t)); // every freq_cnt positions, store an array of ints
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:544:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (fm->occCnts_sb,  num_freq_cnts_sb *  (meta->alph_size ) * sizeof(uint32_t)); // every freq_cnt positions, store an array of ints
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:505:13: warning: variable 'occCnts_b' set but not used [-Wunused-but-set-variable]
>   uint16_t *occCnts_b  = NULL;  //convenience variables, used to simplify macro calls
>             ^~~~~~~~~
>fm_general.c:502:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from fm_general.c:17:0:
>fm_general.c: In function 'fm_readFMmeta':
>fm_general.c:625:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (meta->seq_data,  meta->seq_count   * sizeof(FM_SEQDATA));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:642:77: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC (meta->seq_data[i].name,  (1+meta->seq_data[i].name_length)   * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:643:77: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC (meta->seq_data[i].acc,   (1+meta->seq_data[i].acc_length)    * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:644:77: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC (meta->seq_data[i].source,(1+meta->seq_data[i].source_length) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:645:77: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC (meta->seq_data[i].desc,  (1+meta->seq_data[i].desc_length)   * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_general.c:604:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>fm_general.c: In function 'fm_configAlloc':
>fm_general.c:692:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     CC hmmalign.o
>In file included from fm_ssv.c:5:0:
>fm_ssv.c: In function 'FM_getSeeds':
>fm_ssv.c:455:58: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dp_pairs_fwd, ssvdata->M * fm_cfg->max_depth * sizeof(FM_DP_PAIR)); // guaranteed to be enough to hold all diagonals
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_ssv.c:456:58: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dp_pairs_rev, ssvdata->M * fm_cfg->max_depth * sizeof(FM_DP_PAIR));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_ssv.c:448:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>fm_ssv.c: In function 'FM_window_from_diag':
>fm_ssv.c:608:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from fm_ssv.c:5:0:
>fm_ssv.c: In function 'p7_SSVFM_longlarget':
>fm_ssv.c:758:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(consensus, (om->M+1)*sizeof(uint8_t) );
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC hmmbuild.o
>In file included from hmmalign.c:10:0:
>hmmalign.c: In function 'map_alignment':
>hmmalign.c:252:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq, sizeof(ESL_SQ *)   * msa->nseq);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmalign.c:253:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr, sizeof(P7_TRACE *) * msa->nseq);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmalign.c:254:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matassign, sizeof(int) * (msa->alen + 1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from hmmbuild.c:13:0:
>hmmbuild.c: In function 'usual_master':
>hmmbuild.c:542:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * infocnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>fm_ssv.c:698:31: warning: 'max_hit_end' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   diag->length  = max_hit_end - max_hit_start + 1;
>                   ~~~~~~~~~~~~^~~~~~~~~~~~~~~
>fm_ssv.c:649:37: note: 'max_hit_end' was declared here
>   int64_t hit_start, max_hit_start, max_hit_end;
>                                     ^~~~~~~~~~~
>fm_ssv.c:697:32: warning: 'max_hit_start' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   diag->k       = model_start  + max_hit_start - 1;
>                   ~~~~~~~~~~~~~^~~~~~~~~~~~~~~
>fm_ssv.c:649:22: note: 'max_hit_start' was declared here
>   int64_t hit_start, max_hit_start, max_hit_end;
>                      ^~~~~~~~~~~~~
>     CC hmmconvert.o
>     CC hmmemit.o
>     CC hmmfetch.o
>     CC hmmpress.o
>hmmemit.c: In function 'emit_alignment':
>hmmemit.c:215:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>   for (i = 0; i < N; i++) p7_trace_Destroy(tr[i]);  free(tr);
>   ^~~
>hmmemit.c:215:53: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>   for (i = 0; i < N; i++) p7_trace_Destroy(tr[i]);  free(tr);
>                                                     ^~~~
>hmmemit.c:216:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>   for (i = 0; i < N; i++) esl_sq_Destroy(sq[i]);    free(sq);
>   ^~~
>hmmemit.c:216:53: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>   for (i = 0; i < N; i++) esl_sq_Destroy(sq[i]);    free(sq);
>                                                     ^~~~
>     CC hmmscan.o
>     CC hmmsearch.o
>     CC hmmsim.o
>In file included from hmmscan.c:14:0:
>hmmscan.c: In function 'serial_master':
>hmmscan.c:422:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * infocnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from hmmsearch.c:14:0:
>hmmsearch.c: In function 'serial_master':
>hmmsearch.c:440:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * infocnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from hmmsim.c:17:0:
>hmmsim.c: In function 'process_workunit':
>hmmsim.c:672:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC hmmstat.o
>hmmsim.c: In function 'main':
>hmmsim.c:851:45: warning: 'lambda' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    fprintf(cfg->efp, "%d %g\n", i, cfg->N * esl_exp_surv(x, pmu, plambda));
>                                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>hmmsim.c:363:19: note: 'lambda' was declared here
>   double      mu, lambda;
>                   ^~~~~~
>hmmsim.c:851:45: warning: 'mu' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    fprintf(cfg->efp, "%d %g\n", i, cfg->N * esl_exp_surv(x, pmu, plambda));
>                                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>hmmsim.c:363:15: note: 'mu' was declared here
>   double      mu, lambda;
>               ^~
>hmmstat.c: In function 'main':
>hmmstat.c:165:5: warning: 's_val' may be used uninitialized in this function [-Wmaybe-uninitialized]
>     printf (" %6s %6.2f", "E-val for", s_val);
>     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>hmmstat.c:229:37: warning: 'e_val' may be used uninitialized in this function [-Wmaybe-uninitialized]
>         sc = esl_exp_invsurv( e_val / nseq ,  hmm->evparam[p7_FTAU],  hmm->evparam[p7_FLAMBDA]);
>                               ~~~~~~^~~~~~
>     CC phmmer.o
>     CC jackhmmer.o
>In file included from phmmer.c:9:0:
>phmmer.c: In function 'serial_master':
>phmmer.c:519:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * infocnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>In file included from jackhmmer.c:9:0:
>jackhmmer.c: In function 'serial_master':
>jackhmmer.c:523:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * infocnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC nhmmer.o
>     CC nhmmscan.o
>In file included from nhmmer.c:9:0:
>nhmmer.c: In function 'serial_master':
>nhmmer.c:713:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * infocnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>nhmmer.c:502:20: warning: unused variable 'fminfo' [-Wunused-variable]
>   FM_THREAD_INFO  *fminfo   = NULL;
>                    ^~~~~~
>nhmmer.c: In function 'serial_loop':
>nhmmer.c:1223:7: warning: variable 'prev_hit_cnt' set but not used [-Wunused-but-set-variable]
>   int prev_hit_cnt;
>       ^~~~~~~~~~~~
>nhmmer.c: In function 'pipeline_thread':
>nhmmer.c:1435:7: warning: variable 'prev_hit_cnt' set but not used [-Wunused-but-set-variable]
>   int prev_hit_cnt;
>       ^~~~~~~~~~~~
>In file included from nhmmer.c:9:0:
>nhmmer.c: In function 'init_id_length':
>nhmmer.c:1635:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (list->id_lengths, size * sizeof(ID_LENGTH));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>nhmmer.c:1627:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from nhmmscan.c:9:0:
>nhmmscan.c: In function 'serial_master':
>nhmmscan.c:420:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(info, sizeof(*info) * infocnt);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>nhmmscan.c:434:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(info[i].scores, sizeof(float) * abc->Kp * 16); //allocation of space to store scores that will be used in p7_oprofile_Update(Fwd|Vit|MSV)EmissionScores
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>nhmmscan.c: In function 'serial_loop':
>nhmmscan.c:671:9: warning: implicit declaration of function 'p7_oprofile_UpdateVitEmissionScores'; did you mean 'p7_oprofile_UpdateFwdEmissionScores'? [-Wimplicit-function-declaration]
>         p7_oprofile_UpdateVitEmissionScores(om, info->bg, info->fwd_emissions, info->scores);
>         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>         p7_oprofile_UpdateFwdEmissionScores
>nhmmscan.c:672:9: warning: implicit declaration of function 'p7_oprofile_UpdateMSVEmissionScores'; did you mean 'p7_oprofile_UpdateFwdEmissionScores'? [-Wimplicit-function-declaration]
>         p7_oprofile_UpdateMSVEmissionScores(om, info->bg, info->fwd_emissions, info->scores);
>         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>         p7_oprofile_UpdateFwdEmissionScores
>nhmmer.c: In function 'main':
>nhmmer.c:1282:20: warning: 'dbsq_revcmp' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (dbsq_revcmp) esl_sq_Destroy(dbsq_revcmp);
>                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~
>nhmmer.c:1227:13: note: 'dbsq_revcmp' was declared here
>   ESL_SQ   *dbsq_revcmp;
>             ^~~~~~~~~~~
>     CC hmmpgmd.o
>     CC hmmc2.o
>     CC makehmmerdb.o
>hmmc2.c: In function 'main':
>hmmc2.c:574:9: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>         if (scores) p7_tophits_Targets(stdout, th, pli, 120); fprintf(stdout, "\n\n");
>         ^~
>hmmc2.c:574:63: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>         if (scores) p7_tophits_Targets(stdout, th, pli, 120); fprintf(stdout, "\n\n");
>                                                               ^~~~~~~
>hmmc2.c:575:9: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>         if (ali)    p7_tophits_Domains(stdout, th, pli, 120); fprintf(stdout, "\n\n");
>         ^~
>hmmc2.c:575:63: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>         if (ali)    p7_tophits_Domains(stdout, th, pli, 120); fprintf(stdout, "\n\n");
>                                                               ^~~~~~~
>In file included from makehmmerdb.c:3:0:
>makehmmerdb.c: In function 'allocateSeqdata':
>makehmmerdb.c:136:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (meta->seq_data[numseqs].name, (1+length) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:140:54: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (meta->seq_data[numseqs].acc, (1+length) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:144:57: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (meta->seq_data[numseqs].source, (1+length) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:148:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (meta->seq_data[numseqs].desc, (1+length) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c: In function 'buildAndWriteFMIndex':
>makehmmerdb.c:191:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC (Tcompressed, compressed_bytes * sizeof(uint8_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c: In function 'main':
>makehmmerdb.c:462:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (meta->seq_data, allocedseqs * sizeof(FM_SEQDATA));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:554:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (T, max_block_size * sizeof(uint8_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:555:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (BWT, max_block_size * sizeof(uint8_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:556:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (SA, max_block_size * sizeof(int));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:557:75: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (SAsamp,     (1+floor((double)max_block_size/meta->freq_SA) ) * sizeof(uint32_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC hmmerfm-exactmatch.o
>makehmmerdb.c:559:96: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (occCnts_sb, (1+ceil((double)max_block_size/meta->freq_cnt_sb)) *  meta->alph_size * sizeof(uint32_t)); // every freq_cnt_sb positions, store an array of ints
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:560:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (cnts_sb,    meta->alph_size * sizeof(uint32_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:561:96: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (occCnts_b,  ( 1+ceil((double)max_block_size/meta->freq_cnt_b)) *  meta->alph_size * sizeof(uint16_t)); // every freq_cnt_b positions, store an array of 8-byte ints
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:562:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (cnts_b,     meta->alph_size * sizeof(uint16_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>makehmmerdb.c:428:12: warning: variable 'prev_numseqs' set but not used [-Wunused-but-set-variable]
>   uint32_t prev_numseqs = 0;
>            ^~~~~~~~~~~~
>In file included from hmmerfm-exactmatch.c:6:0:
>hmmerfm-exactmatch.c: In function 'main':
>hmmerfm-exactmatch.c:288:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fmsf, meta->block_count * sizeof(FM_DATA) );
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmerfm-exactmatch.c:290:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(fmsb, meta->block_count * sizeof(FM_DATA) );
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>hmmerfm-exactmatch.c:320:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hits, hits_size * sizeof(FM_HIT));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     AR libhmmer-src.stamp
>makehmmerdb.c:866:6: warning: 'ambig_list.ranges' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (ambig_list.ranges) free(ambig_list.ranges);
>      ^
>     SUBDIR impl_dummy
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>     CC decoding.o
>     CC fwdback.o
>     CC io.o
>In file included from io.c:35:0:
>io.c: In function 'p7_oprofile_CreateBlock':
>io.c:477:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(block->list, sizeof(P7_OPROFILE *) * count);
>../../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>io.c:469:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status = eslOK;
>       ^~~~~~
>     CC msvfilter.o
>     CC null2.o
>     CC optacc.o
>     CC stotrace.o
>     CC vitfilter.o
>     CC p7_omx.o
>     CC p7_oprofile.o
>     CC mpi.o
>p7_oprofile.c: In function 'p7_oprofile_UpdateFwdEmissionScores':
>p7_oprofile.c:428:11: warning: unused variable 'M' [-Wunused-variable]
>   int     M   = om->M;    /* length of the query                                          */
>           ^
>     AR libhmmer-impl.stamp
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>     GEN alimask
>     GEN hmmalign
>     GEN hmmbuild
>     GEN hmmconvert
>     GEN hmmemit
>     GEN hmmfetch
>     GEN hmmlogo
>     GEN hmmpress
>     GEN hmmscan
>     GEN hmmsearch
>     GEN hmmsim
>     GEN hmmstat
>     GEN jackhmmer
>     GEN phmmer
>     GEN nhmmer
>     GEN nhmmscan
>     GEN hmmpgmd
>     GEN hmmc2
>     GEN makehmmerdb
>     GEN hmmerfm-exactmatch
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/src'
>     SUBDIR profmark
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/profmark'
>     CC create-profmark.o
>     CC rocplot.o
>In file included from rocplot.c:54:0:
>rocplot.c: In function 'create_plot':
>rocplot.c:410:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(plot->tp, sizeof(double) * plot->nxpts);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>rocplot.c:398:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from create-profmark.c:21:0:
>create-profmark.c: In function 'remove_fragments':
>create-profmark.c:334:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>create-profmark.c:327:12: warning: variable 'nfrags' set but not used [-Wunused-but-set-variable]
>   int      nfrags;
>            ^~~~~~
>In file included from create-profmark.c:21:0:
>create-profmark.c: In function 'separate_sets':
>create-profmark.c:371:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>create-profmark.c:365:8: warning: variable 'ntrain' set but not used [-Wunused-but-set-variable]
>   int  ntrain;   /* number of seqs in the training alignment */
>        ^~~~~~
>     GEN rocplot
>     GEN create-profmark
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/profmark'
>+ exit 0
>Executing(%install): /bin/sh -e /var/tmp/rpm-tmp.aouftC
>+ umask 022
>+ cd /builddir/build/BUILD
>+ '[' /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64 '!=' / ']'
>+ rm -rf /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64
>++ dirname /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64
>+ mkdir -p /builddir/build/BUILDROOT
>+ mkdir /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64
>+ cd hmmer-3.1b2
>+ rm -rf /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64
>+ make install DESTDIR=/builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64
>/usr/bin/install -c -d /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin
>/usr/bin/install -c -d /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/lib64
>/usr/bin/install -c -d /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/include
>/usr/bin/install -c -d /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/share/man/man1
>/usr/bin/install -c -d /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/share/doc/hmmer
>     SUBDIR src
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/src'
>     SUBDIR impl_dummy
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>for file in impl_dummy.h; do \
>   /usr/bin/install -c -m 0644 ./$file /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/include/ ;\
>done
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>for file in alimask hmmalign hmmbuild hmmconvert hmmemit hmmfetch hmmlogo hmmpress hmmscan hmmsearch hmmsim hmmstat jackhmmer phmmer nhmmer nhmmscan hmmpgmd hmmc2 makehmmerdb hmmerfm-exactmatch; do \
>   /usr/bin/install -c -m 0755 $file /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/ ;\
>done
>/usr/bin/install -c -m 0755 libhmmer.a /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/lib64/
>for file in hmmer.h cachedb.h p7_gbands.h p7_gmxb.h p7_gmxchk.h p7_hmmcache.h; do \
>   /usr/bin/install -c -m 0644 ./$file /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/include/ ;\
>done
>/usr/bin/install -c -m 0644 p7_config.h /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/include/ ;\
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/src'
>     SUBDIR documentation
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/documentation'
>     SUBDIR man
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/documentation/man'
>for file in hmmer hmmalign hmmbuild hmmconvert hmmemit hmmfetch hmmlogo hmmpgmd hmmpress hmmscan hmmsearch hmmsim hmmstat jackhmmer makehmmerdb phmmer nhmmer nhmmscan alimask; do \
>   /usr/bin/install -c -m 0755 ./$file.man /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/share/man/man1/${file}.1 ;\
>done
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/documentation/man'
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/documentation'
>+ /usr/lib/rpm/find-debuginfo.sh --strict-build-id -m --run-dwz --dwz-low-mem-die-limit 10000000 --dwz-max-die-limit 50000000 /builddir/build/BUILD/hmmer-3.1b2
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmconvert
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmemit
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/jackhmmer
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmalign
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmstat
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmsim
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmlogo
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/nhmmer
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/makehmmerdb
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/nhmmscan
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmc2
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/phmmer
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmbuild
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmpress
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmsearch
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/alimask
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmerfm-exactmatch
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmscan
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmpgmd
>extracting debug info from /builddir/build/BUILDROOT/hmmer-3.1b2-5.fc26.ppc64/usr/bin/hmmfetch
>/usr/lib/rpm/sepdebugcrcfix: Updated 20 CRC32s, 0 CRC32s did match.
>9904 blocks
>+ /usr/lib/rpm/check-buildroot
>+ /usr/lib/rpm/brp-compress
>+ /usr/lib/rpm/brp-strip-static-archive /usr/bin/strip
>+ /usr/lib/rpm/brp-python-bytecompile /usr/bin/python 1
>+ /usr/lib/rpm/brp-python-hardlink
>Executing(%check): /bin/sh -e /var/tmp/rpm-tmp.qRCWW4
>+ umask 022
>+ cd /builddir/build/BUILD
>+ cd hmmer-3.1b2
>+ make check
>     SUBDIR easel
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/easel'
>     GEN easel_utest
>In file included from ./easel.c:39:0:
>./easel.c: In function 'esl_strdup':
>./easel.c:579:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(new, sizeof(char) * (n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./easel.c: In function 'esl_vsprintf':
>./easel.c:974:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (n1+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./easel.c: In function 'esl_str_IsInteger':
>./easel.c:1178:9: warning: variable 'val' set but not used [-Wunused-but-set-variable]
>   long  val;
>         ^~~
>In file included from ./easel.c:39:0:
>./easel.c: In function 'esl_FileTail':
>./easel.c:1320:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tail, sizeof(char) * (strlen(path)+1)); /* a little overkill */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./easel.c: In function 'esl_FileConcat':
>./easel.c:1413:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(path, sizeof(char) * (nd+nf+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./easel.c: In function 'esl_FileNewSuffix':
>./easel.c:1469:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(new, sizeof(char) * (nf+strlen(sfx)+2)); /* '.' too */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./easel.c: In function 'esl_FileEnvOpen':
>./easel.c:1543:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(path, sizeof(char) * np);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./easel.c: In function 'esl_getcwd':
>./easel.c:1771:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(cwd, sizeof(char) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_alphabet_utest
>./esl_alphabet.c: In function 'esl_alphabet_Create':
>./esl_alphabet.c:54:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>In file included from ./esl_alphabet.c:21:0:
>./esl_alphabet.c: In function 'esl_alphabet_CreateCustom':
>./esl_alphabet.c:124:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->sym,    sizeof(char)   * (Kp+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c:125:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->degen,  sizeof(char *) * Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c:126:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->ndegen, sizeof(int)    * Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c:131:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->degen[0], sizeof(char) * (Kp*K));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c:107:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>In file included from ./esl_alphabet.c:21:0:
>./esl_alphabet.c: In function 'set_complementarity':
>./esl_alphabet.c:360:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(a->complement, sizeof(ESL_DSQ) * a->Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'esl_abc_CreateDsq':
>./esl_alphabet.c:634:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'esl_abc_dsqdup':
>./esl_alphabet.c:824:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(new, sizeof(ESL_DSQ) * (L+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'esl_abc_dsqcat':
>./esl_alphabet.c:925:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(*dsq, sizeof(ESL_DSQ)     * (n+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'utest_Digitize':
>./esl_alphabet.c:1938:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (strlen(goodseq)+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'utest_Textize':
>./esl_alphabet.c:1969:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(newseq, sizeof(char) * (L+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'utest_TextizeN':
>./esl_alphabet.c:1992:17: warning: variable 'L' set but not used [-Wunused-but-set-variable]
>   int           L;
>                 ^
>In file included from ./esl_alphabet.c:21:0:
>./esl_alphabet.c: In function 'utest_FCount':
>./esl_alphabet.c:2213:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(vec, sizeof(float) * (a->K+1)); /* include gap char for this test */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'utest_DCount':
>./esl_alphabet.c:2247:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(vec, sizeof(double) * (a->K+1)); /* include gap char for this test */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_alphabet.c: In function 'esl_alphabet_CreateCustom':
>./esl_alphabet.c:171:3: warning: 'a' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   esl_alphabet_Destroy(a);
>   ^~~~~~~~~~~~~~~~~~~~~~~
>     GEN esl_buffer_utest
>In file included from ./esl_buffer.c:37:0:
>./esl_buffer.c: In function 'esl_buffer_OpenPipe':
>./esl_buffer.c:348:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * bf->pagesize);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'esl_buffer_OpenStream':
>./esl_buffer.c:478:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * bf->pagesize);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'esl_buffer_FetchLine':
>./esl_buffer.c:1082:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(p, sizeof(char) * nc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'esl_buffer_FetchLineAsStr':
>./esl_buffer.c:1148:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (nc+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'esl_buffer_FetchToken':
>./esl_buffer.c:1345:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tok, sizeof(char) * nc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'esl_buffer_FetchTokenAsStr':
>./esl_buffer.c:1428:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tok, sizeof(char) * (nc+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'buffer_init_file_slurped':
>./esl_buffer.c:1603:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * filesize);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'buffer_init_file_basic':
>./esl_buffer.c:1626:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bf->mem, sizeof(char) * bf->pagesize);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_buffer.c: In function 'main':
>./esl_buffer.c:2393:3: warning: 'testline2' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   utest_compare_line(p, n, testline2);
>   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>./esl_buffer.c:2306:25: note: 'testline2' was declared here
>   int         thisline, testline2;
>                         ^~~~~~~~~
>./esl_buffer.c:2391:7: warning: 'testoffset2' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (esl_buffer_SetOffset(bf, testoffset2) != eslOK) esl_fatal(msg);
>       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>./esl_buffer.c:2304:40: note: 'testoffset2' was declared here
>   esl_pos_t   thisoffset, testoffset1, testoffset2;
>                                        ^~~~~~~~~~~
>./esl_buffer.c:2395:7: warning: 'testoffset1' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (esl_buffer_SetOffset(bf, testoffset1) != eslOK) esl_fatal(msg);
>       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>./esl_buffer.c:2304:27: note: 'testoffset1' was declared here
>   esl_pos_t   thisoffset, testoffset1, testoffset2;
>                           ^~~~~~~~~~~
>     GEN esl_cluster_utest
>     GEN esl_dirichlet_utest
>In file included from ./esl_dirichlet.c:21:0:
>./esl_dirichlet.c: In function 'esl_mixdchlet_Create':
>./esl_dirichlet.c:60:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pri->pq,    sizeof(double)   * N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c:61:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pri->alpha, sizeof(double *) * N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c:64:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pri->alpha[0], sizeof(double) * N * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c:52:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_dirichlet.c:21:0:
>./esl_dirichlet.c: In function 'esl_mixdchlet_Compare':
>./esl_dirichlet.c:181:22: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A, d1->N * sizeof(int*));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c:183:27: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(A[i], d1->N * sizeof(int) );
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c: In function 'esl_dirichlet_LogProbData_Mixture':
>./esl_dirichlet.c:512:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mixq, sizeof(double)*d->N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c: In function 'esl_mixdchlet_Fit':
>./esl_dirichlet.c:857:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * np);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c:858:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(u,   sizeof(double) * np);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c:859:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(wrk, sizeof(double) * np * 4);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dirichlet.c: In function 'esl_mixdchlet_Fit_Multipass':
>./esl_dirichlet.c:986:10: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   return status;
>          ^~~~~~
>     GEN esl_distance_utest
>In file included from ./esl_distance.c:22:0:
>./esl_distance.c: In function 'main':
>./esl_distance.c:1263:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(as, sizeof(char *) * N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_distance.c:1265:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(as[i], sizeof(char) * (L+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_distance.c:1277:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ax, sizeof(ESL_DSQ *) * N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_distance.c:1228:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>./esl_distance.c: In function 'esl_dst_CPairIdMx':
>./esl_distance.c:354:7: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int status;
>       ^~~~~~
>./esl_distance.c: In function 'esl_dst_CJukesCantorMx':
>./esl_distance.c:467:16: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int          status;
>                ^~~~~~
>./esl_distance.c: In function 'esl_dst_XPairIdMx':
>./esl_distance.c:539:7: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int status;
>       ^~~~~~
>./esl_distance.c: In function 'esl_dst_XJukesCantorMx':
>./esl_distance.c:653:16: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int          status;
>                ^~~~~~
>     GEN esl_dmatrix_utest
>In file included from ./esl_dmatrix.c:30:0:
>./esl_dmatrix.c: In function 'esl_dmatrix_Create':
>./esl_dmatrix.c:64:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A->mx, sizeof(double *) * n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dmatrix.c:67:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A->mx[0], sizeof(double) * n * m);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dmatrix.c:57:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_dmatrix.c:30:0:
>./esl_dmatrix.c: In function 'esl_dmatrix_CreateUpper':
>./esl_dmatrix.c:113:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(A->mx, sizeof(double *) * n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dmatrix.c:101:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_dmatrix.c:30:0:
>./esl_dmatrix.c: In function 'esl_permutation_Create':
>./esl_dmatrix.c:454:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(P->pi, sizeof(int) * n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dmatrix.c:448:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>./esl_dmatrix.c: In function 'esl_dmx_AddScale':
>./esl_dmatrix.c:893:15: warning: self-comparison always evaluates to false [-Wtautological-compare]
>   if (A->type != A->type) ESL_EXCEPTION(eslEINVAL, "matrices of different type");
>               ^~
>In file included from ./esl_dmatrix.c:30:0:
>./esl_dmatrix.c: In function 'esl_dmx_Invert':
>./esl_dmatrix.c:1087:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b, sizeof(double) * A->n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dmatrix.c:1088:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(y, sizeof(double) * A->n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_dmatrix.c: In function 'esl_dmx_LUP_decompose':
>./esl_dmatrix.c:976:37: warning: 'kpiv' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       j = P->pi[k]; P->pi[k] = P->pi[kpiv]; P->pi[kpiv] = j;
>                                     ^
>     GEN esl_exponential_utest
>     GEN esl_fileparser_utest
>./esl_fileparser.c: In function 'esl_fileparser_Create':
>./esl_fileparser.c:103:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     GEN esl_gamma_utest
>     GEN esl_getopts_utest
>In file included from ./esl_getopts.c:22:0:
>./esl_getopts.c: In function 'esl_getopts_Create':
>./esl_getopts.c:109:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(g->val,    sizeof(char *) * g->nopts);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_getopts.c:110:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(g->setby,  sizeof(int)    * g->nopts);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_getopts.c:111:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(g->valloc, sizeof(int)    * g->nopts);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_getopts.c:65:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_getopts.c:22:0:
>./esl_getopts.c: In function 'esl_opt_SpoofCmdline':
>./esl_getopts.c:736:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cmdline, sizeof(char) * (ntot+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_getopts.c: In function 'set_option':
>./esl_getopts.c:1218:77: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>        if (g->valloc[opti] == 0) ESL_ALLOC (g->val[opti],      sizeof(char) * (arglen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_getopts.c: In function 'esl_opt_ProcessCmdline':
>./esl_getopts.c:1393:9: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int   opti;  /* option number found                               */
>         ^~~~
>In file included from ./esl_getopts.c:22:0:
>./esl_getopts.c: In function 'esl_opt_VerifyConfig':
>./esl_getopts.c:648:39: warning: '%.24s' directive output may be truncated writing up to 24 bytes into a region of size between 21 and 54 [-Wformat-truncation=]
>       ESL_FAIL(eslESYNTAX, g->errbuf, "Option %.24s (set by cfg file %d) requires (or has no effect without) option(s) %.24s",
>                                       ^
>./easel.h:57:57: note: in definition of macro 'ESL_FAIL'
>     if (errbuf != NULL) snprintf(errbuf, eslERRBUFSIZE, __VA_ARGS__); \
>                                                         ^~~~~~~~~~~
>In file included from /usr/include/stdio.h:939:0,
>                 from ./esl_getopts.c:18:
>/usr/include/bits/stdio2.h:64:10: note: '__builtin___snprintf_chk' output between 75 and 132 bytes into a destination of size 128
>   return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1,
>          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>        __bos (__s), __fmt, __va_arg_pack ());
>        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>./esl_getopts.c: In function 'esl_opt_IsDefault':
>./esl_getopts.c:789:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>./esl_getopts.c: In function 'esl_opt_IsOn':
>./esl_getopts.c:821:8: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    int opti;
>        ^~~~
>./esl_getopts.c: In function 'esl_opt_IsUsed':
>./esl_getopts.c:849:13: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (g->val[opti] == NULL)          return FALSE;
>             ^
>./esl_getopts.c: In function 'esl_opt_GetSetter':
>./esl_getopts.c:869:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>./esl_getopts.c: In function 'esl_opt_GetBoolean':
>./esl_getopts.c:885:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>./esl_getopts.c: In function 'esl_opt_GetInteger':
>./esl_getopts.c:905:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>./esl_getopts.c: In function 'esl_opt_GetReal':
>./esl_getopts.c:923:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>./esl_getopts.c: In function 'esl_opt_GetChar':
>./esl_getopts.c:942:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>./esl_getopts.c: In function 'esl_opt_GetString':
>./esl_getopts.c:965:7: warning: 'opti' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int opti;
>       ^~~~
>     GEN esl_gumbel_utest
>In file included from ./esl_gumbel.c:27:0:
>./esl_gumbel.c: In function 'main':
>./esl_gumbel.c:1111:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(x, sizeof(double) * totalN);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_histogram_utest
>In file included from ./esl_histogram.c:19:0:
>./esl_histogram.c: In function 'esl_histogram_Create':
>./esl_histogram.c:111:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->obs, sizeof(uint64_t) * h->nb);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_histogram.c:74:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_histogram.c:19:0:
>./esl_histogram.c: In function 'esl_histogram_CreateFull':
>./esl_histogram.c:139:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->x, sizeof(double) * h->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_histogram.c:133:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_histogram.c:19:0:
>./esl_histogram.c: In function 'esl_histogram_SetExpect':
>./esl_histogram.c:758:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(h->expect, sizeof(double) * h->nb);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_histogram.c: In function 'esl_histogram_SetExpectedTail':
>./esl_histogram.c:814:63: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (h->expect == NULL)  ESL_ALLOC(h->expect, sizeof(double) * h->nb);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_histogram.c: In function 'esl_histogram_Goodness':
>./esl_histogram.c:1262:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(obs,  sizeof(uint64_t) * (nb*2+1)); /* final nb must be <= 2*nb+1 */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_histogram.c:1263:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(exp,  sizeof(double)   * (nb*2+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_histogram.c:1264:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(topx, sizeof(double)   * (nb*2+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_histogram.c: In function 'main':
>./esl_histogram.c:1706:6: warning: 'fstrategy' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (fstrategy != FIT_TAIL && fabs(avg_ep[0] - p[0]) > 0.1)
>      ^
>./esl_histogram.c:1602:46: warning: 'bstrategy' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       else if (cstrategy == COLLECT_CENSORED &&
>                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~
>         bstrategy == FIT_SAMPLES &&
>         ~~~~~~~~~~~~~~~~~~~~~~~~              
>./esl_histogram.c:1640:7: warning: 'cstrategy' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    if (cstrategy == COLLECT_CENSORED)
>       ^
>     GEN esl_hyperexp_utest
>In file included from ./esl_hyperexp.c:9:0:
>./esl_hyperexp.c: In function 'esl_hyperexp_Create':
>./esl_hyperexp.c:61:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->q,         sizeof(double) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:62:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->lambda,    sizeof(double) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:63:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->wrk,       sizeof(double) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:64:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->fixlambda, sizeof(char)   * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:51:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>In file included from ./esl_hyperexp.c:9:0:
>./esl_hyperexp.c: In function 'esl_hxp_FitComplete':
>./esl_hyperexp.c:867:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * np);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:868:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(u,   sizeof(double) * np);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:869:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(wrk, sizeof(double) * np * 4);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c: In function 'esl_hxp_FitCompleteBinned':
>./esl_hyperexp.c:1095:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * np);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:1096:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(u,   sizeof(double) * np);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_hyperexp.c:1097:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(wrk, sizeof(double) * np * 4);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_keyhash_utest
>In file included from ./esl_keyhash.c:22:0:
>./esl_keyhash.c: In function 'keyhash_create':
>./esl_keyhash.c:381:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->hashtable, sizeof(int) * kh->hashsize);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_keyhash.c:384:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->key_offset, sizeof(int) * kh->kalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_keyhash.c:385:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->nxt,        sizeof(int) * kh->kalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_keyhash.c:388:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(kh->smem,   sizeof(char) * kh->salloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_keyhash.c:369:8: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int  status;
>        ^~~~~~
>./esl_keyhash.c: In function 'key_upsize':
>./esl_keyhash.c:460:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>     GEN esl_mem_utest
>In file included from ./esl_mem.c:23:0:
>./esl_mem.c: In function 'esl_memstrdup':
>./esl_mem.c:392:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_mem.c: In function 'esl_memtod':
>./esl_mem.c:451:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(bigbuf, sizeof(char) * (n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_mem.c: In function 'esl_memtof':
>./esl_mem.c:492:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(bigbuf, sizeof(char) * (n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_msa_utest
>In file included from ./esl_msa.c:30:0:
>./esl_msa.c: In function 'esl_msa_Create':
>./esl_msa.c:107:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->aseq,   sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:114:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->aseq[i], sizeof(char) * (alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:100:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from ./esl_msa.c:30:0:
>./esl_msa.c: In function 'esl_msa_Copy':
>./esl_msa.c:309:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->sqacc, sizeof(char **) * new->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:314:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->sqdesc, sizeof(char **) * new->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:319:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->ss, sizeof(char **) * new->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:324:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->sa, sizeof(char **) * msa->nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:329:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->pp, sizeof(char **) * msa->nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:340:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->comment, sizeof(char **) * msa->ncomment);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:348:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gf_tag, sizeof(char **) * msa->ngf);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:349:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gf,     sizeof(char **) * msa->ngf);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:359:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gs_tag, sizeof(char **)  * msa->ngs);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:360:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gs,     sizeof(char ***) * msa->ngs);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:363:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(new->gs[i], sizeof(char **) * msa->nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:371:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gc_tag, sizeof(char **) * msa->ngc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:372:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gc,     sizeof(char **) * msa->ngc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:381:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gr_tag, sizeof(char **)  * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:382:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->gr,     sizeof(char ***) * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:385:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(new->gr[i], sizeof(char **) * msa->nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'msa_create_mostly':
>./esl_msa.c:622:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqname, sizeof(char *) * nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:623:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->wgt,    sizeof(double) * nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:624:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqlen,  sizeof(int64_t)* nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:542:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from ./esl_msa.c:30:0:
>./esl_msa.c: In function 'esl_msa_CreateDigital':
>./esl_msa.c:784:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->ax,   sizeof(ESL_DSQ *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:791:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->ax[i], sizeof(ESL_DSQ) * (alen+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:777:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from ./esl_msa.c:30:0:
>./esl_msa.c: In function 'esl_msa_Digitize':
>./esl_msa.c:858:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->ax, msa->sqalloc * sizeof(ESL_DSQ *));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:861:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->ax[i], (msa->alen+2) * sizeof(ESL_DSQ));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_Textize':
>./esl_msa.c:913:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->aseq, msa->sqalloc * sizeof(char *));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:916:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->aseq[i], (msa->alen+1) * sizeof(char));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_SetSeqAccession':
>./esl_msa.c:1162:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqacc, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_SetSeqDescription':
>./esl_msa.c:1214:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqdesc, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_FormatSeqAccession':
>./esl_msa.c:1437:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqacc, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_FormatSeqDescription':
>./esl_msa.c:1478:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sqdesc, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_AddGS':
>./esl_msa.c:1621:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->gs[0],  sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:1644:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(msa->gs[tagidx], sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_AppendGR':
>./esl_msa.c:1795:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->gr[0],  sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:1815:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(msa->gr[msa->ngr], sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'msa_set_seq_ss':
>./esl_msa.c:1892:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->ss, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'msa_set_seq_sa':
>./esl_msa.c:1919:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->sa, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'msa_set_seq_pp':
>./esl_msa.c:1946:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(msa->pp, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_ReasonableRF':
>./esl_msa.c:2032:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(counts, msa->abc->K * sizeof(float));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_MinimGaps':
>./esl_msa.c:2419:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is just to deal w/ alen=0 special case */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_MinimGapsText':
>./esl_msa.c:2496:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is just to deal w/ alen=0 special case */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_NoGaps':
>./esl_msa.c:2566:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is only to deal with alen=0 special case */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_NoGapsText':
>./esl_msa.c:2629:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * (msa->alen+1)); /* +1 is only to deal with alen=0 special case */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c: In function 'esl_msa_RemoveBrokenBasepairsFromSS':
>./esl_msa.c:2806:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct,          sizeof(int)  * (len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msa.c:2807:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss_nopseudo, sizeof(char) * (len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>At top level:
>./esl_msa.c:2879:1: warning: 'msa_get_rlen' defined but not used [-Wunused-function]
> msa_get_rlen(const ESL_MSA *msa, int seqidx)
> ^~~~~~~~~~~~
>./esl_msa.c: In function 'esl_msa_ReasonableRF':
>./esl_msa.c:2041:9: warning: 'counts' may be used uninitialized in this function [-Wmaybe-uninitialized]
>         esl_vec_FSet(counts, msa->abc->K, 0.0);
>         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>     GEN esl_msacluster_utest
>In file included from ./esl_msacluster.c:23:0:
>./esl_msacluster.c: In function 'esl_msacluster_SingleLinkage':
>./esl_msacluster.c:135:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(workspace,  sizeof(int) * msa->nseq * 2);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msacluster.c:136:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(assignment, sizeof(int) * msa->nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msacluster.c:155:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(nin, sizeof(int) * nc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_msafile_utest
>     GEN esl_msafile2_utest
>In file included from ./esl_alphabet.h:7:0,
>                 from ./esl_msa.h:8,
>                 from ./esl_msafile2.c:26:
>./esl_msafile2.c: In function 'msafile2_open':
>./esl_msafile2.c:220:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(cmd, sizeof(char) * (n+1+strlen("gzip -dc ")));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c: In function 'esl_msafile2_ReadInfoPfam':
>./esl_msafile2.c:422:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(spos_ct, sizeof(int) * known_alen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:423:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(epos_ct, sizeof(int) * known_alen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:431:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ct,  sizeof(int)  * (known_alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:432:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(ss_nopseudo, sizeof(char) * (known_alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:435:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(bp_ct,  sizeof(double **) * known_alen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:439:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(bp_ct[apos], sizeof(double *) * (abc->Kp));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:441:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(bp_ct[apos][x], sizeof(double) * (abc->Kp));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:531:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(pp_ct, sizeof(double *) * alen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:533:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>         ESL_ALLOC(pp_ct[apos], sizeof(double) * nppvals);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:537:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>         ESL_ALLOC(tmp_dsq, (alen+2) * sizeof(ESL_DSQ));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:540:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>         ESL_ALLOC(abc_ct, sizeof(double *) * alen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:542:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(abc_ct[apos], sizeof(double) * (abc->K+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:579:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp_dsq, (alen+2) * sizeof(ESL_DSQ));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:582:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(abc_ct, sizeof(double *) * alen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:584:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(abc_ct[apos], sizeof(double) * (abc->K+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:589:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pp_ct, sizeof(double *) * alen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:591:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(pp_ct[apos], sizeof(double) * nppvals);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c: In function 'gapize_string':
>./esl_msafile2.c:1116:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dst_str, sizeof(char) * (dst_len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile2.c:1110:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>./esl_msafile2.c: In function 'msafile2_open':
>./esl_msafile2.c:272:10: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   return status;
>          ^~~~~~
>     GEN esl_msafile_a2m_utest
>In file included from ./esl_msafile_a2m.c:19:0:
>./esl_msafile_a2m.c: In function 'esl_msafile_a2m_Read':
>./esl_msafile_a2m.c:245:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(csflag, sizeof(char *) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_a2m.c:316:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(nins, sizeof(int) * (ncons+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_a2m.c: In function 'esl_msafile_a2m_Write':
>./esl_msafile_a2m.c:413:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_a2m.c: In function 'a2m_padding_digital':
>./esl_msafile_a2m.c:524:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->rf, sizeof(char) * (alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_a2m.c:534:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ax, sizeof(ESL_DSQ) * (alen + 2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_a2m.c: In function 'a2m_padding_text':
>./esl_msafile_a2m.c:577:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->rf, sizeof(char) * (alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_a2m.c:587:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(aseq, sizeof(char) * (alen + 1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_msafile_afa_utest
>     GEN esl_msafile_clustal_utest
>./esl_msafile_clustal.c: In function 'esl_msafile_clustal_Read':
>./esl_msafile_clustal.c:237:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = 0;     pos < n; pos++) if (! isspace(p[pos])) break;  name_start = pos;
>       ^~~
>./esl_msafile_clustal.c:237:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = 0;     pos < n; pos++) if (! isspace(p[pos])) break;  name_start = pos;
>                                                                        ^~~~~~~~~~
>./esl_msafile_clustal.c:238:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < n; pos++) if (  isspace(p[pos])) break;  name_len   = pos - name_start;
>       ^~~
>./esl_msafile_clustal.c:238:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < n; pos++) if (  isspace(p[pos])) break;  name_len   = pos - name_start;
>                                                                        ^~~~~~~~
>./esl_msafile_clustal.c:239:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < n; pos++) if (! isspace(p[pos])) break;  seq_start  = pos;
>       ^~~
>./esl_msafile_clustal.c:239:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < n; pos++) if (! isspace(p[pos])) break;  seq_start  = pos;
>                                                                        ^~~~~~~~~
>./esl_msafile_clustal.c:241:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = n-1; pos > 0; pos--)   if (! isspace(p[pos])) break;  seq_len    = pos - seq_start + 1;
>       ^~~
>./esl_msafile_clustal.c:241:72: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = n-1; pos > 0; pos--)   if (! isspace(p[pos])) break;  seq_len    = pos - seq_start + 1;
>                                                                        ^~~~~~~
>In file included from ./esl_msafile_clustal.c:21:0:
>./esl_msafile_clustal.c: In function 'esl_msafile_clustal_Write':
>./esl_msafile_clustal.c:351:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_clustal.c: In function 'make_text_consensus_line':
>./esl_msafile_clustal.c:471:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(consline, sizeof(char)     * (msa->alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_clustal.c:472:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(v,        sizeof(uint32_t) * (msa->alen));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_clustal.c: In function 'make_digital_consensus_line':
>./esl_msafile_clustal.c:537:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(v,        sizeof(uint32_t) * (msa->alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_clustal.c:538:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(consline, sizeof(char)     * (msa->alen+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_clustal.c:532:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>./esl_msafile_clustal.c: In function 'esl_msafile_clustal_Read':
>./esl_msafile_clustal.c:248:5: warning: 'block_seq_len' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if (seq_len   != block_seq_len)   ESL_XFAIL(eslEFORMAT, afp->errmsg, "sequence end is misaligned");
>     ^
>In file included from ./esl_msafile_clustal.c:21:0:
>In function 'make_text_consensus_line',
>    inlined from 'esl_msafile_clustal_Write' at ./esl_msafile_clustal.c:364:18:
>./easel.h:146:8: warning: argument 1 value '18446744073709551612' exceeds maximum object size 9223372036854775807 [-Walloc-size-larger-than=]
>     if (((p) = malloc(size)) == NULL && (size)) { \
>        ^
>./esl_msafile_clustal.c:472:3: note: in expansion of macro 'ESL_ALLOC'
>   ESL_ALLOC(v,        sizeof(uint32_t) * (msa->alen));
>   ^~~~~~~~~
>In file included from ./esl_msafile_clustal.c:17:0:
>./esl_msafile_clustal.c: In function 'esl_msafile_clustal_Write':
>/usr/include/stdlib.h:443:14: note: in a call to allocation function 'malloc' declared here
> extern void *malloc (size_t __size) __THROW __attribute_malloc__ __wur;
>              ^~~~~~
>     GEN esl_msafile_phylip_utest
>In file included from ./esl_msafile_phylip.c:23:0:
>./esl_msafile_phylip.c: In function 'phylip_interleaved_Read':
>./esl_msafile_phylip.c:415:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(namebuf, sizeof(char) * (namewidth+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_phylip.c: In function 'phylip_interleaved_Write':
>./esl_msafile_phylip.c:492:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (rpl+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_phylip.c: In function 'phylip_sequential_Read':
>./esl_msafile_phylip.c:549:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(namebuf, sizeof(char) * (namewidth+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_phylip.c: In function 'phylip_sequential_Write':
>./esl_msafile_phylip.c:612:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (rpl+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_phylip.c: In function 'esl_msafile_phylip_Read':
>./esl_msafile_phylip.c:589:6: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (status == eslOK) eslx_msafile_PutLine(afp);
>      ^
>./esl_msafile_phylip.c:547:13: note: 'status' was declared here
>   int       status;
>             ^~~~~~
>./esl_msafile_phylip.c: In function 'esl_msafile_phylip_CheckFileFormat':
>./esl_msafile_phylip.c:872:20: warning: 'nw_max' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (nw_min <= 10 && nw_max >= 10) *ret_namewidth = 10;
>       ~~~~~~~~~~~~~^~~~~~~~~~~~~~~
>./esl_msafile_phylip.c:812:31: note: 'nw_max' was declared here
>   int       nwA, nwB, nw_min, nw_max;
>                               ^~~~~~
>./esl_msafile_phylip.c:873:52: warning: 'nw_min' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   else                              *ret_namewidth = nw_min;
>                                     ~~~~~~~~~~~~~~~^~~~~~~~
>./esl_msafile_phylip.c:812:23: note: 'nw_min' was declared here
>   int       nwA, nwB, nw_min, nw_max;
>                       ^~~~~~
>./esl_msafile_phylip.c:853:18: warning: 'n0' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       for (c = n0-1; nres1 && c >= 0; c--)
>                ~~^~
>./esl_msafile_phylip.c:808:17: note: 'n0' was declared here
>   esl_pos_t n,  n0;
>                 ^~
>./esl_msafile_phylip.c:860:8: warning: 'p0' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if (p0[c] != ' ') break;
>        ^
>./esl_msafile_phylip.c:807:17: note: 'p0' was declared here
>   char     *p, *p0;
>                 ^~
>     GEN esl_msafile_psiblast_utest
>./esl_msafile_psiblast.c: In function 'esl_msafile_psiblast_Read':
>./esl_msafile_psiblast.c:219:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = 0;     pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  name_start = pos;
>       ^~~
>./esl_msafile_psiblast.c:219:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = 0;     pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  name_start = pos;
>                                                                                     ^~~~~~~~~~
>./esl_msafile_psiblast.c:220:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < afp->n; pos++) if (  isspace(afp->line[pos])) break;  name_len   = pos - name_start;
>       ^~~
>./esl_msafile_psiblast.c:220:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < afp->n; pos++) if (  isspace(afp->line[pos])) break;  name_len   = pos - name_start;
>                                                                                     ^~~~~~~~
>./esl_msafile_psiblast.c:221:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = pos+1; pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  seq_start  = pos;
>       ^~~
>./esl_msafile_psiblast.c:221:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = pos+1; pos < afp->n; pos++) if (! isspace(afp->line[pos])) break;  seq_start  = pos;
>                                                                                     ^~~~~~~~~
>./esl_msafile_psiblast.c:223:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (pos = afp->n-1; pos > 0; pos--)   if (! isspace(afp->line[pos])) break;  seq_len    = pos - seq_start + 1;
>       ^~~
>./esl_msafile_psiblast.c:223:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>       for (pos = afp->n-1; pos > 0; pos--)   if (! isspace(afp->line[pos])) break;  seq_len    = pos - seq_start + 1;
>                                                                                     ^~~~~~~
>In file included from ./esl_msafile_psiblast.c:16:0:
>./esl_msafile_psiblast.c: In function 'esl_msafile_psiblast_Write':
>./esl_msafile_psiblast.c:341:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_msafile_selex_utest
>In file included from ./esl_msafile_selex.c:35:0:
>./esl_msafile_selex.c: In function 'esl_msafile_selex_Write':
>./esl_msafile_selex.c:304:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c: In function 'selex_block_Create':
>./esl_msafile_selex.c:364:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->line,    sizeof(char *)    * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:365:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->llen,    sizeof(esl_pos_t) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:366:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->offsets, sizeof(esl_pos_t) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:367:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->linenum, sizeof(int64_t)   * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:368:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->ltype,   sizeof(int)       * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:369:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->lpos,    sizeof(esl_pos_t) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:370:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(b->rpos,    sizeof(esl_pos_t) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:351:20: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int              status;
>                    ^~~~~~
>In file included from ./esl_msafile_selex.c:35:0:
>./esl_msafile_selex.c: In function 'selex_first_block':
>./esl_msafile_selex.c:577:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->ss, sizeof(char *) * nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c:581:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->sa, sizeof(char *) * nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_selex.c: In function 'selex_append_block':
>./esl_msafile_selex.c:657:27: warning: variable 'nright' set but not used [-Wunused-but-set-variable]
>   esl_pos_t nleft, ntext, nright;
>                           ^~~~~~
>./esl_msafile_selex.c: In function 'esl_msafile_selex_Read':
>./esl_msafile_selex.c:250:26: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       if      (! nblocks &&  (status = selex_first_block(afp, b, &msa)) != eslOK) goto ERROR;
>     GEN esl_msafile_stockholm_utest
>In file included from ./esl_msafile_stockholm.c:20:0:
>./esl_msafile_stockholm.c: In function 'stockholm_parsedata_Create':
>./esl_msafile_stockholm.c:422:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pd->sqlen,     sizeof(int64_t) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c:387:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_msafile_stockholm.c:20:0:
>./esl_msafile_stockholm.c: In function 'stockholm_parse_gr':
>./esl_msafile_stockholm.c:806:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->ss,   sizeof(char *)  * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c:807:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pd->sslen, sizeof(int64_t) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c:817:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->pp,   sizeof(char *)  * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c:818:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pd->pplen, sizeof(int64_t) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c:828:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(msa->sa,   sizeof(char *)  * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c:829:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pd->salen, sizeof(int64_t) * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c: In function 'stockholm_get_gr_tagidx':
>./esl_msafile_stockholm.c:1031:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(msa->gr[tagidx],     sizeof(char *)    * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c:1032:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pd->ogr_len[tagidx], sizeof(int64_t)   * msa->sqalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c: In function 'stockholm_write':
>./esl_msafile_stockholm.c:1167:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (cpl+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msafile_stockholm.c: In function 'esl_msafile_stockholm_Read':
>./esl_msafile_stockholm.c:306:47: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>    else if (esl_memstrpfx(p, n, "#=GS")) { if ((status = stockholm_parse_gs     (afp, pd, msa, p, n)) != eslOK) goto ERROR; }
>                                               ^
>     GEN esl_msaweight_utest
>In file included from ./esl_msaweight.c:26:0:
>./esl_msaweight.c: In function 'esl_msaweight_GSC':
>./esl_msaweight.c:139:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(x, sizeof(double) * (T->N-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msaweight.c: In function 'esl_msaweight_PB':
>./esl_msaweight.c:276:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     { ESL_ALLOC(nres, sizeof(int) * msa->abc->K); K = msa->abc->K; }
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msaweight.c: In function 'esl_msaweight_BLOSUM':
>./esl_msaweight.c:413:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nmem, sizeof(int) * nc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msaweight.c: In function 'esl_msaweight_IDFilter':
>./esl_msaweight.c:476:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(list,  sizeof(int) * msa->nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msaweight.c:477:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(useme, sizeof(int) * msa->nseq);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_msaweight.c: In function 'esl_msaweight_PB':
>./esl_msaweight.c:307:5: warning: 'ntotal' may be used uninitialized in this function [-Wmaybe-uninitialized]
>  if (ntotal > 0) msa->wgt[idx] /= (double) rlen;
>     ^
>     GEN esl_random_utest
>./esl_random.c: In function 'esl_randomness_Create':
>./esl_random.c:87:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;
>                   ^~~~~~
>./esl_random.c: In function 'esl_randomness_CreateFast':
>./esl_random.c:151:19: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int             status;
>                   ^~~~~~
>     GEN esl_randomseq_utest
>In file included from ./esl_randomseq.c:25:0:
>./esl_randomseq.c: In function 'esl_rsq_Sample':
>./esl_randomseq.c:110:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (L+1)); /* +\0 */
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'esl_rsq_CShuffleDP':
>./esl_randomseq.c:283:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(E[x], sizeof(char) * (len-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'esl_rsq_CShuffleKmers':
>./esl_randomseq.c:475:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(swap, sizeof(char) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'esl_rsq_XShuffleDP':
>./esl_randomseq.c:864:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nE, sizeof(int)       * K);  for (x = 0; x < K; x++) nE[x] = 0;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:865:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(E,  sizeof(ESL_DSQ *) * K);  for (x = 0; x < K; x++) E[x]  = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:866:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(iE, sizeof(int)       * K);  for (x = 0; x < K; x++) iE[x] = 0;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:867:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(Z,  sizeof(ESL_DSQ)   * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:869:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(E[x], sizeof(ESL_DSQ) * (L-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'esl_rsq_XShuffleKmers':
>./esl_randomseq.c:979:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(swap, sizeof(char) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'esl_rsq_XMarkov0':
>./esl_randomseq.c:1114:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p, sizeof(double) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'esl_rsq_XMarkov1':
>./esl_randomseq.c:1195:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p0, sizeof(double)   * K);  for (x = 0; x < K; x++) p0[x] = 0.;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1196:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,  sizeof(double *) * K);  for (x = 0; x < K; x++) p[x]  = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1198:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     { ESL_ALLOC(p[x], sizeof(double) * K); for (y = 0; y < K; y++) p[x][y] = 0.; }
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'composition_allocate':
>./esl_randomseq.c:1404:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mono, sizeof(int)   * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1405:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(di,   sizeof(int *) * K); for (x = 0; x < K; x++) di[x] = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1407:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(di[x], sizeof(int) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c: In function 'utest_CShufflers':
>./esl_randomseq.c:1460:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s,   sizeof(char)   * (L+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1461:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s2,  sizeof(char)   * (L+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1462:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double) * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1449:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from ./esl_randomseq.c:25:0:
>./esl_randomseq.c: In function 'utest_CMarkovs':
>./esl_randomseq.c:1583:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(float)  * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1584:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s,   sizeof(char)   * (L+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1585:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s2,  sizeof(char)   * (L+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1569:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from ./esl_randomseq.c:25:0:
>./esl_randomseq.c: In function 'utest_XShufflers':
>./esl_randomseq.c:1679:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1680:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ds2, sizeof(ESL_DSQ) * (L+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1681:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double)  * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1668:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>In file included from ./esl_randomseq.c:25:0:
>./esl_randomseq.c: In function 'utest_XMarkovs':
>./esl_randomseq.c:1789:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dsq, sizeof(ESL_DSQ) * (L+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1790:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ds2, sizeof(ESL_DSQ) * (L+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1791:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(p,   sizeof(double)  * K);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_randomseq.c:1777:12: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int      status;
>            ^~~~~~
>./esl_randomseq.c: In function 'esl_rsq_XShuffleDP':
>./esl_randomseq.c:949:19: warning: 'Z' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (Z  != NULL) free(Z);
>                   ^~~~~~~
>./esl_randomseq.c: In function 'esl_rsq_XMarkov1':
>./esl_randomseq.c:1235:3: warning: 'p' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   esl_Free2D((void**)p, K);
>   ^~~~~~~~~~~~~~~~~~~~~~~~
>./esl_randomseq.c:1236:19: warning: 'p0' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   if (p0 != NULL) free(p0);
>                   ^~~~~~~~
>     GEN esl_ratematrix_utest
>     GEN esl_recorder_utest
>In file included from ./esl_recorder.c:18:0:
>./esl_recorder.c: In function 'esl_recorder_Create':
>./esl_recorder.c:58:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rc->line,   sizeof(char *) * rc->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_recorder.c:61:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rc->lalloc, sizeof(int)    * rc->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_recorder.c:64:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(rc->offset, sizeof(off_t)  * rc->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_recorder.c:45:17: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int           status;
>                 ^~~~~~
>     GEN esl_regexp_utest
>./esl_regexp.c: In function 'esl_regexp_Create':
>./esl_regexp.c:91:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_regexp.c:59:0:
>./esl_regexp.c: In function 'esl_regexp_SubmatchDup':
>./esl_regexp.c:237:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(s, sizeof(char) * (len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_regexp.c:229:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>./esl_regexp.c: In function 'regcomp':
>./esl_regexp.c:579:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>         int status;
>             ^~~~~~
>./esl_regexp.c: In function 'reg':
>./esl_regexp.c:667:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>./esl_regexp.c: In function 'regpiece':
>./esl_regexp.c:779:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>         int status;
>             ^~~~~~
>./esl_regexp.c: In function 'regatom':
>./esl_regexp.c:855:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>./esl_regexp.c: In function 'regescape':
>./esl_regexp.c:1612:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>     GEN esl_rootfinder_utest
>./esl_rootfinder.c: In function 'esl_rootfinder_Create':
>./esl_rootfinder.c:51:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>./esl_rootfinder.c: In function 'esl_rootfinder_CreateFDF':
>./esl_rootfinder.c:105:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>     GEN esl_scorematrix_utest
>In file included from ./esl_scorematrix.c:23:0:
>./esl_scorematrix.c: In function 'esl_scorematrix_Create':
>./esl_scorematrix.c:68:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->s, sizeof(int *) * abc->Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_scorematrix.c:70:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->isval, sizeof(char) * abc->Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_scorematrix.c:72:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->outorder, sizeof(char) * (abc->Kp+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_scorematrix.c:75:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(S->s[0], sizeof(int) * abc->Kp * abc->Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_scorematrix.c:54:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_scorematrix.c:23:0:
>./esl_scorematrix.c: In function 'esl_scorematrix_Read':
>./esl_scorematrix.c:1060:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(map, sizeof(int) * S->nc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_scorematrix.c: In function 'esl_scorematrix_Probify':
>./esl_scorematrix.c:1669:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fi, sizeof(double) * S->Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_scorematrix.c:1670:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fj, sizeof(double) * S->Kp);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_scorematrix.c: In function 'esl_scorematrix_SetWAG':
>./esl_scorematrix.c:947:7: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int status;
>       ^~~~~~
>     GEN esl_sq_utest
>In file included from ./esl_sq.c:21:0:
>./esl_sq.c: In function 'esl_sq_Copy':
>./esl_sq.c:274:76: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (src->ss != NULL && dst->ss  == NULL) ESL_ALLOC(dst->ss, sizeof(char) * dst->salloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:288:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(dst->xr_tag, sizeof(char *) * dst->nxr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:289:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(dst->xr,     sizeof(char *) * dst->nxr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:292:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(dst->xr_tag[x], sizeof(char) * src->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:293:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(dst->xr[x],     sizeof(char) * src->salloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c: In function 'esl_sq_CreateDigitalFrom':
>./esl_sq.c:715:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->ss, sizeof(char) * (sq->n+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c: In function 'esl_sq_Digitize':
>./esl_sq.c:790:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->dsq, (sq->salloc) * sizeof(ESL_DSQ));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c: In function 'esl_sq_Textize':
>./esl_sq.c:845:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->seq, sq->salloc * sizeof(char));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c: In function 'esl_sq_GetFromMSA':
>./esl_sq.c:1712:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xr_tag, sizeof(char *) * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1713:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(xr,     sizeof(char *) * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1725:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(sq->xr_tag, sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr_tag[x] = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1726:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(sq->xr,     sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr[x]     = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1756:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>    ESL_ALLOC(sq->ss, sizeof(char) * (strlen(ss)+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1764:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr[x], sizeof(char) * (strlen(xr[x])+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1793:7: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>       if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>       ^~
>./esl_sq.c:1793:41: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>       if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>                                         ^~
>In file included from ./esl_sq.c:21:0:
>./esl_sq.c: In function 'esl_sq_FetchFromMSA':
>./esl_sq.c:1845:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(xr_tag, sizeof(char *) * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1846:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(xr,     sizeof(char *) * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1865:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr_tag, sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr_tag[x] = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1866:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr,     sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr[x] = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1888:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr_tag, sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr_tag[x] = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1889:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(sq->xr,     sizeof(char *) * sq->nxr); for (x = 0; x < sq->nxr; x ++) sq->xr[x] = NULL;
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1893:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>        ESL_ALLOC(sq->xr[x], sizeof(char) * (sq->n+2));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1897:6: warning: this 'else' clause does not guard... [-Wmisleading-indentation]
>      else strcpy(sq->xr[x]+1, xr[x]); sq->xr[x][0] = '\0';
>      ^~~~
>./esl_sq.c:1897:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'else'
>      else strcpy(sq->xr[x]+1, xr[x]); sq->xr[x][0] = '\0';
>                                       ^~
>./esl_sq.c:1926:5: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>     if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>     ^~
>./esl_sq.c:1926:39: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>     if (xr_tag != NULL) free(xr_tag); if (xr != NULL) free(xr);
>                                       ^~
>./esl_sq.c: In function 'sq_create':
>./esl_sq.c:1950:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_sq.c:21:0:
>./esl_sq.c: In function 'sq_createblock':
>./esl_sq.c:1979:41: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(block->list, sizeof(ESL_SQ) * count);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1970:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status = eslOK;
>       ^~~~~~
>In file included from ./esl_sq.c:21:0:
>./esl_sq.c: In function 'sq_init':
>./esl_sq.c:2015:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->name,   sizeof(char) * sq->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2016:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->acc,    sizeof(char) * sq->aalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2017:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->desc,   sizeof(char) * sq->dalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2018:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->source, sizeof(char) * sq->srcalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2019:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (do_digital) ESL_ALLOC(sq->dsq,  sizeof(ESL_DSQ) * sq->salloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2020:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   else            ESL_ALLOC(sq->seq,  sizeof(char)    * sq->salloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:1998:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_sq.c:21:0:
>./esl_sq.c: In function 'sq_create_from':
>./esl_sq.c:2055:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->name, sizeof(char) * n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2062:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->name, sizeof(char) * sq->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2069:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->desc, sizeof(char) * n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2076:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->desc, sizeof(char) * sq->dalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2083:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->acc, sizeof(char) * n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2090:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(sq->acc,  sizeof(char) * sq->aalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2096:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sq->source, sizeof(char) * sq->srcalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2042:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>./esl_sq.c: In function 'utest_ExtraResMarkups':
>./esl_sq.c:2374:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_GetFromMSA(msa1, 0, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>   ^~
>./esl_sq.c:2374:64: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_GetFromMSA(msa1, 0, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>                                                                ^~~~~~~~~~~~
>./esl_sq.c:2375:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_GetFromMSA(msa1, 1, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>   ^~
>./esl_sq.c:2375:64: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_GetFromMSA(msa1, 1, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>                                                                ^~~~~~~~~~~~
>./esl_sq.c:2376:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_GetFromMSA(msa1, 2, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>   ^~
>./esl_sq.c:2376:64: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_GetFromMSA(msa1, 2, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>                                                                ^~~~~~~~~~~~
>./esl_sq.c:2388:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_FetchFromMSA(msa1, 0, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2388:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_FetchFromMSA(msa1, 0, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                   ^~~~~~~~~~~~~~
>./esl_sq.c:2389:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_FetchFromMSA(msa1, 1, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2389:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_FetchFromMSA(msa1, 1, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                   ^~~~~~~~~~~~~~
>./esl_sq.c:2390:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_FetchFromMSA(msa1, 2, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2390:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_FetchFromMSA(msa1, 2, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                   ^~~~~~~~~~~~~~
>./esl_sq.c:2391:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_FetchFromMSA(msa1, 5, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2391:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_FetchFromMSA(msa1, 5, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                   ^~~~~~~~~~~~~~
>./esl_sq.c:2399:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_GetFromMSA(msa2, 0, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>   ^~
>./esl_sq.c:2399:64: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_GetFromMSA(msa2, 0, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>                                                                ^~~~~~~~~~~~
>./esl_sq.c:2400:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_GetFromMSA(msa2, 1, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>   ^~
>./esl_sq.c:2400:64: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_GetFromMSA(msa2, 1, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>                                                                ^~~~~~~~~~~~
>./esl_sq.c:2401:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_GetFromMSA(msa2, 2, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>   ^~
>./esl_sq.c:2401:64: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_GetFromMSA(msa2, 2, sq) != eslOK) esl_fatal(msg); esl_sq_Reuse(sq);
>                                                                ^~~~~~~~~~~~
>./esl_sq.c:2402:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_GetFromMSA(msa2, 5, sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2402:64: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_GetFromMSA(msa2, 5, sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                ^~~~~~~~~~~~~~
>./esl_sq.c:2404:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_FetchFromMSA(msa2, 0, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2404:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_FetchFromMSA(msa2, 0, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                   ^~~~~~~~~~~~~~
>./esl_sq.c:2405:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_FetchFromMSA(msa2, 1, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2405:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_FetchFromMSA(msa2, 1, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                   ^~~~~~~~~~~~~~
>./esl_sq.c:2406:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (esl_sq_FetchFromMSA(msa2, 2, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>   ^~
>./esl_sq.c:2406:67: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (esl_sq_FetchFromMSA(msa2, 2, &sq) != eslOK) esl_fatal(msg); esl_sq_Destroy(sq);
>                                                                   ^~~~~~~~~~~~~~
>In file included from ./esl_sq.c:21:0:
>./esl_sq.c: In function 'utest_CountResidues':
>./esl_sq.c:2441:27: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cnts, abc->Kp * sizeof(float));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sq.c:2438:16: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int          status;
>                ^~~~~~
>./esl_sq.c: In function 'esl_sq_GetFromMSA':
>./esl_sq.c:1698:11: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int     status;
>           ^~~~~~
>     GEN esl_sqio_utest
>In file included from ./esl_sqio.c:34:0:
>./esl_sqio.c: In function 'sqfile_open':
>./esl_sqio.c:213:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sqfp->filename, sizeof(char) * (strlen(filename) + 1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sqio.c:237:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(list, sizeof(char) * (strlen(s1) + 1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sqio.c:240:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(path, sizeof(char) * (strlen(filename) + strlen(list) + 3));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sqio.c: In function 'esl_sqfile_Cache':
>./esl_sqio.c:483:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cache->sq_list, sizeof(ESL_SQ) * (count + 1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sqio.c: In function 'convert_sq_to_msa':
>./esl_sqio.c:1450:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->gr,     sizeof(char **) * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_sqio.c:1451:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(msa->gr_tag, sizeof(char  *) * msa->ngr);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_sse_utest
>     GEN esl_ssi_utest
>In file included from ./esl_ssi.c:15:0:
>./esl_ssi.c: In function 'esl_ssi_Open':
>./esl_ssi.c:111:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->filename,   sizeof(char *) * ssi->nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:113:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->fileformat, sizeof(uint32_t) * ssi->nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:114:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->fileflags,  sizeof(uint32_t) * ssi->nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:115:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->bpl,        sizeof(uint32_t) * ssi->nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:116:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ssi->rpl,        sizeof(uint32_t) * ssi->nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:121:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ssi->filename[i], sizeof(char)* ssi->flen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c: In function 'esl_ssi_FindName':
>./esl_ssi.c:197:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>  ESL_ALLOC(pkey, sizeof(char) * ssi->plen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c: In function 'esl_ssi_FindNumber':
>./esl_ssi.c:261:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pkey, sizeof(char) * ssi->plen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c: In function 'binary_search':
>./esl_ssi.c:567:32: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(name, (sizeof(char)*klen));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c: In function 'esl_newssi_Write':
>./esl_ssi.c:999:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fk, sizeof(char) * ns->flen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:1000:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pk, sizeof(char) * ns->plen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:1001:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (ns->slen) ESL_ALLOC(sk, sizeof(char) * ns->slen);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c: In function 'main':
>./esl_ssi.c:1796:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sqfile, sizeof(char *) * nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:1806:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(seq,    sizeof(char *) * nseq * nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:1807:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(seqname,sizeof(char *) * nseq * nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:1808:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(seqlen, sizeof(int)    * nseq * nfiles);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_ssi.c:1812:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(seq[i], sizeof(char) * (seqlen[i]+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_stack_utest
>In file included from ./esl_stack.c:26:0:
>./esl_stack.c: In function 'esl_stack_ICreate':
>./esl_stack.c:59:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ns->idata, sizeof(int) * ns->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_stack.c:53:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_stack.c:26:0:
>./esl_stack.c: In function 'esl_stack_CCreate':
>./esl_stack.c:95:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cs->cdata, sizeof(char) * cs->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_stack.c:89:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./esl_stack.c:26:0:
>./esl_stack.c: In function 'esl_stack_PCreate':
>./esl_stack.c:131:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ps->pdata, sizeof(void *) * ps->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_stack.c:125:14: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int        status;
>              ^~~~~~
>./esl_stack.c: In function 'esl_stack_Convert2String':
>./esl_stack.c:477:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>./esl_stack.c: In function 'utest_shuffle':
>./esl_stack.c:882:19: warning: variable 'appears_shuffled' set but not used [-Wunused-but-set-variable]
>   int             appears_shuffled = FALSE;
>                   ^~~~~~~~~~~~~~~~
>./esl_stack.c: In function 'esl_stack_DiscardSelected':
>./esl_stack.c:583:8: warning: 'npos' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   s->n = npos;
>   ~~~~~^~~~~~
>     GEN esl_stats_utest
>In file included from ./esl_stats.c:20:0:
>./esl_stats.c: In function 'esl_stats_LinearRegression':
>./esl_stats.c:528:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(t, sizeof(double) * n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_stretchexp_utest
>./esl_stretchexp.c: In function 'esl_sxp_invcdf':
>./esl_stretchexp.c:166:10: warning: variable 'f1' set but not used [-Wunused-but-set-variable]
>   double f1, f2, fm;
>          ^~
>./esl_stretchexp.c: In function 'esl_sxp_FitComplete':
>./esl_stretchexp.c:353:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>./esl_stretchexp.c: In function 'esl_sxp_FitCompleteBinned':
>./esl_stretchexp.c:441:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>     GEN esl_tree_utest
>In file included from ./esl_tree.c:21:0:
>./esl_tree.c: In function 'esl_tree_Create':
>./esl_tree.c:64:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->parent, sizeof(int)    * (ntaxa-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:65:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->left,   sizeof(int)    * (ntaxa-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:66:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->right,  sizeof(int)    * (ntaxa-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:67:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->ld,     sizeof(double) * (ntaxa-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:68:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->rd,     sizeof(double) * (ntaxa-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:49:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>./esl_tree.c: In function 'esl_tree_Grow':
>./esl_tree.c:179:9: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int   status;
>         ^~~~~~
>In file included from ./esl_tree.c:21:0:
>./esl_tree.c: In function 'esl_tree_SetTaxaParents':
>./esl_tree.c:263:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->taxaparent, sizeof(int) * T->N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'esl_tree_SetCladesizes':
>./esl_tree.c:298:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->cladesize, sizeof(int) * (T->N-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'esl_tree_SetTaxonlabels':
>./esl_tree.c:344:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(T->taxonlabel, sizeof(char **) * T->nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'esl_tree_RenumberNodes':
>./esl_tree.c:395:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(map, sizeof(int) * (T->N-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:413:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(T2->nodelabel,  sizeof(char *) * (T2->nalloc-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:417:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(T2->taxaparent, sizeof(int)    * (T2->nalloc));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'esl_tree_VerifyUltrametric':
>./esl_tree.c:482:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(d, sizeof(double) * T->N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'newick_parse_quoted_label':
>./esl_tree.c:1005:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(label, sizeof(char) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'newick_parse_unquoted_label':
>./esl_tree.c:1062:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(label, sizeof(char) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'newick_parse_branchlength':
>./esl_tree.c:1106:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(branch, sizeof(char) * nalloc);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'esl_tree_Compare':
>./esl_tree.c:1482:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(Mg,  sizeof(int) * (T1->N-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:1483:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(Mgt, sizeof(int) * (T1->N));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'cluster_engine':
>./esl_tree.c:1608:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(idx,    sizeof(int)    *  D->n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:1609:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(nin,    sizeof(int)    *  D->n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:1610:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(height, sizeof(double) * (D->n-1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'esl_tree_Simulate':
>./esl_tree.c:1849:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(branchpapa, sizeof(int) * N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c:1850:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(branchside, sizeof(int) * N);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_tree.c: In function 'newick_parse_branchlength':
>./esl_tree.c:1103:9: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   int   status;
>         ^~~~~~
>     GEN esl_vectorops_utest
>In file included from ./esl_vectorops.c:20:0:
>./esl_vectorops.c: In function 'esl_vec_DLogValidate':
>./esl_vectorops.c:1216:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(expvec, sizeof(double)*n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_vectorops.c: In function 'esl_vec_FLogValidate':
>./esl_vectorops.c:1236:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(expvec, sizeof(float)*n);
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN esl_weibull_utest
>     GEN esl_wuss_utest
>In file included from ./esl_wuss.c:8:0:
>./esl_wuss.c: In function 'esl_ct2wuss':
>./esl_wuss.c:169:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cct, sizeof(int)*(n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c: In function 'esl_ct2simplewuss':
>./esl_wuss.c:393:29: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(cct, sizeof(int)*(n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c: In function 'esl_wuss_full':
>./esl_wuss.c:632:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct,  sizeof(int)  * (n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c:633:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tmp, sizeof(char) * (n+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c: In function 'main':
>./esl_wuss.c:736:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct1, sizeof(int)  * (len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c:737:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ct2, sizeof(int)  * (len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c:738:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss2, sizeof(char) * (len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c:739:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ss3, sizeof(char) * (len+1));
>./easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./esl_wuss.c: In function 'esl_wuss2ct':
>./esl_wuss.c:119:10: warning: 'status' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   return status;
>          ^~~~~~
>     SUBDIR miniapps
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/easel/miniapps'
>make[2]: Nothing to be done for 'tests'.
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/easel/miniapps'
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/easel'
>     SUBDIR libdivsufsort
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/libdivsufsort'
>make[1]: Nothing to be done for 'all'.
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/libdivsufsort'
>     SUBDIR src
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/src'
>     SUBDIR impl_dummy
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>make[2]: 'libhmmer-impl.stamp' is up to date.
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>     GEN build_utest
>In file included from ./build.c:29:0:
>./build.c: In function 'p7_Handmodelmaker':
>./build.c:92:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matassign, sizeof(int) * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c: In function 'p7_Fastmodelmaker':
>./build.c:170:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(matassign, sizeof(int)     * (msa->alen+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c: In function 'matassign2hmm':
>./build.c:284:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr, sizeof(P7_TRACE *) * msa->nseq);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c:312:57: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (msa->rf == NULL)  ESL_ALLOC(msa->rf, sizeof(char) * (msa->alen + 1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c: In function 'annotate_model':
>./build.c:354:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->rf, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c:364:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->mm, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c:374:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->cs, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c:384:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->ca, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./build.c:393:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->map, sizeof(int) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN generic_fwdback_utest
>./generic_fwdback.c: In function 'utest_enumeration':
>./generic_fwdback.c:561:10: warning: variable 'vp' set but not used [-Wunused-but-set-variable]
>   double vp, fp;  /* P(seq,\pi | model) and P(seq | model) */
>          ^~
>     GEN generic_fwdback_chk_utest
>     GEN generic_msv_utest
>     GEN generic_stotrace_utest
>In file included from ./generic_stotrace.c:17:0:
>./generic_stotrace.c: In function 'p7_GStochasticTrace':
>./generic_stotrace.c:63:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sc, sizeof(float) * (2*M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./generic_stotrace.c:178:27: warning: 'scur' may be used uninitialized in this function [-Wmaybe-uninitialized]
>       if ( (scur == p7T_N || scur == p7T_J || scur == p7T_C) && scur == sprv) i--;
>             ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~
>     GEN generic_viterbi_utest
>     GEN hmmer_utest
>     GEN logsum_utest
>     GEN modelconfig_utest
>In file included from ./modelconfig.c:23:0:
>./modelconfig.c: In function 'p7_ProfileConfig':
>./modelconfig.c:92:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(occ, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN seqmodel_utest
>     GEN p7_alidisplay_utest
>./p7_alidisplay.c: In function 'p7_alidisplay_Create':
>./p7_alidisplay.c:68:18: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int            status;
>                  ^~~~~~
>In file included from ./p7_alidisplay.c:21:0:
>./p7_alidisplay.c: In function 'p7_alidisplay_Clone':
>./p7_alidisplay.c:243:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>       ESL_ALLOC(ad2->mem, sizeof(char) * ad->memsize);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:232:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>./p7_alidisplay.c: In function 'p7_alidisplay_Serialize':
>./p7_alidisplay.c:385:3: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
>   if (ad->mem) free(ad->mem); ad->mem = NULL;
>   ^~
>./p7_alidisplay.c:385:31: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
>   if (ad->mem) free(ad->mem); ad->mem = NULL;
>                               ^~
>In file included from ./p7_alidisplay.c:21:0:
>./p7_alidisplay.c: In function 'p7_alidisplay_Deserialize':
>./p7_alidisplay.c:423:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->hmmname,  sizeof(char) * n); memcpy(ad->hmmname,  ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:424:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->hmmacc,   sizeof(char) * n); memcpy(ad->hmmacc,   ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:425:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->hmmdesc,  sizeof(char) * n); memcpy(ad->hmmdesc,  ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:426:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->sqname,   sizeof(char) * n); memcpy(ad->sqname,   ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:427:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->sqacc,    sizeof(char) * n); memcpy(ad->sqacc,    ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:428:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   n = 1 + strlen(ad->mem+pos);  ESL_ALLOC(ad->sqdesc,   sizeof(char) * n); memcpy(ad->sqdesc,   ad->mem+pos, n); pos += n;
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c: In function 'p7_alidisplay_Print':
>./p7_alidisplay.c:598:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(buf, sizeof(char) * (aliwidth+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c: In function 'create_faux_alidisplay':
>./p7_alidisplay.c:990:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(guidestring, sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:1047:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (esl_rnd_Roll(rng, 2) == 0)  ESL_ALLOC(ad->rfline, sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:1048:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (esl_rnd_Roll(rng, 2) == 0)  ESL_ALLOC(ad->mmline, sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:1049:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (esl_rnd_Roll(rng, 2) == 0)  ESL_ALLOC(ad->csline, sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:1050:70: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (esl_rnd_Roll(rng, 2) == 0)  ESL_ALLOC(ad->ppline, sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:1051:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ad->model, sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:1052:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ad->mline, sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_alidisplay.c:1053:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(ad->aseq,  sizeof(char) * (N+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN p7_bg_utest
>In file included from ./p7_bg.c:19:0:
>./p7_bg.c: In function 'p7_bg_Create':
>./p7_bg.c:64:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg->f,     sizeof(float) * abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_bg.c:58:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from ./p7_bg.c:19:0:
>./p7_bg.c: In function 'p7_bg_CreateUniform':
>./p7_bg.c:101:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(bg->f,     sizeof(float) * abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_bg.c:95:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from ./p7_bg.c:19:0:
>./p7_bg.c: In function 'p7_bg_Clone':
>./p7_bg.c:136:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(dup->f, sizeof(float) * bg->abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_bg.c:129:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from ./p7_bg.c:19:0:
>./p7_bg.c: In function 'p7_bg_Read':
>./p7_bg.c:267:31: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(fq, sizeof(float) * bg->abc->K);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN p7_gmx_utest
>In file included from ./hmmer.h:43:0,
>                 from ./p7_gmx.c:12:
>./p7_gmx.c: In function 'p7_gmx_Create':
>./p7_gmx.c:45:42: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gx->dp,      sizeof(float *) * (allocL+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_gmx.c:46:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gx->xmx,     sizeof(float)   * (allocL+1) * p7G_NXCELLS);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_gmx.c:47:68: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gx->dp_mem,  sizeof(float)   * (allocL+1) * (allocM+1) * p7G_NSCELLS);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_gmx.c:34:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>     GEN p7_gmxchk_utest
>In file included from ./hmmer.h:43:0,
>                 from ./p7_gmxchk.c:20:
>./p7_gmxchk.c: In function 'p7_gmxchk_Create':
>./p7_gmxchk.c:96:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( gxc->dp_mem, sizeof(float)   * gxc->ncells);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_gmxchk.c:97:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( gxc->dp,     sizeof(float *) * gxc->allocR);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_gmxchk.c:74:14: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int        status;
>              ^~~~~~
>     GEN p7_hmm_utest
>./p7_hmm.c: In function 'p7_hmm_CreateShell':
>./p7_hmm.c:82:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from ./p7_hmm.c:21:0:
>./p7_hmm.c: In function 'p7_hmm_CreateBody':
>./p7_hmm.c:141:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->t,    (M+1) * sizeof(float *));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:142:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->mat,  (M+1) * sizeof(float *));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:143:30: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->ins,  (M+1) * sizeof(float *));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:149:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->t[0],   (p7H_NTRANSITIONS*(M+1)) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:150:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->mat[0], (abc->K*(M+1))           * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:151:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(hmm->ins[0], (abc->K*(M+1))           * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:166:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_RF)    ESL_ALLOC(hmm->rf,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:167:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_MMASK) ESL_ALLOC(hmm->mm,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:168:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_CONS)  ESL_ALLOC(hmm->consensus,  (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:169:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_CS)    ESL_ALLOC(hmm->cs,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:170:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_CA)    ESL_ALLOC(hmm->ca,         (M+2) * sizeof(char));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:171:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (hmm->flags & p7H_MAP)   ESL_ALLOC(hmm->map,        (M+1) * sizeof(int));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c: In function 'p7_hmm_Clone':
>./p7_hmm.c:282:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->map, sizeof(int) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c: In function 'p7_hmm_AppendComlog':
>./p7_hmm.c:528:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(hmm->comlog, sizeof(char)* (n+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c: In function 'p7_hmm_SetComposition':
>./p7_hmm.c:634:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(mocc, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c:635:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(iocc, sizeof(float) * (hmm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_hmm.c: In function 'p7_hmm_SetConsensus':
>./p7_hmm.c:711:64: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (! hmm->consensus) ESL_ALLOC(hmm->consensus, sizeof(char) * (hmm->M+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN p7_hmmfile_utest
>In file included from ./p7_hmmfile.c:25:0:
>./p7_hmmfile.c: In function 'read_bin_string':
>./p7_hmmfile.c:2229:33: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(s,  (sizeof(char) * len));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN p7_profile_utest
>In file included from ./p7_profile.c:20:0:
>./p7_profile.c: In function 'p7_profile_Create':
>./p7_profile.c:68:53: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->tsc,       sizeof(float)   * allocM * p7P_NTRANS);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:69:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->rsc,       sizeof(float *) * abc->Kp);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:70:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->rf,        sizeof(char)    * (allocM+2)); /* yes, +2: each is (0)1..M, +trailing \0  */
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:71:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->mm,        sizeof(char)    * (allocM+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:72:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->cs,        sizeof(char)    * (allocM+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:73:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->consensus, sizeof(char)    * (allocM+2));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:77:62: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(gm->rsc[0], sizeof(float) * abc->Kp * (allocM+1) * p7P_NR);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:56:15: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int         status;
>               ^~~~~~
>In file included from ./p7_profile.c:20:0:
>./p7_profile.c: In function 'p7_profile_Validate':
>./p7_profile.c:511:36: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(pstart, sizeof(double) * (gm->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_profile.c:507:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>     GEN p7_tophits_utest
>In file included from ./p7_tophits.c:17:0:
>./p7_tophits.c: In function 'p7_tophits_Create':
>./p7_tophits.c:43:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->hit,   sizeof(P7_HIT *) * default_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_tophits.c:44:40: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(h->unsrt, sizeof(P7_HIT)   * default_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_tophits.c:37:15: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int         status;
>               ^~~~~~
>./p7_tophits.c: In function 'p7_tophits_Grow':
>./p7_tophits.c:78:11: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int     status;
>           ^~~~~~
>In file included from ./p7_tophits.c:17:0:
>./p7_tophits.c: In function 'p7_tophits_Merge':
>./p7_tophits.c:419:43: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC (new_hit, sizeof(P7_HIT *)    * Nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_tophits.c: In function 'p7_tophits_Targets':
>./p7_tophits.c:1108:3: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>   for (h = 0; h < th->N; h++)
>   ^~~
>./p7_tophits.c:1176:5: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>     if (th->nreported == 0)
>     ^~
>./p7_tophits.c: In function 'p7_tophits_Domains':
>./p7_tophits.c:1282:7: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
>       for (d = 0; d < th->hit[h]->ndom; d++)
>       ^~~
>./p7_tophits.c:1338:11: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
>           if (pli->show_alignments)
>           ^~
>In file included from ./p7_tophits.c:17:0:
>./p7_tophits.c: In function 'p7_tophits_Alignment':
>./p7_tophits.c:1455:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(sqarr, sizeof(ESL_SQ *)   * (ndom + inc_n));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_tophits.c:1456:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(trarr, sizeof(P7_TRACE *) * (ndom + inc_n));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_tophits.c: In function 'main':
>./p7_tophits.c:2119:19: warning: 'key' may be used uninitialized in this function [-Wmaybe-uninitialized]
>   double          key;
>                   ^~~
>     GEN p7_trace_utest
>In file included from ./p7_trace.c:22:0:
>./p7_trace.c: In function 'trace_create_engine':
>./p7_trace.c:93:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->st, sizeof(char) * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:94:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->k,  sizeof(int)  * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:95:34: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->i,  sizeof(int)  * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:97:37: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(tr->pp, sizeof(float) * initial_nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:102:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->tfrom,   sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:103:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->tto,     sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:104:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->sqfrom,  sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:105:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->sqto,    sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:106:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->hmmfrom, sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:107:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(tr->hmmto,   sizeof(int) * initial_ndomalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_trace.c:79:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int       status;
>             ^~~~~~
>In file included from ./p7_trace.c:22:0:
>./p7_trace.c: In function 'p7_trace_SetPP':
>./p7_trace.c:933:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   if (tr->pp == NULL) ESL_ALLOC(tr->pp, sizeof(float) * tr->nalloc);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     GEN p7_scoredata_utest
>In file included from ./p7_scoredata.c:18:0:
>./p7_scoredata.c: In function 'scoredata_GetSSVScoreArrays':
>./p7_scoredata.c:70:49: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->ssv_scores, (om->M + 1) * K * sizeof(uint8_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:75:51: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->ssv_scores_f, (om->M + 1) * K * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:76:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(max_scores, (om->M + 1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:89:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->opt_ext_fwd, (om->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:90:46: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->opt_ext_rev, (om->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:60:13: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int i, j, status;
>             ^~~~~~
>./p7_scoredata.c: In function 'p7_hmm_ScoreDataCreate':
>./p7_scoredata.c:180:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>In file included from ./p7_scoredata.c:18:0:
>./p7_scoredata.c: In function 'p7_hmm_ScoreDataClone':
>./p7_scoredata.c:242:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->ssv_scores, (src->M + 1) * Kp * sizeof(uint8_t));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:245:52: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(new->ssv_scores_f, (src->M + 1) * Kp * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:251:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->prefix_lengths, (src->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:255:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->suffix_lengths, (src->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:259:44: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->fwd_scores, (src->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:265:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->opt_ext_fwd, (src->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:272:47: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>      ESL_ALLOC(new->opt_ext_rev, (src->M + 1) * sizeof(float*));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:281:53: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>        ESL_ALLOC(new->fwd_transitions[i], (src->M+1)* sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:224:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status;
>       ^~~~~~
>In file included from ./p7_scoredata.c:18:0:
>./p7_scoredata.c: In function 'p7_hmm_ScoreDataComputeRest':
>./p7_scoredata.c:324:60: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(data->fwd_scores, sizeof(float) *  om->abc->Kp * (om->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:331:55: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC(data->fwd_transitions[i], sizeof(float) * (om->M+1));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:337:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(data->prefix_lengths, (om->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:338:45: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(data->suffix_lengths, (om->M+1) * sizeof(float));
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./p7_scoredata.c:318:10: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int    status;
>          ^~~~~~
>./p7_scoredata.c: In function 'utest_createScoreData':
>./p7_scoredata.c:382:11: warning: variable 'bias' set but not used [-Wunused-but-set-variable]
>   uint8_t bias;
>           ^~~~
>     GEN hmmpgmd2msa_utest
>In file included from ./hmmer.h:43:0,
>                 from ./hmmpgmd2msa.c:14:
>./hmmpgmd2msa.c: In function 'hmmpgmd2msa':
>./hmmpgmd2msa.c:137:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.unsrt, sizeof(P7_HIT) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:139:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.hit, sizeof(P7_HIT*) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:158:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC( th.hit[i]->dcl, sizeof(P7_DOMAIN) *  th.hit[i]->ndom);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c: In function 'hmmpgmd2stats':
>./hmmpgmd2msa.c:321:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( *statsOut,   sizeof(float) * hmm->M * 3);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:324:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( cover,   sizeof(int) * hmm->M);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:325:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( id,      sizeof(int) * hmm->M);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:326:35: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( similar, sizeof(int) * hmm->M);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:357:39: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.unsrt, sizeof(P7_HIT) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:359:38: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC( th.hit, sizeof(P7_HIT*) * stats->nhits);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./hmmpgmd2msa.c:378:50: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>     ESL_ALLOC( th.hit[i]->dcl, sizeof(P7_DOMAIN) *  th.hit[i]->ndom);
>../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>     CC itest_brute.o
>     GEN itest_brute
>     SUBDIR impl_dummy
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>     GEN decoding_utest
>     GEN fwdback_utest
>     GEN io_utest
>In file included from ./io.c:35:0:
>./io.c: In function 'p7_oprofile_CreateBlock':
>./io.c:477:48: warning: '*' in boolean context, suggest '&&' instead [-Wint-in-bool-context]
>   ESL_ALLOC(block->list, sizeof(P7_OPROFILE *) * count);
>../../easel/easel.h:146:42: note: in definition of macro 'ESL_ALLOC'
>     if (((p) = malloc(size)) == NULL && (size)) { \
>                                          ^~~~
>./io.c:469:7: warning: variable 'status' set but not used [-Wunused-but-set-variable]
>   int status = eslOK;
>       ^~~~~~
>     GEN msvfilter_utest
>     GEN null2_utest
>     GEN optacc_utest
>     GEN stotrace_utest
>     GEN vitfilter_utest
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/src/impl_dummy'
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/src'
>     SUBDIR easel
>make[1]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/easel'
>     SUBDIR miniapps
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/easel/miniapps'
>make[2]: Nothing to be done for 'check'.
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/easel/miniapps'
>     SUBDIR testsuite
>make[2]: Entering directory '/builddir/build/BUILD/hmmer-3.1b2/easel/testsuite'
>Running Easel test suite...
>make[2]: ./../devkit/sqc: Command not found
>make[2]: *** [Makefile:34: check] Error 127
>make[2]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/easel/testsuite'
>make[1]: *** [Makefile:370: check] Error 2
>make[1]: Leaving directory '/builddir/build/BUILD/hmmer-3.1b2/easel'
>make: *** [Makefile:129: check] Error 2
>error: Bad exit status from /var/tmp/rpm-tmp.qRCWW4 (%check)
>RPM build errors:
>    Bad exit status from /var/tmp/rpm-tmp.qRCWW4 (%check)
>Child return code was: 1
>EXCEPTION: [Error()]
>Traceback (most recent call last):
>  File "/usr/lib/python3.5/site-packages/mockbuild/trace_decorator.py", line 89, in trace
>    result = func(*args, **kw)
>  File "/usr/lib/python3.5/site-packages/mockbuild/util.py", line 578, in do
>    raise exception.Error("Command failed. See logs for output.\n # %s" % (command,), child.returncode)
>mockbuild.exception.Error: Command failed. See logs for output.
> # bash --login -c /usr/bin/rpmbuild -bb --target ppc64 --nodeps /builddir/build/SPECS/hmmer.spec

Actions: View

Attachments on bug 1423711: 1252486 | 1252487 | 1252488