Show report
[2018-08-09 22:45:08+0200] ==> Skipping synctree
[2018-08-09 22:45:08+0200] ==> Starting runsmoke
[2018-08-09 22:45:08+0200] [tssmokeperl.pl] chdir(/pro/3gl/CPAN/perl-current)
[2018-08-09 22:45:08+0200] Setup alarm: Fri Aug 10 22:15:08 2018
[2018-08-09 22:45:08+0200] qx[/pro/bin/perl -e "require q[/pro/3gl/CPAN/perl-current/cpan/Test-Harness/lib/Test/Harness.pm];print Test::Harness->VERSION" 2>&1]
[2018-08-09 22:45:08+0200] Found: Test::Harness version 3.42.
[2018-08-09 22:45:08+0200] Reading build configurations from /pro/3gl/CPAN/smoke/p59.cfg
[2018-08-09 22:45:08+0200] Reading 'Policy.sh' from ../Policy.sh (v=1)
[2018-08-09 22:45:08+0200] Running test suite only with 'harness'
[2018-08-09 22:45:08+0200] make distclean ...
[2018-08-09 22:45:08+0200] Smoking patch ce6f496d720f6206455628425320badd95b07372 v5.29.1-85-gce6f496d72
[2018-08-09 22:45:08+0200] Smoking branch blead
[2018-08-09 22:45:09+0200] Locally applied patches from '/pro/3gl/CPAN/perl-current/patchlevel.h'
[2018-08-09 22:45:09+0200] Patches: 'uncommitted-changes'
[2018-08-09 22:45:09+0200] Adding 'SMOKEce6f496d720f6206455628425320badd95b07372' to the registered patches.
[2018-08-09 22:45:09+0200] 
[2018-08-09 22:45:09+0200] Configuration: -Dusedevel
[2018-08-09 22:45:09+0200] ------------------------------------------------------------------------------
[2018-08-09 22:45:09+0200] make distclean ...
[2018-08-09 22:45:09+0200] 
[2018-08-09 22:45:09+0200] Copy Policy.sh ...
[2018-08-09 22:45:09+0200] 
[2018-08-09 22:45:09+0200] Configure ...
5.29.2 <=> 5.026002
===== PROCURA Policy for hpux/ccache cc ========================
===== PROCURA Policy results ============================
cc:         ccache cc
ccversion:  -
gccversion: -
ccflags:     +Z -z
optimize:   
ld:         
ldflags:    -L/pro/local/lib
libswanted: cl pthread cl pthread socket bind inet nsl ndbm gdbm dbm db malloc dl ld sun m crypt sec util c cposix posix ucb bsd BSD
libsdirs:    /lib /pro/local/lib
locincpth:  /pro/local/include
loclibpth:  /pro/local/lib
useshrplib: 
===== PROCURA Policy done ===============================
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
[2018-08-09 22:46:32+0200] 
[2018-08-09 22:46:32+0200] make ...
"op.c", line 12320: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

"op.c", line 12996: warning #2111-D: statement is unreachable
  	} ((void)0);  
  	  ^

"op.c", line 15228: warning #2549-D: variable "defer_queue" is used before its value is set
                          defer_queue[(defer_base + defer_ix--) % 4];
                          ^

"op.c", line 16274: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"op.c", line 3183: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l)))) ? (size_t)(l) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)(argp->p), (l) * sizeof(char)));
                                                                                                                                                                                        ^

"op.c", line 5143: warning #4276-D: relational operator ">" always evaluates to 'false'
      PL_compiling.cop_warnings = (((PL_compiling . cop_warnings) == 0L || (PL_compiling . cop_warnings) == (((STRLEN*)0)+1) || (PL_compiling . cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_compiling . cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings)))) ? (size_t)(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings))),(const char*)(PL_compiling . cop_warnings), (sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 8048: warning #4276-D: relational operator ">" always evaluates to 'false'
      cop->cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 10502: warning #4276-D: relational operator ">" always evaluates to 'false'
  	 PL_compiling.cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"op.c", line 12436: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(end - s - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(end - s - 1)))) ? (size_t)(end - s - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(s+1),(const char*)(s+2), (end - s - 1) * sizeof(char)));
  		                                                                                                                                                                                                        ^

"op.c", line 12605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf+1),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"perl.c", line 3496: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

"perl.c", line 4578: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
            if (((((XPVHV*) (dups)->sv_any)->xhv_keys) - (((XPVMG*) (dups)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)dups) : 0))) {
                                                           ^

"gv.c", line 118: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(tmpbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen)))) ? (size_t)(tmplen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"gv.c", line 1464: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(tmpbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen)))) ? (size_t)(tmplen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"gv.c", line 1465: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(namelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(namelen)))) ? (size_t)(namelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf),(const char*)(name), (namelen) * sizeof(char)));
                                                                                                                                                                                              ^

"gv.c", line 1657: warning #4276-D: relational operator ">" always evaluates to 'false'
                              (tmpfullbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(full_len+2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(full_len+2)))) ? (size_t)(full_len+2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((full_len+2)*sizeof(char))))));
                                                                                                                                                                                                                                             ^

"gv.c", line 1660: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*len)))) ? (size_t)(*len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf),(const char*)(*name), (*len) * sizeof(char)));
                                                                                                                                                                                                     ^

"toke.c", line 1036: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(bufptr+len+highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1062: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(bufptr+len-highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1082: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(bufptr+len),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1085: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bufptr),(const char*)(pv), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 1180: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufend+1-ptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufend+1-ptr)))) ? (size_t)(bufend+1-ptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(buf),(const char*)(ptr), (bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                             ^

"toke.c", line 1258: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-ptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-ptr)))) ? (size_t)(PL_parser->bufend+1-ptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(buf),(const char*)(ptr), (PL_parser->bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                                                              ^

"toke.c", line 1810: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (tmpbuf2 = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen2 + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen2 + 2)))) ? (size_t)(tmplen2 + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen2 + 2)*sizeof(char))))));
  		                                                                                                                                                                                                                   ^

"toke.c", line 3718: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(e - orig_s + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(e - orig_s + 1)))) ? (size_t)(e - orig_s + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(orig_s), (e - orig_s + 1) * sizeof(char)));
                                                                                                                                                                                                                                       ^

"toke.c", line 3809: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(initial_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(initial_len)))) ? (size_t)(initial_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(initial_text), (initial_len) * sizeof(char)));
                                                                                                                                                                                                                                      ^

"toke.c", line 3860: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_length)))) ? (size_t)(output_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                            ^

"toke.c", line 3881: warning #4276-D: relational operator ">" always evaluates to 'false'
                                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_length)))) ? (size_t)(output_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                                ^

"toke.c", line 3950: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(str), (len) * sizeof(char)));
  			                                                                                                                                                                            ^

"toke.c", line 4031: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                      ^

"toke.c", line 4093: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                              ^

"toke.c", line 4837: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  			                                                                                                                                                                                                                                                                                            ^

"toke.c", line 4916: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((PL_parser->lex_casestack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_casemods) + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_casemods) + 2)))) ? (size_t)((PL_parser->lex_casemods) + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_casestack)),(size_t)(((PL_parser->lex_casemods) + 2)*sizeof(char))))));
  		                                                                                                                                                                                                                                                                                            ^

"toke.c", line 5036: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                              ^

"toke.c", line 5887: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                ^

"toke.c", line 6137: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                ^

"toke.c", line 7179: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf+1),(const char*)((PL_parser->tokenbuf)), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 7774: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(olen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(olen)))) ? (size_t)(olen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((PL_parser->tokenbuf)),(const char*)((PL_parser->bufptr)), (olen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"toke.c", line 9163: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s - w) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s - w)))) ? (size_t)(s - w) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf+1),(const char*)(w), (s - w) * sizeof(char)));
  		                                                                                                                                                                                  ^

"toke.c", line 9342: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(t - *s) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(t - *s)))) ? (size_t)(t - *s) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(*d),(const char*)(*s), (t - *s) * sizeof(char)));
                                                                                                                                                                                                   ^

"toke.c", line 9376: warning #4276-D: relational operator ">" always evaluates to 'false'
          (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*s - olds + saw_tick + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*s - olds + saw_tick + 2)))) ? (size_t)(*s - olds + saw_tick + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((*s - olds + saw_tick + 2)*sizeof(char))))));  
                                                                                                                                                                                                                                                          ^

"toke.c", line 10031: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"toke.c", line 10151: warning #4276-D: relational operator ">" always evaluates to 'false'
  			(indent = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(indent_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(indent_len + 1)))) ? (size_t)(indent_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((indent_len + 1)*sizeof(char))))));
  			                                                                                                                                                                                                                       ^

"toke.c", line 10203: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufend-s + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufend-s + 1)))) ? (size_t)(bufend-s + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (bufend-s + 1) * sizeof(char)));
  	                                                                                                                                                                                                       ^

"toke.c", line 10287: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (indent = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(indent_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(indent_len + 1)))) ? (size_t)(indent_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((indent_len + 1)*sizeof(char))))));
  		                                                                                                                                                                                                                           ^

"toke.c", line 10367: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { const STRLEN _lEnGtH = ((XPV*) (tmpstr)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (tmpstr)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((tmpstr))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((tmpstr)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"toke.c", line 10647: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(termlen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(termlen)))) ? (size_t)(termlen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(termstr),(const char*)(s), (termlen) * sizeof(U8)));
  	                                                                                                                                                                                    ^

"toke.c", line 10816: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)))))); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"toke.c", line 12245: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                            ^

"pad.c", line 2232: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (((XPVMG*) (proto)->sv_any)->xmg_u . xmg_magic)
           ^

"pad.c", line 2312: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVGV *" may cause misaligned access
  	else if (flags & 1) Perl_sv_sethek( retsv,(((XPVGV*)(cv)->sv_any)->xiv_u . xivu_namehek));
  	                                            ^

"pad.c", line 2746: warning #4276-D: relational operator ">" always evaluates to 'false'
      (alloc2 = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1)))) ? (size_t)(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1),sizeof(char)))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^

"pad.c", line 2753: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((pn)->xpadn_pv),(const char*)(s), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"regcomp.c", line 3486: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    (((((struct regnode_1 *)convert)->arg1)) = ((data_slot)));
  	        ^

"regcomp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(((struct regnode_charclass *)convert)->bitmap),(const char*)(trie ->bitmap), (((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                                                    ^

"regcomp.c", line 3616: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U32 trie_offset = ((((struct regnode_1 *)source)->arg1));
                                 ^

"regcomp.c", line 3641: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (*((struct regnode_1*)(op)) = *((struct regnode_1*)(source)));
                                          ^

"regcomp.c", line 3646: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
          (*((struct regnode_charclass*)(op)) = *((struct regnode_charclass*)(source)));
                                                  ^

"regcomp.c", line 3651: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      (((((struct regnode_1 *)stclass)->arg1)) = ((data_slot)));
          ^

"regcomp.c", line 4206: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      I32 is_par = ((scan)->type) == 52 ? ((((struct regnode_1 *)scan)->arg1)) : 0;
                                             ^

"regcomp.c", line 4287: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    int off = (reg_off_by_arg[((scan)->type)] ? ((((struct regnode_1 *)scan)->arg1)) : ((scan)->next_off));
  	                                                   ^

"regcomp.c", line 4294: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((((n)->type) == 66) && (noff = ((((struct regnode_1 *)n)->arg1)))))
  		                                             ^

"regcomp.c", line 4298: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		((((struct regnode_1 *)scan)->arg1)) = off;
  		   ^

"regcomp.c", line 4815: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  paren = ((((struct regnode_1 *)scan)->arg1));
                             ^

"regcomp.c", line 4816: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  (pRExC_state ->recurse)[((((struct regnode_2L *)scan)->arg2))] = scan;
                                             ^

"regcomp.c", line 5219: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          (pRExC_state ->open_parens)[((((struct regnode_1 *)nxt1)->arg1))]=oscan;  
                                                         ^

"regcomp.c", line 5220: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          (pRExC_state ->close_parens)[((((struct regnode_1 *)nxt1)->arg1))]=nxt+2;  
                                                          ^

"regcomp.c", line 5223: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    oscan->flags = (U8)((((struct regnode_1 *)nxt)->arg1));
  		                          ^

"regcomp.c", line 5264: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			oscan->flags = (U8)((((struct regnode_1 *)nxt)->arg1));
  			                      ^

"regcomp.c", line 5266: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              (pRExC_state ->open_parens)[((((struct regnode_1 *)nxt1)->arg1))]=oscan;  
                                                             ^

"regcomp.c", line 5267: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              (pRExC_state ->close_parens)[((((struct regnode_1 *)nxt1)->arg1))]=nxt2+1;  
                                                              ^

"regcomp.c", line 5312: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			nxt += ((((struct regnode_1 *)nxt)->arg1));
  			          ^

"regcomp.c", line 5547: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  			S_ssc_and( pRExC_state,data->start_class,(regnode_charclass *) scan);
  			                                         ^

"regcomp.c", line 5550: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  			S_ssc_or( pRExC_state,data->start_class,(regnode_charclass *) scan);
  			                                        ^

"regcomp.c", line 5855: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen != (I32)((((struct regnode_1 *)scan)->arg1)))
  	                             ^

"regcomp.c", line 5859: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen == (I32)((((struct regnode_1 *)scan)->arg1))) {
  	                             ^

"regcomp.c", line 5862: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if ((I32)((((struct regnode_1 *)scan)->arg1)) == is_par) {
  	                ^

"regcomp.c", line 5869: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		*(data->last_closep) = ((((struct regnode_1 *)scan)->arg1));
  		                          ^

"regcomp.c", line 5918: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_trie_data *trie = (reg_trie_data*)(pRExC_state ->rxi)->data->data[ ((((struct regnode_1 *)scan)->arg1)) ];
                                                                                        ^

"regcomp.c", line 6117: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"regcomp.c", line 7514: warning #2187-D: use of "=" where "==" may have been intended
  	while ((((first)->type) == 52 && (sawopen = 1)) ||
  	                                 ^

"regcomp.c", line 7518: warning #2187-D: use of "=" where "==" may have been intended
  	    (((first)->type) == 68 && !first->flags && (sawlookahead = 1)) ||
  	                                               ^

"regcomp.c", line 7554: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        ((reg_trie_data *)ri->data->data[ ((((struct regnode_1 *)first)->arg1)) ])->minlen>0)
  	                                             ^

"regcomp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          (((((struct regnode_2L *)scan)->arg2)) = (((pRExC_state ->open_parens)[((((struct regnode_1 *)scan)->arg1))] - scan)));
              ^

"regcomp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (((((struct regnode_2L *)scan)->arg2)) = (((pRExC_state ->open_parens)[((((struct regnode_1 *)scan)->arg1))] - scan)));
                                                                                    ^

"regcomp.c", line 11020: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      ((((struct regnode_1 *)ret)->arg1)) = S_add_data( pRExC_state,
                         ^

"regcomp.c", line 11022: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      (pRExC_state ->rxi)->data->data[((((struct regnode_1 *)ret)->arg1))]=(void*)sv;
                                                         ^

"regcomp.c", line 11028: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      (((((struct regnode_2L *)ret)->arg2)) = ((internal_argval)));
                          ^

"regcomp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(((regnode_charclass*)(node))->bitmap),0,(((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                             ^

"regcomp.c", line 14382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (! (((( (U8*) ((regnode_charclass*)(node))->bitmap) [ ( ( (UV) (i)) >> 3) ] ) & (1U << ((i) & 7))) ? (_Bool)1 : (_Bool)0)) {
  		                  ^

"regcomp.c", line 14383: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		    ((( (U8*) ((regnode_charclass*)(node))->bitmap) [ ( ( (UV) (i)) >> 3) ] ) |= (1U << ((i) & 7)));
  		               ^

"regcomp.c", line 17142: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      do { ((regnode_charclass_posixl*) (ret))->classflags = 0; } while (0);
                            ^

"regcomp.c", line 17159: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      && (((regnode_charclass_posixl*) (ret))->classflags & (1U << (namedclass + ((namedclass % 2) ? -1 : 1)))))
                           ^

"regcomp.c", line 17170: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                  (((regnode_charclass_posixl*) (ret))->classflags |= (1U << (namedclass)));
                    ^

"regcomp.c", line 18705: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	(((((struct regnode_1 *)node)->arg1)) = ((((U32) -1))));
  	    ^

"regcomp.c", line 18736: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	(((((struct regnode_1 *)node)->arg1)) = ((n)));
  	    ^

"regcomp.c", line 18787: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	const U32 n = ((((struct regnode_1 *)node)->arg1));
  	                 ^

"regcomp.c", line 19174: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 1; } while (0);
                   ^

"regcomp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg1))); (((((struct regnode_2L *)ptr)->arg2)) = ((arg2))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 2; } while (0);
                   ^

"regcomp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg1))); (((((struct regnode_2L *)ptr)->arg2)) = ((arg2))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 2; } while (0);
                                                                     ^

"regcomp.c", line 19348: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (((((struct regnode_1 *)scan)->arg1)) = ((val - scan)));
              ^

"regcomp.c", line 19463: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U8 lowest = (U8) ((((struct regnode_1 *)n)->arg1));
                                ^

"regcomp.c", line 19473: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ((i & ((n)->flags)) == ((((struct regnode_1 *)n)->arg1))) {
                                       ^

"regcomp.c", line 20632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      offset = (reg_off_by_arg[((p)->type)] ? ((((struct regnode_1 *)p)->arg1)) : ((p)->next_off));
                                                 ^

"regcomp.c", line 3913: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((((struct regnode_string *)n)->str_len)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((((struct regnode_string *)n)->str_len))))) ? (size_t)((((struct regnode_string *)n)->str_len)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)((((struct regnode_string *)scan)->string) + oldl),(const char*)((((struct regnode_string *)n)->string)), ((((struct regnode_string *)n)->str_len)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                      ^

"regcomp.c", line 3977: warning #4276-D: relational operator ">" always evaluates to 'false'
                  (folded = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(3 * (((struct regnode_string *)scan)->str_len) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(3 * (((struct regnode_string *)scan)->str_len) + 1)))) ? (size_t)(3 * (((struct regnode_string *)scan)->str_len) + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((3 * (((struct regnode_string *)scan)->str_len) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                 ^

"regcomp.c", line 3982: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s_len)))) ? (size_t)(s_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s_len)))) ? (size_t)(s_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 4863: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 4865: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((pRExC_state ->study_chunk_recursed) + (recursed_depth * (pRExC_state ->study_chunk_recursed_bytes))),(const char*)((pRExC_state ->study_chunk_recursed) + ((recursed_depth-1) * (pRExC_state ->study_chunk_recursed_bytes))), ((pRExC_state ->study_chunk_recursed_bytes)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 6127: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi)->data = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1))))) ? (size_t)(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (struct reg_data*)(Perl_safesysrealloc((void *)((pRExC_state ->rxi)->data),(size_t)((sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"regcomp.c", line 6131: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((pRExC_state ->rxi)->data->what = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(count + n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(count + n)))) ? (size_t)(count + n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)((pRExC_state ->rxi)->data->what),(size_t)((count + n)*sizeof(U8))))));
  	                                                                                                                                                                                                                             ^

"regcomp.c", line 6133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((pRExC_state ->rxi)->data->what = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((n)*sizeof(U8))))));
  	                                                                                                                                                                                                     ^

"regcomp.c", line 6135: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((pRExC_state ->rxi)->data->what + count),(const char*)(s), (n) * sizeof(U8)));
                                                                                                                                                                        ^

"regcomp.c", line 6312: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*plen_p * 2 + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*plen_p * 2 + 1)))) ? (size_t)(*plen_p * 2 + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((*plen_p * 2 + 1)*sizeof(U8))))));
                                                                                                                                                                                                                         ^

"regcomp.c", line 6672: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(newpat = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(newlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(newlen)))) ? (size_t)(newlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((newlen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"regcomp.c", line 7278: warning #4276-D: relational operator ">" always evaluates to 'false'
      (ri = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode))))) ? (size_t)(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (regexp_internal*)(Perl_safesysmalloc((size_t)((sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                             ^

"regcomp.c", line 7347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"regcomp.c", line 7362: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(plen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(plen)))) ? (size_t)(plen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)((pRExC_state ->precomp)), (plen) * sizeof(char)));
                                                                                                                                                                                         ^

"regcomp.c", line 7427: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((pRExC_state ->study_chunk_recursed) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)(((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                                                                    ^

"regcomp.c", line 7455: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                                                                            ^

"regcomp.c", line 8708: warning #4276-D: relational operator ">" always evaluates to 'false'
      do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (invlist)->sv_any)->xpv_len_u . xpvlenu_len = ((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))); } while (0); do { ((void)0); ((void)0); ((void)0); (((invlist))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))))) ? (size_t)((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((invlist)->sv_u . svu_pv), (size_t)(((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))))))); } while (0); } while (0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ^

"regcomp.c", line 9975: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(physical_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(physical_length)))) ? (size_t)(physical_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(((new_invlist)->sv_u . svu_pv)),(const char*)(((invlist)->sv_u . svu_pv)), (physical_length) * sizeof(char)));
                                                                                                                                                                                                                      ^

"regcomp.c", line 12729: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((((struct regnode_string *)node)->string)),(const char*)((char *) character), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"regcomp.c", line 20656: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l1)))) ? (size_t)(l1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(buf),(const char*)(pat1), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 20657: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l2)))) ? (size_t)(l2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(buf + l1),(const char*)(pat2), (l2) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 20666: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l1)))) ? (size_t)(l1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(buf),(const char*)(message), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 21596: warning #4276-D: relational operator ">" always evaluates to 'false'
      (lookup_name = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                                 ^

"dump.c", line 1967: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	usedkeys = ((((XPVHV*) (((HV *)((void *) (sv))))->sv_any)->xhv_keys) - (((XPVMG*) (((HV *)((void *) (sv))))->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)((HV *)((void *) (sv)))) : 0));
  	                                                                         ^

"dump.c", line 2672: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2681: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2692: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2702: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2710: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"util.c", line 1053: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(pvlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(pvlen)))) ? (size_t)(pvlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((pvlen)*sizeof(char))))));
  	                                                                                                                                                                                             ^

"util.c", line 1084: warning #4276-D: relational operator ">" always evaluates to 'false'
      (newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len+1)*sizeof(char))))));
                                                                                                                                                                                                   ^

"util.c", line 1089: warning #4276-D: relational operator ">" always evaluates to 'false'
      	return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(newaddr),(const char*)(pv), (len) * sizeof(char)));
      	                                                                                                                                                                                            ^

"util.c", line 1092: warning #4276-D: relational operator ">" always evaluates to 'false'
  	return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), memset((char*)(newaddr),0,(len+1) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"util.c", line 1170: warning #4276-D: relational operator ">" always evaluates to 'false'
      (newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                             ^

"util.c", line 1171: warning #4276-D: relational operator ">" always evaluates to 'false'
      return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(newaddr),(const char*)(pv), (len) * sizeof(char)));
                                                                                                                                                                                                  ^

"util.c", line 2047: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((buffer + 1)),(const char*)(bits), (size) * sizeof(char)));
                                                                                                                                                                                     ^

"util.c", line 2049: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(18 - size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(18 - size)))) ? (size_t)(18 - size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)((char *)(buffer + 1) + size),0,(18 - size) * sizeof(char)));
  	                                                                                                                                                                                              ^

"util.c", line 2150: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpenv[j]),(const char*)(environ[j]), (len+1) * sizeof(char)));
                                                                                                                                                                                                    ^

"util.c", line 2181: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]),(const char*)(nam), (nlen) * sizeof(char))); *(environ[i]+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                         ^

"util.c", line 2181: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]),(const char*)(nam), (nlen) * sizeof(char))); *(environ[i]+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ^

"util.c", line 2207: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env),(const char*)(nam), (nlen) * sizeof(char))); *(new_env+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                             ^

"util.c", line 2207: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env),(const char*)(nam), (nlen) * sizeof(char))); *(new_env+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"util.c", line 3839: warning #4276-D: relational operator ">" always evaluates to 'false'
    (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(buflen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(buflen)))) ? (size_t)(buflen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((buflen)*sizeof(char))))));
                                                                                                                                                                                                ^

"util.c", line 3866: warning #4276-D: relational operator ">" always evaluates to 'false'
      (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufsize)))) ? (size_t)(bufsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(buf),(size_t)((bufsize)*sizeof(char))))));
                                                                                                                                                                                                     ^

"util.c", line 3882: warning #4276-D: relational operator ">" always evaluates to 'false'
        (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufsize)))) ? (size_t)(bufsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(buf),(size_t)((bufsize)*sizeof(char))))));
                                                                                                                                                                                                       ^

"vutil.c", line 335: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    || (((rev) < 0 ? -(rev) : (rev)) > 0x7FFFFFFF )) {
  			                                     ^

"vutil.c", line 535: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(raw + len - under - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(raw + len - under - 1)))) ? (size_t)(raw + len - under - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(under),(const char*)(under + 1), (raw + len - under - 1) * sizeof(char)));
  		                                                                                                                                                                                                                                  ^

"vutil.c", line 585: warning #4276-D: relational operator ">" always evaluates to 'false'
  	   || (((ver)->sv_flags & 0x00000100) && ((XPVIV*) (ver)->sv_any)->xiv_u . xivu_iv > 0x7FFFFFFF) ) {
  	                                                                                   ^

"mg.c", line 1842: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	     i = ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0));
  	                                                  ^

"mg.c", line 2770: warning #2191-D: type qualifier is meaningless on cast type
              (((S_ReANY((const REGEXP *)((REGEXP * const)rx)))->engine))->numbered_buff_STORE( ((REGEXP * const)rx),(paren),(sv));
                                           ^

"mg.c", line 2770: warning #2191-D: type qualifier is meaningless on cast type
              (((S_ReANY((const REGEXP *)((REGEXP * const)rx)))->engine))->numbered_buff_STORE( ((REGEXP * const)rx),(paren),(sv));
                                                                                                  ^

"mro_core.c", line 579: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	    if (!((revstash)->sv_flags & 0x00100000)) ((XPVMG*) (revstash)->sv_any)->xmg_stash = 0L;
  	                                               ^

"mro_core.c", line 707: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
                  if(!((isarev)->sv_u . svu_hash) || !((((XPVHV*) (isarev)->sv_any)->xhv_keys) - (((XPVMG*) (isarev)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)isarev) : 0)))
                                                                                                   ^

"mro_core.c", line 1113: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if(oldstash && ((((XPVHV*) (oldstash)->sv_any)->xhv_keys) - (((XPVMG*) (oldstash)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)oldstash) : 0))) {
                                                                    ^

"mro_core.c", line 1199: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (stash && ((((XPVHV*) (stash)->sv_any)->xhv_keys) - (((XPVMG*) (stash)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)stash) : 0))) {
                                                               ^

"hv.c", line 888: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          const U32 items = (U32)(((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0);
                                   ^

"hv.c", line 918: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      const MAGIC *mg = ((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic;
                         ^

"hv.c", line 965: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      Perl_sv_setuv( sv,((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get((const HV *)hv) : 0)));
                                                                 ^

"hv.c", line 1014: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          size_t nkeys = ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0));
                                                                  ^

"hv.c", line 1071: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (((((XPVHV*) ((HV *)hv)->sv_any)->xhv_keys) - (((XPVMG*) ((HV *)hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(HV *)hv) : 0))) {
                                                         ^

"hv.c", line 1870: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      const U32 items = (U32)(((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0);
                               ^

"hv.c", line 1909: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		    I32 placeholders = (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0);
  		                         ^

"hv.c", line 2783: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	? (((XPVHV*) (hv)->sv_any)->xhv_keys) : ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0))) {
  	                                                                                 ^

"hv.c", line 88: warning #4276-D: relational operator ">" always evaluates to 'false'
      (k = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2)))) ? (size_t)(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2)*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                 ^

"hv.c", line 90: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((hek)->hek_key),(const char*)(str), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"hv.c", line 357: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((hv)->sv_flags & 0xff)) == (svtype)0xff)
                                            ^

"hv.c", line 588: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((xhv->xhv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((xhv->xhv_max+1) * sizeof(HE*)))))) ? (size_t)(((xhv->xhv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((xhv->xhv_max+1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                                                ^

"hv.c", line 812: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((xhv->xhv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((xhv->xhv_max+1) * sizeof(HE*)))))) ? (size_t)(((xhv->xhv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((xhv->xhv_max+1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                                            ^

"hv.c", line 1429: warning #4276-D: relational operator ">" always evaluates to 'false'
      (a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0))))) ? (size_t)(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(a),(size_t)((((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                       ^

"hv.c", line 1478: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((newsize -oldsize) * sizeof(HE*)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((newsize -oldsize) * sizeof(HE*))))) ? (size_t)((newsize -oldsize) * sizeof(HE*)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(&a[oldsize * sizeof(HE*)]),0,((newsize -oldsize) * sizeof(HE*)) * sizeof(char)));	 
                                                                                                                                                                                                                                                                         ^

"hv.c", line 1567: warning #4276-D: relational operator ">" always evaluates to 'false'
          (a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((newsize) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((newsize) * sizeof(HE*)))))) ? (size_t)(((newsize) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((newsize) * sizeof(HE*))),sizeof(char)))));
                                                                                                                                                                                                                                                             ^

"hv.c", line 1605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((hv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((hv_max+1) * sizeof(HE*)))))) ? (size_t)(((hv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((hv_max+1) * sizeof(HE*)))*sizeof(char))))));
  	                                                                                                                                                                                                                                                      ^

"hv.c", line 2238: warning #4276-D: relational operator ">" always evaluates to 'false'
              (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))))) ? (size_t)(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)),sizeof(char)))));
                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"hv.c", line 2242: warning #4276-D: relational operator ">" always evaluates to 'false'
              (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))))) ? (size_t)(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(array),(size_t)((((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"hv.c", line 3127: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(k = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2)))) ? (size_t)(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"hv.c", line 3133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((hek)->hek_key),(const char*)(str), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"hv.c", line 3276: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((max + 1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((max + 1) * sizeof(HE*)))))) ? (size_t)(((max + 1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((max + 1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                       ^

"hv.c", line 3401: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (q = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(keylen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(keylen)))) ? (size_t)(keylen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((keylen)*sizeof(char))))));
  	                                                                                                                                                                                              ^

"hv.c", line 3577: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (q = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(keylen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(keylen)))) ? (size_t)(keylen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((keylen)*sizeof(char))))));
  	                                                                                                                                                                                              ^

"hv.c", line 3613: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(value_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(value_len + 1)))) ? (size_t)(value_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(he ->refcounted_he_data + 1),(const char*)(value_p), (value_len + 1) * sizeof(char)));
  	                                                                                                                                                                                                          ^

"av.c", line 363: warning #4232-D: conversion from "XPVAV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	const MAGIC *mg = ((XPVMG*) (av)->sv_any)->xmg_u . xmg_magic;
  	                   ^

"av.c", line 476: warning #4232-D: conversion from "XPVAV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	const MAGIC* const mg = ((XPVMG*) (av)->sv_any)->xmg_u . xmg_magic;
  	                         ^

"pp_hot.c", line 1812: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          i = ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0));
                                                       ^

"pp_hot.c", line 2579: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              if (((hash)->sv_flags & 0x00800000) || ((((XPVHV*) (hash)->sv_any)->xhv_keys) - (((XPVMG*) (hash)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hash) : 0)))
                                                                                                ^

"pp_hot.c", line 2733: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              if (((lsv)->sv_flags & 0x00800000) || ((((XPVHV*) ((HV*)lsv)->sv_any)->xhv_keys) - (((XPVMG*) ((HV*)lsv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(HV*)lsv) : 0)))
                                                                                                   ^

"pp_hot.c", line 3088: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"pp_hot.c", line 803: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(targ_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(targ_len)))) ? (size_t)(targ_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(targ_buf),(const char*)(targ_pv), (targ_len) * sizeof(char)));
                                                                                                                                                                                                             ^

"pp_hot.c", line 854: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(targ_pv),(const char*)(svpv_p->pv), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"pp_hot.c", line 870: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(targ_pv),(const char*)(const_pv), (len) * sizeof(char)));
                                                                                                                                                                                              ^

"pp_hot.c", line 882: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(targ_pv),(const char*)(svpv_p->pv), (len) * sizeof(char)));
                                                                                                                                                                                              ^

"pp_hot.c", line 3297: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                              ^

"pp_hot.c", line 3306: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (new_len)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_len)))) ? (size_t)(new_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((new_len)))))); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                  ^

"pp_hot.c", line 4301: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(m),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4306: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(m),(const char*)(d), (i) * sizeof(char)));
  		                                                                                                                                                                          ^

"pp_hot.c", line 4316: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d - i),(const char*)(s), (i) * sizeof(char)));
                                                                                                                                                                                            ^

"pp_hot.c", line 4319: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4337: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(char)));
  			                                                                                                                                                                      ^

"pp_hot.c", line 4341: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4352: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i+1)))) ? (size_t)(i+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i+1) * sizeof(char)));		 
  		                                                                                                                                                                            ^

"sv.c", line 1459: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	    do { ((void)0); (((XPVMG*) (io)->sv_any)->xmg_stash = (((HV *)((void *) (S_SvREFCNT_inc(((SV *)((void *) ((((0+(iogv)->sv_u . svu_gp))->gp_hv)))))))))); } while (0);
  	                      ^

"sv.c", line 16330: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"sv.c", line 16433: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"sv.c", line 16640: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"sv.c", line 472: warning #4275-D: constant out of range ([0 - 16]) for the operator
  	    if (((svtype)((sv)->sv_flags & 0xff)) != (svtype)0xff
  	                                          ^

"sv.c", line 1108: warning #4276-D: relational operator ">" always evaluates to 'false'
      (adesc->arena = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(good_arena_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(good_arena_size)))) ? (size_t)(good_arena_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((good_arena_size)*sizeof(char))))));
                                                                                                                                                                                                                                      ^

"sv.c", line 1343: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_type_details->body_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_type_details->body_size)))) ? (size_t)(new_type_details->body_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                    ^

"sv.c", line 1413: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_type_details->body_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_type_details->body_size)))) ? (size_t)(new_type_details->body_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                        ^

"sv.c", line 1434: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(length)))) ? (size_t)(length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((char *)new_body + offset),(const char*)((char *)old_body + offset), (length) * sizeof(char)));
  	                                                                                                                                                                                         ^

"sv.c", line 1519: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_cur+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_cur+1)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_cur+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (((XPV*) (sv)->sv_any)->xpv_cur+1) * sizeof(char)));
                                                                                                                                                                                                                                                                         ^

"sv.c", line 1602: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_cur)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(s),(const char*)(((const char*)(0 + (sv)->sv_u . svu_pv))), (((XPV*) (sv)->sv_any)->xpv_cur) * sizeof(char)));
                                                                                                                                                                                                                                                                               ^

"sv.c", line 3039: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(buffer = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
  		                                                                                                                                                                                      ^

"sv.c", line 3097: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(s),(const char*)(ptr), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 4386: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(((dstr)->sv_u . svu_pv)),(const char*)(ptr), (len + 1) * sizeof(char)));
                                                                                                                                                                                                      ^

"sv.c", line 4641: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cur)))) ? (size_t)(cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((dstr)->sv_u . svu_pv)),(const char*)(((const char*)(0 + (sstr)->sv_u . svu_pv))), (cur) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 4905: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(dptr),(const char*)(ptr), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 4956: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 5161: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cur)))) ? (size_t)(cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (cur) * sizeof(char)));
                                                                                                                                                                                              ^

"sv.c", line 5345: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 5440: warning #4276-D: relational operator ">" always evaluates to 'false'
        ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(slen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(slen)))) ? (size_t)(slen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((dsv)->sv_u . svu_pv) + dlen),(const char*)(sstr), (slen) * sizeof(char)));
                                                                                                                                                                                       ^

"sv.c", line 5532: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)+tlen),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 6311: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(offset+len-curlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(offset+len-curlen)))) ? (size_t)(offset+len-curlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(((bigstr)->sv_u . svu_pv)+curlen),0,(offset+len-curlen) * sizeof(char)));
  	                                                                                                                                                                                                                      ^

"sv.c", line 6325: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(big+offset),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 6331: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((bigstr)->sv_u . svu_pv)+offset),(const char*)(little), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 6347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6352: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(mid),(const char*)(midend), (i) * sizeof(char)));
  	                                                                                                                                                                          ^

"sv.c", line 6361: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(midend - i),(const char*)(big), (i) * sizeof(char)));
  	                                                                                                                                                                      ^

"sv.c", line 6364: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6369: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(midend),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 8645: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(got) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(got)))) ? (size_t)(got) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bp),(const char*)(ptr), (got) * sizeof(unsigned char)));
                                                                                                                                                                                                                    ^

"sv.c", line 8651: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cnt) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cnt)))) ? (size_t)(cnt) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(unsigned char)));
                                                                                                                                                                                                                ^

"sv.c", line 8658: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cnt) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cnt)))) ? (size_t)(cnt) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(char)));	      
  	                                                                                                                                                                                    ^

"sv.c", line 9708: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((old)->sv_flags & 0xff)) == (svtype)0xff) {
                                             ^

"sv.c", line 10042: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 10934: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(end),(const char*)(buf), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 11676: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vn - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vn - 1)))) ? (size_t)(vn - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(v0 + 1),(const char*)(v0), (vn - 1) * sizeof(char)));
                                                                                                                                                                                                               ^

"sv.c", line 11719: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)(r), (n) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 11768: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nmove) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nmove)))) ? (size_t)(nmove) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(zerox + nzero),(const char*)(zerox), (nmove) * sizeof(char)));
                                                                                                                                                                                                ^

"sv.c", line 11773: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(buf + gap),(const char*)(buf), (elen) * sizeof(char)));
                                                                                                                                                                                             ^

"sv.c", line 13031: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(PL_efloatbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_efloatsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_efloatsize)))) ? (size_t)(PL_efloatsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((PL_efloatsize)*sizeof(char))))));
  		                                                                                                                                                                                                                          ^

"sv.c", line 13273: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 13294: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 15962: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len + 1) * sizeof(char)));
  	                                                                                                                                                                                            ^

"pp.c", line 2177: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"pp.c", line 6745: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          if (((targ)->sv_flags & 0x00800000) || ((((XPVHV*) ((HV*)targ)->sv_any)->xhv_keys) - (((XPVMG*) ((HV*)targ)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(HV*)targ) : 0))) {
                                                                                                 ^

"pp.c", line 3903: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tculen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tculen)))) ? (size_t)(tculen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  	                                                                                                                                                                                     ^

"pp.c", line 3916: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tculen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tculen)))) ? (size_t)(tculen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  		                                                                                                                                                                                 ^

"pp.c", line 3933: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(slen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(slen)))) ? (size_t)(slen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d + 1),(const char*)(s + 1), (slen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4037: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(capital_iota_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(capital_iota_len)))) ? (size_t)(capital_iota_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)("\xCE\x99"), (capital_iota_len) * sizeof(U8)));
  		                                                                                                                                                                                                               ^

"pp.c", line 4071: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                             ^

"pp.c", line 4077: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(capital_iota_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(capital_iota_len)))) ? (size_t)(capital_iota_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)("\xCE\x99"), (capital_iota_len) * sizeof(U8)));
                                                                                                                                                                                                                             ^

"pp.c", line 4295: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4495: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                         ^

"pp.c", line 4542: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(small_mu_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(small_mu_len)))) ? (size_t)(small_mu_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)("\xCE\xBC"), (small_mu_len) * sizeof(U8)));
                                                                                                                                                                                                                         ^

"pp.c", line 4559: warning #4276-D: relational operator ">" always evaluates to 'false'
                              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                                         ^

"scope.c", line 385: warning #4232-D: conversion from "XPVAV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (__builtin_expect(((((XPVMG*) (oav)->sv_any)->xmg_u . xmg_magic) ? (_Bool)1 : (_Bool)0),(0)))
                              ^

"scope.c", line 403: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (__builtin_expect(((((XPVMG*) (ohv)->sv_any)->xmg_u . xmg_magic) ? (_Bool)1 : (_Bool)0),(0)))
                              ^

"pp_ctl.c", line 290: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"pp_ctl.c", line 4914: warning #4232-D: conversion from "XPVHV *const" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		else if(((((XPVHV*) ((const HV *) hv)->sv_any)->xhv_keys) - (((XPVMG*) ((const HV *) hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(const HV *) hv) : 0)) != ((((XPVHV*) (other_hv)->sv_any)->xhv_keys) - (((XPVMG*) (other_hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)other_hv) : 0)))
  		                                                              ^

"pp_ctl.c", line 4914: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		else if(((((XPVHV*) ((const HV *) hv)->sv_any)->xhv_keys) - (((XPVMG*) ((const HV *) hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(const HV *) hv) : 0)) != ((((XPVHV*) (other_hv)->sv_any)->xhv_keys) - (((XPVMG*) (other_hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)other_hv) : 0)))
  		                                                                                                                                                                                                                                      ^

"pp_ctl.c", line 4939: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		other_key_count = ((((XPVHV*) (other_hv)->sv_any)->xhv_keys) - (((XPVMG*) (other_hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)other_hv) : 0));
  		                                                                 ^

"pp_ctl.c", line 800: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(to_copy) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(to_copy)))) ? (size_t)(to_copy) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(t),(const char*)(source), (to_copy) * sizeof(char)));
  		                                                                                                                                                                                        ^

"pp_ctl.c", line 3479: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (((oldcurcop->cop_warnings) == 0L || (oldcurcop->cop_warnings) == (((STRLEN*)0)+1) || (oldcurcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(oldcurcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings)))) ? (size_t)(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings))),(const char*)(oldcurcop->cop_warnings), (sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"pp_sys.c", line 2997: warning #2186-D: pointless comparison of unsigned integer with zero
  	    neg = PL_statcache.st_ino < 0;
  	                              ^

"pp_sys.c", line 325: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"pp_sys.c", line 1237: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(fd_sets[i] = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(growsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(growsize)))) ? (size_t)(growsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((growsize)*sizeof(char))))));
  	                                                                                                                                                                                                         ^

"pp_sys.c", line 1825: warning #4276-D: relational operator ">" always evaluates to 'false'
      	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(offset-orig_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(offset-orig_size)))) ? (size_t)(offset-orig_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(buffer+orig_size),0,(offset-orig_size) * sizeof(char)));
      	                                                                                                                                                                                                                   ^

"doop.c", line 1299: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		i = ((((XPVHV*) (keys)->sv_any)->xhv_keys) - (((XPVMG*) (keys)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)keys) : 0));
  		                                               ^

"doop.c", line 71: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len*2+1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len*2+1)))) ? (size_t)(len*2+1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len*2+1)*sizeof(U8))))));
  	                                                                                                                                                                                             ^

"doop.c", line 87: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (ulen) * sizeof(U8)));
  		                                                                                                                                                                           ^

"doop.c", line 223: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len*2+1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len*2+1)))) ? (size_t)(len*2+1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len*2+1)*sizeof(U8))))));
  	                                                                                                                                                                                             ^

"doop.c", line 249: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                          ^

"doop.c", line 328: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len * 3 + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len * 3 + 13)))) ? (size_t)(len * 3 + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len * 3 + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 346: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  	                                                                                                                                                                      ^

"doop.c", line 363: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 491: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len * 3 + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len * 3 + 13)))) ? (size_t)(len * 3 + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len * 3 + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 510: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  		                                                                                                                                                                                                    ^

"doop.c", line 525: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  		                                                                                                                                                                  ^

"doop.c", line 544: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (len) * sizeof(U8)));
  			                                                                                                                                                                        ^

"doop.c", line 564: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  		                                                                                                                                                                                                    ^

"doop.c", line 576: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  		                                                                                                                                                                  ^

"doop.c", line 1135: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(dc = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(needlen + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(needlen + 1)))) ? (size_t)(needlen + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((needlen + 1),sizeof(char)))));
  	                                                                                                                                                                                                          ^

"doio.c", line 2299: warning #4276-D: relational operator ">" always evaluates to 'false'
      (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cmdlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cmdlen)))) ? (size_t)(cmdlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((cmdlen)*sizeof(char))))));
                                                                                                                                                                                                  ^

"doio.c", line 3177: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(msize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(msize)))) ? (size_t)(msize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(mbuf),(const char*)(shm + mpos), (msize) * sizeof(char)));
  	                                                                                                                                                                                  ^

"doio.c", line 3189: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(shm + mpos),(const char*)(mbuf), (n) * sizeof(char)));
  	                                                                                                                                                                      ^

"regexec.c", line 505: warning #2111-D: statement is unreachable
      return (0);  
      ^

"regexec.c", line 2227: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              do { while (s < strend) { if ((((( (U8*) ((regnode_charclass*)(c))->bitmap) [ ( ( (UV) (*((U8*)s))) >> 3) ] ) & (1U << ((*((U8*)s)) & 7))) ? (_Bool)1 : (_Bool)0)) { if ( ( doevery || s != previous_occurrence_end) && (reginfo->intuit || S_regtry( reginfo,&s))) { goto got_it; } s += ((0) ? PL_utf8skip[*(const U8*)(s)] : 1); previous_occurrence_end = s; } else { s += ((0) ? PL_utf8skip[*(const U8*)(s)] : 1); } } } while (0);
                                                        ^

"regexec.c", line 2233: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          while (s < strend) { s = ((char *) S_find_next_masked((U8 *) s, (U8 *) strend, (U8) ((((struct regnode_1 *)c)->arg1)), ((c)->flags))); if (s >= strend) { break; } if ( ( doevery || s != previous_occurrence_end) && (reginfo->intuit || S_regtry( reginfo,&s))) { goto got_it; } s += (0) ? PL_utf8skip[*(const U8*)(s)] : 1; previous_occurrence_end = s; };
                                                                                                 ^

"regexec.c", line 2872: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_ac_data *aho = (reg_ac_data*)progi->data->data[ ((((struct regnode_1 *)c)->arg1)) ];
                                                                     ^

"regexec.c", line 2910: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                      bitmap=(U8*)((regnode_charclass*)(c))->bitmap;
                                   ^

"regexec.c", line 4356: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      SV *sv_dat= ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                         ^

"regexec.c", line 5835: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 5841: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 5877: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              if(!(nextchr < 0) && !(((( (U8*) ((regnode_charclass*)(scan))->bitmap) [ ( ( (UV) (nextchr)) >> 3) ] ) & (1U << ((nextchr) & 7))) ? (_Bool)1 : (_Bool)0)) {
                                                ^

"regexec.c", line 5883: warning #2111-D: statement is unreachable
                  ((void)0);  
                  ^

"regexec.c", line 5937: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          	    = (reg_trie_data*)rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ];
          	                                           ^

"regexec.c", line 5938: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		HV * widecharmap = ((HV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) + 1 ])));
  		                                                          ^

"regexec.c", line 6083: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 6113: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = ((reg_trie_data*)rexi->data->data[((((struct regnode_1 *)st->u . trie . me)->arg1))])->wordinfo;
  		                                           ^

"regexec.c", line 6137: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = (reg_trie_data*)rexi->data->data[((((struct regnode_1 *)st->u . trie . me)->arg1))];
  		                                          ^

"regexec.c", line 6200: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 6702: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (!(((scan)->flags) ? S_reginclass( rex,scan,(U8*)locinput,(U8*)locinput+1,utf8_target) : (((( (U8*) ((regnode_charclass*)(scan))->bitmap) [ ( ( (UV) (*((U8*)locinput))) >> 3) ] ) & (1U << ((*((U8*)locinput)) & 7))) ? (_Bool)1 : (_Bool)0)))
  		                                                                                                        ^

"regexec.c", line 6709: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if ((nextchr < 0) || (((int)*(const U8*)(locinput)) & ((scan)->flags)) != ((((struct regnode_1 *)scan)->arg1))) {
                                                                                           ^

"regexec.c", line 7041: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7108: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              arg= (U32)((((struct regnode_1 *)scan)->arg1));
                           ^

"regexec.c", line 7120: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              startpoint = scan + ((((struct regnode_2L *)scan)->arg2));
                                     ^

"regexec.c", line 7181: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		n = ((((struct regnode_1 *)scan)->arg1));
  		       ^

"regexec.c", line 7417: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                                      ((((struct regnode_2L *)scan)->arg2)),
                                         ^

"regexec.c", line 7484: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7567: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7602: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7624: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_yes_mark = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                                       ^

"regexec.c", line 7625: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              if (((((struct regnode_2L *)scan)->arg2))){
                     ^

"regexec.c", line 7632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          n = ((((struct regnode_1 *)cursor)->arg1));
                                 ^

"regexec.c", line 7638: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              if ( n == ((((struct regnode_1 *)scan)->arg1)) || ( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (n) + 1 ) ) ) )
                                           ^

"regexec.c", line 7648: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7658: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              n = ((((struct regnode_1 *)scan)->arg1));
                     ^

"regexec.c", line 7673: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next = scan + ((((struct regnode_1 *)scan)->arg1));
  		                 ^

"regexec.c", line 7775: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next += ((((struct regnode_1 *)next)->arg1));
  		           ^

"regexec.c", line 7797: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7803: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7809: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7845: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7953: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7964: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7968: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"regexec.c", line 7974: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7981: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7991: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8016: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8047: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8053: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ((((struct regnode_1 *)scan)->arg1));
  	                     ^

"regexec.c", line 8072: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8076: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  ? ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])))
                                                           ^

"regexec.c", line 8079: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8087: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8091: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8156: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8204: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		if (( (PL_regkind[((st->u . curlym . B)->type)] == 34) || PL_regkind[((st->u . curlym . B)->type)] == 56 ) || ( ((st->u . curlym . B)->type) == 52 || (((st->u . curlym . B)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)st->u . curlym . B)->arg1))) + 1 ) ) ) ) || ((st->u . curlym . B)->type) == 73 || ((st->u . curlym . B)->type) == 70 || ((st->u . curlym . B)->type) == 68 || ((st->u . curlym . B)->type) == 46 || ((st->u . curlym . B)->type) == 74 || ((st->u . curlym . B)->type) == 94 || (PL_regkind[((st->u . curlym . B)->type)] == 47 && ((((struct regnode_2 *)st->u . curlym . B)->arg1)) > 0) )) {
  		                                                                                                                                                                                                                                                                                                                    ^

"regexec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  			                                                                                                                                                                                                ^

"regexec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  			                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^

"regexec.c", line 8285: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8368: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (! ( (PL_regkind[((next)->type)] == 34) || PL_regkind[((next)->type)] == 56 ) && ! ( ((next)->type) == 52 || (((next)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)next)->arg1))) + 1 ) ) ) ) || ((next)->type) == 73 || ((next)->type) == 70 || ((next)->type) == 68 || ((next)->type) == 46 || ((next)->type) == 74 || ((next)->type) == 94 || (PL_regkind[((next)->type)] == 47 && ((((struct regnode_2 *)next)->arg1)) > 0) )) {
                                                                                                                                                                                                                                                                              ^

"regexec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  		                                                                                                                                                                                                    ^

"regexec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ^

"regexec.c", line 8463: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8566: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8596: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8624: warning #2111-D: statement is unreachable
  		    ((void)0);  
  		    ^

"regexec.c", line 8728: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    next = scan + ((((struct regnode_1 *)scan)->arg1));
  		                     ^

"regexec.c", line 8745: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8763: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    scan = st->u . ifmatch .me + ((((struct regnode_1 *)st->u . ifmatch . me)->arg1));
  	                                    ^

"regexec.c", line 8772: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ((((struct regnode_1 *)scan)->arg1));
  	                     ^

"regexec.c", line 8783: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        sv_yes_mark = sv_commit = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
  	                                                                         ^

"regexec.c", line 8785: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8791: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8795: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_commit = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                                     ^

"regexec.c", line 8805: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8811: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                           ^

"regexec.c", line 8815: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8820: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8840: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8853: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  SV *find = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                                    ^

"regexec.c", line 8885: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 9382: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	    while (scan < loceol && (((( (U8*) ((regnode_charclass*)(p))->bitmap) [ ( ( (UV) (*((U8*)scan))) >> 3) ] ) & (1U << ((*((U8*)scan)) & 7))) ? (_Bool)1 : (_Bool)0))
  	                                        ^

"regexec.c", line 9396: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          scan = (char *) S_find_span_end_mask((U8 *) scan, (U8 *) loceol, (U8) ((((struct regnode_1 *)p)->arg1)), ((p)->flags));
                                                                                   ^

"regexec.c", line 9712: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	if ((((( (U8*) ((regnode_charclass*)(n))->bitmap) [ ( ( (UV) (c)) >> 3) ] ) & (1U << ((c) & 7))) ? (_Bool)1 : (_Bool)0))
  	                ^

"regexec.c", line 9725: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		&& (((( (U8*) ((regnode_charclass*)(n))->bitmap) [ ( ( (UV) (PL_fold_locale[c])) >> 3) ] ) & (1U << ((PL_fold_locale[c]) & 7))) ? (_Bool)1 : (_Bool)0))
  		               ^

"regexec.c", line 9729: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
              else if (((((n)->flags) & 0x02) && (((regnode_charclass_posixl*)(n))->classflags))
                                                   ^

"regexec.c", line 9767: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      if ((((regnode_charclass_posixl*) (n))->classflags & (1U << (count)))
                            ^

"regexec.c", line 9799: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	else if (    ((((struct regnode_1 *)n)->arg1)) != ((U32) -1)
  	                ^

"regexec.c", line 3200: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sublen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sublen)))) ? (size_t)(sublen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(prog->subbeg),(const char*)(strbeg + min), (sublen) * sizeof(char)));
                                                                                                                                                                                                   ^

"regexec.c", line 4452: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_utf8skip[*(const U8*)(pat)]) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_utf8skip[*(const U8*)(pat)])))) ? (size_t)(PL_utf8skip[*(const U8*)(pat)]) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(c1_utf8),(const char*)(pat), (PL_utf8skip[*(const U8*)(pat)]) * sizeof(U8)));
                                                                                                                                                                                                                                                                       ^

"regexec.c", line 4453: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_utf8skip[*(const U8*)(pat)]) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_utf8skip[*(const U8*)(pat)])))) ? (size_t)(PL_utf8skip[*(const U8*)(pat)]) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(c2_utf8),(const char*)(pat), (PL_utf8skip[*(const U8*)(pat)]) * sizeof(U8)));
                                                                                                                                                                                                                                                                       ^

"regexec.c", line 7909: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    (aux->poscache = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(aux->poscache),(size_t)((size)*sizeof(char))))));
  			                                                                                                                                                                                                    ^

"regexec.c", line 7912: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(aux->poscache),0,(size) * sizeof(char)));
  			                                                                                                                                                                               ^

"regexec.c", line 7916: warning #4276-D: relational operator ">" always evaluates to 'false'
  			(aux->poscache = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((size),sizeof(char)))));
  			                                                                                                                                                                                                ^

"utf8.c", line 3282: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"utf8.c", line 1086: warning #4276-D: relational operator ">" always evaluates to 'false'
      (output = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_len)))) ? (size_t)(output_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((output_len)*sizeof(char))))));
                                                                                                                                                                                                                 ^

"utf8.c", line 2578: warning #4276-D: relational operator ">" always evaluates to 'false'
      (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((*lenp) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((*lenp) + 1)))) ? (size_t)((*lenp) + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)(((*lenp) + 1)*sizeof(U8))))));
                                                                                                                                                                                                           ^

"utf8.c", line 2615: warning #4276-D: relational operator ">" always evaluates to 'false'
      (converted_start = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp + 1)))) ? (size_t)(*lenp + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(converted_start),(size_t)((*lenp + 1)*sizeof(U8))))));
                                                                                                                                                                                                                   ^

"utf8.c", line 2652: warning #4276-D: relational operator ">" always evaluates to 'false'
      (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((*lenp) * 2 + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((*lenp) * 2 + 1)))) ? (size_t)((*lenp) * 2 + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)(((*lenp) * 2 + 1)*sizeof(U8))))));
                                                                                                                                                                                                                       ^

"utf8.c", line 2664: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp + 1)))) ? (size_t)(*lenp + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dst),(size_t)((*lenp + 1)*sizeof(U8))))));
                                                                                                                                                                                                       ^

"utf8.c", line 3039: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)("\xC5\xBF" "\xC5\xBF"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                            ^

"utf8.c", line 3508: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(ustrp),(const char*)(p), (len) * sizeof(U8)));
                                                                                                                                                                                      ^

"utf8.c", line 3638: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(ustrp),(const char*)(p), (*lenp) * sizeof(char)));
                                                                                                                                                                                        ^

"utf8.c", line 4034: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(ustrp),(const char*)(p), (*lenp) * sizeof(char)));
  		                                                                                                                                                                                      ^

"utf8.c", line 4066: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(ustrp),(const char*)("\xC5\xBF" "\xC5\xBF"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                    ^

"utf8.c", line 4075: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(ustrp),(const char*)("\xEF\xAC\x86"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                    ^

"utf8.c", line 4551: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(klen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(klen)))) ? (size_t)(klen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(PL_last_swash_key),(const char*)(ptr), (klen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"universal.c", line 386: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	    pkg = ((XPVMG*) (( (sv) && ( ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVLV ) && (0+(sv)->sv_u . svu_gp) ? ((0+(sv)->sv_u . svu_gp)->gp_io) : 0L ))->sv_any)->xmg_stash;
  	           ^

"universal.c", line 389: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          pkg = ((XPVMG*) (( (sv) && ( ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVLV ) && (0+(sv)->sv_u . svu_gp) ? ((0+(sv)->sv_u . svu_gp)->gp_io) : 0L ))->sv_any)->xmg_stash;
                 ^

"universal.c", line 391: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          pkg = ((XPVMG*) (( (iogv) && ( ((svtype)(((const SV*)(iogv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((const SV*)(iogv))->sv_flags & 0xff)) == SVt_PVLV ) && (0+(iogv)->sv_u . svu_gp) ? ((0+(iogv)->sv_u . svu_gp)->gp_io) : 0L ))->sv_any)->xmg_stash;
                 ^

"universal.c", line 986: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"universal.c", line 938: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(reflags + left),(const char*)(name), (len) * sizeof(char)));
  		                                                                                                                                                                            ^

"perlio.c", line 350: warning #2111-D: statement is unreachable
      __va_start__(ap);
      ^

"perlio.c", line 2062: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      ((PerlIOBuf *)(*(f)))->posn = old;
       ^

"perlio.c", line 2760: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"perlio.c", line 2789: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"perlio.c", line 3844: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
                      ^

"perlio.c", line 3947: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4009: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4081: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
          const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                       ^

"perlio.c", line 4093: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4152: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4203: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	    PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                    ^

"perlio.c", line 4213: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4244: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4257: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4269: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                   ^

"perlio.c", line 4278: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                   ^

"perlio.c", line 4289: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4308: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                   ^

"perlio.c", line 4317: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4407: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4565: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
      PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
                              ^

"perlio.c", line 4574: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                ^

"perlio.c", line 4620: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4624: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
  	PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
  	                        ^

"perlio.c", line 4692: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4693: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
      PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
                              ^

"perlio.c", line 4750: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
  	                       ^

"perlio.c", line 4797: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
      PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
                              ^

"perlio.c", line 1138: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (temp = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tab->size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tab->size)))) ? (size_t)(tab->size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((tab->size),sizeof(char)))));
  	                                                                                                                                                                                                          ^

"perlio.c", line 2086: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(take) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(take)))) ? (size_t)(take) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(buf),(const char*)(ptr), (take) * sizeof(unsigned char)));
  		                                                                                                                                                                                                 ^

"perlio.c", line 4055: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(avail) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(avail)))) ? (size_t)(avail) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(b->buf),(const char*)(ptr), (avail) * sizeof(unsigned char)));
  	                                                                                                                                                                                                        ^

"perlio.c", line 4136: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(avail) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(avail)))) ? (size_t)(avail) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(b->ptr),(const char*)(buf), (avail) * sizeof(unsigned char)));
  		                                                                                                                                                                                                    ^

"perlio.c", line 4178: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(avail) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(avail)))) ? (size_t)(avail) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(b->ptr),(const char*)(buf), (avail) * sizeof(unsigned char)));
  	                                                                                                                                                                                                        ^

"perlio.c", line 4295: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(b->buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(b->bufsiz) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(b->bufsiz)))) ? (size_t)(b->bufsiz) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (unsigned char*)(Perl_safesysmalloc((size_t)((b->bufsiz)*sizeof(unsigned char))))));
  	                                                                                                                                                                                                                          ^

"numeric.c", line 1618: warning #2111-D: statement is unreachable
      *value = result[2];
      ^

"numeric.c", line 745: warning #4277-D: logical AND with a constant, do you mean to use '&'?
                          !(nantype && 0x01)) {
                                    ^

"numeric.c", line 1457: warning #4276-D: relational operator ">" always evaluates to 'false'
              (copy = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len + 1)*sizeof(char))))));
                                                                                                                                                                                                              ^

"numeric.c", line 1458: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(copy),(const char*)(orig), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"locale.c", line 148: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(locs),(const char*)(s + 1), (len) * sizeof(char)));
  		                                                                                                                                                                            ^

"locale.c", line 310: warning #4276-D: relational operator ">" always evaluates to 'false'
          (unknown = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(length)))) ? (size_t)(length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((length)*sizeof(char))))));
                                                                                                                                                                                                          ^

"locale.c", line 2301: warning #4276-D: relational operator ">" always evaluates to 'false'
          (*buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(string_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(string_size)))) ? (size_t)(string_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((string_size)*sizeof(char))))));
                                                                                                                                                                                                                      ^

"locale.c", line 2305: warning #4276-D: relational operator ">" always evaluates to 'false'
          (*buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(string_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(string_size)))) ? (size_t)(string_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(*buf),(size_t)((string_size)*sizeof(char))))));
                                                                                                                                                                                                                      ^

"locale.c", line 2309: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(string_size - offset) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(string_size - offset)))) ? (size_t)(string_size - offset) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(*buf + offset),(const char*)(string), (string_size - offset) * sizeof(char)));
                                                                                                                                                                                                                                     ^

"locale.c", line 3918: warning #4276-D: relational operator ">" always evaluates to 'false'
          (sans_nuls = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sans_nuls_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sans_nuls_len)))) ? (size_t)(sans_nuls_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((sans_nuls_len)*sizeof(char))))));
                                                                                                                                                                                                                                 ^

"locale.c", line 4050: warning #4276-D: relational operator ">" always evaluates to 'false'
                  (s = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                                   ^

"locale.c", line 4071: warning #4276-D: relational operator ">" always evaluates to 'false'
                      (s = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(d) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(d)))) ? (size_t)(d) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(s),(size_t)((d)*sizeof(char))))));    
                                                                                                                                                                                                 ^

"locale.c", line 4094: warning #4276-D: relational operator ">" always evaluates to 'false'
      (xbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(xAlloc) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(xAlloc)))) ? (size_t)(xAlloc) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((xAlloc)*sizeof(char))))));
                                                                                                                                                                                                   ^

"locale.c", line 4228: warning #4276-D: relational operator ">" always evaluates to 'false'
          (xbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(xAlloc) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(xAlloc)))) ? (size_t)(xAlloc) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(xbuf),(size_t)((xAlloc)*sizeof(char))))));
                                                                                                                                                                                                       ^

"locale.c", line 4253: warning #4276-D: relational operator ">" always evaluates to 'false'
      (xbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(PL_collation_ix) + *xlen + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(PL_collation_ix) + *xlen + 1)))) ? (size_t)(sizeof(PL_collation_ix) + *xlen + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(xbuf),(size_t)((sizeof(PL_collation_ix) + *xlen + 1)*sizeof(char))))));
                                                                                                                                                                                                                                                                                          ^

"locale.c", line 4495: warning #4276-D: relational operator ">" always evaluates to 'false'
      (delimited = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len_with_overhead) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len_with_overhead)))) ? (size_t)(input_name_len_with_overhead) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((input_name_len_with_overhead)*sizeof(char))))));
                                                                                                                                                                                                                                                                          ^

"locale.c", line 4497: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len)))) ? (size_t)(input_name_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(delimited + 1),(const char*)(save_input_locale), (input_name_len) * sizeof(char)));
                                                                                                                                                                                                                   ^

"locale.c", line 4520: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(name_pos - utf8ness_cache) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(name_pos - utf8ness_cache)))) ? (size_t)(name_pos - utf8ness_cache) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(utf8ness_cache + input_name_len_with_overhead),(const char*)(utf8ness_cache), (name_pos - utf8ness_cache) * sizeof(char)));
                                                                                                                                                                                                                                                            ^

"locale.c", line 4523: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len_with_overhead - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len_with_overhead - 1)))) ? (size_t)(input_name_len_with_overhead - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(utf8ness_cache),(const char*)(delimited), (input_name_len_with_overhead - 1) * sizeof(char)));
                                                                                                                                                                                                                                                                                 ^

"locale.c", line 4947: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(utf8ness_cache_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(utf8ness_cache_len + 1)))) ? (size_t)(utf8ness_cache_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(utf8ness_cache + input_name_len_with_overhead),(const char*)(utf8ness_cache), (utf8ness_cache_len + 1) * sizeof(char)));
                                                                                                                                                                                                                                               ^

"locale.c", line 4952: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len_with_overhead - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len_with_overhead - 1)))) ? (size_t)(input_name_len_with_overhead - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(utf8ness_cache),(const char*)(delimited), (input_name_len_with_overhead - 1) * sizeof(char)));
                                                                                                                                                                                                                                                                             ^

"pp_pack.c", line 2017: warning #4276-D: relational operator ">" always evaluates to 'false'
      (to_start = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                              ^

"pp_pack.c", line 2018: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(from_ptr-from_start) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(from_ptr-from_start)))) ? (size_t)(from_ptr-from_start) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(to_start),(const char*)(from_start), (from_ptr-from_start) * sizeof(char)));
                                                                                                                                                                                                                                  ^

"pp_pack.c", line 2221: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(cur),0,(len) * sizeof(char)));
  			                                                                                                                                                                            ^

"pp_pack.c", line 2414: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(fromlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(fromlen)))) ? (size_t)(fromlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(cur),(const char*)(aptr), (fromlen) * sizeof(char)));
  		                                                                                                                                                                                        ^

"pp_pack.c", line 2488: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(field_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(field_len)))) ? (size_t)(field_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(cur),0,(field_len) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"pp_pack.c", line 2563: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(field_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(field_len)))) ? (size_t)(field_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(cur),0,(field_len) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"pp_pack.c", line 2898: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN glen = ((buf + sizeof(buf)) - in); STRLEN gl = glen; if (utf8) do { if ((gl) > (ssize_t)(~(size_t)0 >> 1) / 2) Perl_croak( "%s", "Out of memory during pack()"); (gl) = (gl) * 2; } while (0); if ((cur) + gl >= (start) + ((XPV*) (cat)->sv_any)->xpv_len_u . xpvlenu_len) { *cur = '\0'; do { ((void)0); ((void)0); ((void)0); (((XPV*) ((cat))->sv_any)->xpv_cur = ((cur) - (start))); } while (0); (start) = S_sv_exp_grow( cat,gl); (cur) = (start) + ((XPV*) (cat)->sv_any)->xpv_cur; } do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) in, glen, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(in), cur, glen); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(glen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(glen)))) ? (size_t)(glen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^

"pp_pack.c", line 2931: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN glen = ((buf + sizeof(buf)) - in); STRLEN gl = glen; if (utf8) do { if ((gl) > (ssize_t)(~(size_t)0 >> 1) / 2) Perl_croak( "%s", "Out of memory during pack()"); (gl) = (gl) * 2; } while (0); if ((cur) + gl >= (start) + ((XPV*) (cat)->sv_any)->xpv_len_u . xpvlenu_len) { *cur = '\0'; do { ((void)0); ((void)0); ((void)0); (((XPV*) ((cat))->sv_any)->xpv_cur = ((cur) - (start))); } while (0); (start) = S_sv_exp_grow( cat,gl); (cur) = (start) + ((XPV*) (cat)->sv_any)->xpv_cur; } do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) in, glen, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(in), cur, glen); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(glen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(glen)))) ? (size_t)(glen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^

"pp_pack.c", line 2946: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (result = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
  		                                                                                                                                                                                          ^

"pp_pack.c", line 2951: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN glen = ((result + len) - in); STRLEN gl = glen; if (utf8) do { if ((gl) > (ssize_t)(~(size_t)0 >> 1) / 2) Perl_croak( "%s", "Out of memory during pack()"); (gl) = (gl) * 2; } while (0); if ((cur) + gl >= (start) + ((XPV*) (cat)->sv_any)->xpv_len_u . xpvlenu_len) { *cur = '\0'; do { ((void)0); ((void)0); ((void)0); (((XPV*) ((cat))->sv_any)->xpv_cur = ((cur) - (start))); } while (0); (start) = S_sv_exp_grow( cat,gl); (cur) = (start) + ((XPV*) (cat)->sv_any)->xpv_cur; } do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) in, glen, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(in), cur, glen); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(glen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(glen)))) ? (size_t)(glen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"pp_pack.c", line 3119: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) hunk, end-hunk, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(hunk), cur, end-hunk); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(end-hunk) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(end-hunk)))) ? (size_t)(end-hunk) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(cur),(const char*)(hunk), (end-hunk) * sizeof(char))); (cur) += (end-hunk); } } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                         ^

cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
"op.c", line 12320: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

"op.c", line 12996: warning #2111-D: statement is unreachable
  	} ((void)0);  
  	  ^

"op.c", line 15228: warning #2549-D: variable "defer_queue" is used before its value is set
                          defer_queue[(defer_base + defer_ix--) % 4];
                          ^

"op.c", line 16274: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"op.c", line 3183: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l)))) ? (size_t)(l) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)(argp->p), (l) * sizeof(char)));
                                                                                                                                                                                        ^

"op.c", line 5143: warning #4276-D: relational operator ">" always evaluates to 'false'
      PL_compiling.cop_warnings = (((PL_compiling . cop_warnings) == 0L || (PL_compiling . cop_warnings) == (((STRLEN*)0)+1) || (PL_compiling . cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_compiling . cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings)))) ? (size_t)(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings))),(const char*)(PL_compiling . cop_warnings), (sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 8048: warning #4276-D: relational operator ">" always evaluates to 'false'
      cop->cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 10502: warning #4276-D: relational operator ">" always evaluates to 'false'
  	 PL_compiling.cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"op.c", line 12436: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(end - s - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(end - s - 1)))) ? (size_t)(end - s - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(s+1),(const char*)(s+2), (end - s - 1) * sizeof(char)));
  		                                                                                                                                                                                                        ^

"op.c", line 12605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf+1),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"perl.c", line 3496: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

"perl.c", line 4578: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
            if (((((XPVHV*) (dups)->sv_any)->xhv_keys) - (((XPVMG*) (dups)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)dups) : 0))) {
                                                           ^

cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
parts/inc/mess provides vmess, which is still marked todo for 5.6.0
"B.c", line 1431: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.c", line 1525: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.xs", line 1314: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1322: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1331: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1340: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1348: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.c", line 1801: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.c", line 1947: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.c", line 2465: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.xs", line 2035: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	if (HvUSEDKEYS(hv) > 0) {
  	    ^

"B.xs", line 2041: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              extend_size = (SSize_t)HvUSEDKEYS(hv) * 2;
                                     ^

"B.c", line 3435: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Bzip2.xs", line 832: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        Move(s->stream.next_in, SvPVX(buf), in, char) ;	
  	        ^

"bzlib.c", line 868: warning #2111-D: statement is unreachable
     AssertH ( 0, 6001 );
     ^

"Zlib.xs", line 1108: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s->deflateParams_out_buffer, s->stream.next_out, plen, Bytef) ;	
          ^

"Zlib.xs", line 1237: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s->deflateParams_out_buffer, s->stream.next_out, plen, Bytef) ;	
          ^

"Zlib.xs", line 1669: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        Move(s->stream.next_in, SvPVX(buf), in, char) ;	
  	        ^

"Zlib.xs", line 1732: warning #4276-D: relational operator ">" always evaluates to 'false'
       	    Move(s->stream.next_in, SvPVX(buf), in, char) ;	
       	    ^

"Zlib.xs", line 1977: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Move(s->stream.next_in, SvPVX(buf), in, char) ;	
                  ^

"DB_File.xs", line 637: warning #4232-D: conversion from "_Bool *" to a more strictly aligned type "int *" may cause misaligned access
      SAVEINT(CurrentDB->in_compare);
      ^

"DB_File.xs", line 725: warning #4232-D: conversion from "_Bool *" to a more strictly aligned type "int *" may cause misaligned access
      SAVEINT(CurrentDB->in_prefix);
      ^

"DB_File.xs", line 810: warning #4232-D: conversion from "_Bool *" to a more strictly aligned type "int *" may cause misaligned access
      SAVEINT(CurrentDB->in_hash);
      ^

"Dumper.xs", line 908: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    New(0, iname, namelen+28, char);
  	    ^

"Dumper.xs", line 1140: warning #4276-D: relational operator ">" always evaluates to 'false'
  			New(0, nkey_buffer, klen+nticks+3, char);
  			^

"Dumper.xs", line 1146: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    (void)Copy(key, nkey+1, klen, char);
  			          ^

"Dumper.xs", line 1167: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    New(0, extra, klen+4+1, char);
  		    ^

"Dumper.xs", line 1256: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        New(0, npack_buffer, plen+pticks+1, char);
  	        ^

parts/inc/mess provides vmess, which is still marked todo for 5.6.0
"RealPPPort.c", line 1187: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 1648: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2149: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2171: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2193: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2215: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2237: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2258: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2279: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2300: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2321: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2342: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3201: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3267: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3328: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"RealPPPort.c", line 3369: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3399: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.xs", line 1816: warning #2068-D: integer conversion resulted in a change of sign
                  if (SvUTF8(utf8_key)) klen *= -1;
                                                ^

"RealPPPort.c", line 3622: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3645: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3664: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3686: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3724: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3752: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3771: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3790: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3883: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4035: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4060: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4100: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4422: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4446: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4469: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4683: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4751: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.xs", line 655: warning #4276-D: relational operator ">" always evaluates to 'false'
                  SvPV_renew(sv, nlen);
                  ^

"RealPPPort.xs", line 656: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Copy(str, SvPVX(sv), slen + 1, char);
                  ^

"RealPPPort.xs", line 1435: warning #4276-D: relational operator ">" always evaluates to 'false'
                  New(42, copy, len+1, char);
                  ^

"RealPPPort.xs", line 1436: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Copy(str, copy, len+1, char);
                  ^

"MD5.xs", line 510: warning #2191-D: type qualifier is meaningless on cast type
  	    && mg->mg_virtual == (const MGVTBL * const)&vtbl_md5) {
  	                          ^

"MD5.xs", line 532: warning #2191-D: type qualifier is meaningless on cast type
  	sv_magicext(sv, NULL, PERL_MAGIC_ext, (const MGVTBL * const)&vtbl_md5, (const char *)context, 0);
  	                                       ^

"MD5.c", line 799: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 827: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 876: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 938: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"MD5.c", line 963: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 1017: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 1086: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.xs", line 439: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Copy(buf, ctx->buffer + fill, len, U8);
  	    ^

"MD5.xs", line 442: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(buf, ctx->buffer + fill, missing, U8);
  	^

"MD5.xs", line 452: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(buf + (blocks << 6), ctx->buffer, len, U8);
  	^

"MD5.xs", line 466: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(PADDING, ctx->buffer + fill, padlen, U8);
      ^

"SHA.c", line 504: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SHA.c", line 623: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SHA.c", line 654: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SHA.c", line 715: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"src/sha.c", line 331: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(bitstr, s->block, NBYTES(bitcnt), char);
  		^

"src/sha.c", line 347: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(bitstr, s->block+offset, nbits>>3, char);
  		^

"src/sha.c", line 354: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(bitstr, s->block+offset, NBYTES(bitcnt), char);
  		^

"src/sha.c", line 455: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(in, byte, n, UCHR);
  	^

"src/sha.c", line 495: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(key, h->key, keylen, char);
  		^

"src/sha.c", line 501: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(digcpy(&ksha), h->key, ksha.digestlen, char);
  		^

"SHA.xs", line 307: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(digcpy(state), ptr, state->alg <= SHA256 ? 32 : 64, UCHR);
  	^

"SHA.xs", line 309: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(state->block, ptr, state->alg <= SHA256 ? 64 : 128, UCHR);
  	^

"SHA.xs", line 336: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(data, state->block, state->blocksize >> 3, UCHR);
  	^

"Unicode.c", line 512: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Unicode.c", line 657: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Unicode.xs", line 332: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Move(s,SvPVX(str),e-s,U8);
  	    ^

"Unicode.xs", line 342: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Unicode.xs", line 342: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Unicode.xs", line 457: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Move(s,SvPVX(utf8),e-s,U8);
  	    ^

"Unicode.xs", line 467: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Unicode.xs", line 467: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Encode.c", line 906: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Encode.c", line 1001: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Encode.xs", line 514: warning #4276-D: relational operator ">" always evaluates to 'false'
          Move(s, d, len, U8);
          ^

"Encode.xs", line 1040: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(83, dest, len, U8); /* I think */
          ^

"bsd_glob.c", line 893: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(copy, p-path, char);
  	^

"Util.c", line 266: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 354: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"Util.c", line 371: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 409: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.xs", line 161: warning #4232-D: conversion from "XPVHV *const" to a more strictly aligned type "XPVMG *" may cause misaligned access
          U32 total_keys= HvUSEDKEYS(hv);
                          ^

"Util.c", line 528: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 622: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 656: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 684: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 712: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"IO.c", line 558: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"IO.c", line 591: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"SysV.c", line 311: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 356: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 394: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 435: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 477: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 522: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 583: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"SysV.c", line 622: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"SysV.c", line 654: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"SysV.c", line 688: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"SysV.c", line 712: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"SysV.xs", line 360: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(caddr + pos, dst, size, char);
      ^

"SysV.xs", line 381: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(src, caddr + pos, n, char);
      ^

"ListUtil.c", line 355: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 536: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 582: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 654: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 732: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 806: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 866: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 908: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 965: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 999: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1033: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1126: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1389: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1439: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1606: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1627: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1800: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1865: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1939: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"ListUtil.c", line 1980: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.xs", line 1634: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      mg = SvMAGIC(cv);
           ^

"ListUtil.xs", line 1639: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          mg->mg_moremagic = SvMAGIC(cv);
                             ^

"ListUtil.xs", line 1642: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          SvMAGIC_set(cv, mg);
          ^

"ListUtil.c", line 2159: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"FastCalc.c", line 332: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"FastCalc.c", line 385: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"FastCalc.c", line 432: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"FastCalc.c", line 512: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Opcode.xs", line 138: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Zero(SvPVX_const(opset), opset_len + 1, char);
  	^

Warning (mostly harmless): No library found for -lposix
Warning (mostly harmless): No library found for -lcposix
"POSIX.c", line 2010: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"POSIX.c", line 2171: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"POSIX.c", line 5030: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"encoding.xs", line 57: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 93: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 178: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 201: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 238: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 397: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 514: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 543: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
                     ^

"encoding.xs", line 559: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
  	PerlIOEncode *fe = PerlIOSelf(f, PerlIOEncode);
  	                   ^

"encoding.xs", line 560: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
  	PerlIOEncode *oe = PerlIOSelf(o, PerlIOEncode);
  	                   ^

"encoding.xs", line 574: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"mmap.xs", line 30: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 36: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
  	                      ^

"mmap.xs", line 94: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 122: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 155: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 186: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 213: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 241: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
                            ^

"scalar.xs", line 22: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
          PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                            ^

"scalar.xs", line 35: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 91: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 117: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 151: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 168: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 216: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 291: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 303: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 313: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 328: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 338: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 369: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 390: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar * const os = PerlIOSelf(o, PerlIOScalar);
                                ^

"scalar.xs", line 395: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	fs = PerlIOSelf(f, PerlIOScalar);
  	     ^

"scalar.xs", line 205: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(p + (STRLEN)(s->posn), vbuf, got, STDCHAR);
  	^

"scalar.xs", line 252: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Zero(SvPVX(sv) + cur, (STRLEN)s->posn - cur, char);
  		^

"scalar.xs", line 261: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Move(vbuf, dst + offset, count, char);
  	^

"via.xs", line 438: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Move(SvPVX(buf), vbuf, rd, char);
  		^

"Socket.c", line 963: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Socket.xs", line 706: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(sa, addr_len, char);
  	^

"Socket.xs", line 707: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(SvPV_nolen(addr), sa, addr_len, char);
  	^

"Socket.xs", line 858: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(pathname_pv, sun_ad.sun_path, len, char);
  	^

"Socket.xs", line 1155: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Copy(ip_address, &addr, addrlen, char);
  	    ^

"Socket.xs", line 1156: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Zero(((char*)&addr) + addrlen, sizeof(addr) - addrlen, char);
  	    ^

"Storable.xs", line 2887: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              int placeholders = (int)HvPLACEHOLDERS_get(hv);
                                      ^

"Storable.c", line 7945: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Storable.xs", line 2357: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(is_weak ? SX_WEAKOVERLOAD : SX_OVERLOAD);
              ^

"Storable.xs", line 2359: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(is_weak ? SX_WEAKREF : SX_REF);
              ^

"Storable.xs", line 2361: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(is_weak ? SX_WEAKREF : SX_REF);
          ^

"Storable.xs", line 2419: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SV_UNDEF);
              ^

"Storable.xs", line 2422: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_UNDEF);
              ^

"Storable.xs", line 2461: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SV_YES);
              ^

"Storable.xs", line 2464: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SV_NO);
              ^

"Storable.xs", line 2508: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_BYTE);
              ^

"Storable.xs", line 2509: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(siv);
              ^

"Storable.xs", line 2534: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_NETINT);
              ^

"Storable.xs", line 2535: warning #4276-D: relational operator ">" always evaluates to 'false'
              WRITE_I32(niv);
              ^

"Storable.xs", line 2538: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_INTEGER);
              ^

"Storable.xs", line 2539: warning #4276-D: relational operator ">" always evaluates to 'false'
              WRITE(&iv, sizeof(iv));
              ^

"Storable.xs", line 2578: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_DOUBLE);
          ^

"Storable.xs", line 2579: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(&nv, sizeof(nv));
          ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2657: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_ARRAY);
          ^

"Storable.xs", line 2658: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2658: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2683: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SV_UNDEF();
              ^

"Storable.xs", line 2695: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SVUNDEF_ELEM);
              ^

"Storable.xs", line 2810: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_FLAG_HASH);
              ^

"Storable.xs", line 2811: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(hash_flags);
              ^

"Storable.xs", line 2814: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_HASH);
              ^

"Storable.xs", line 2816: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2816: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2984: warning #4276-D: relational operator ">" always evaluates to 'false'
                  PUTMARK(flags);
                  ^

"Storable.xs", line 2996: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(keylen);
              ^

"Storable.xs", line 2996: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(keylen);
              ^

"Storable.xs", line 2998: warning #4276-D: relational operator ">" always evaluates to 'false'
                  WRITE(keyval, keylen);
                  ^

"Storable.xs", line 3177: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flags);
              ^

"Storable.xs", line 3193: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3193: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3195: warning #4276-D: relational operator ">" always evaluates to 'false'
                  WRITE(key, len);
                  ^

"Storable.xs", line 3350: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(SX_CODE);
      ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3438: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(SX_REGEXP);
      ^

"Storable.xs", line 3439: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(op_flags);
      ^

"Storable.xs", line 3442: warning #4276-D: relational operator ">" always evaluates to 'false'
        WLEN(re_len32);
        ^

"Storable.xs", line 3442: warning #4276-D: relational operator ">" always evaluates to 'false'
        WLEN(re_len32);
        ^

"Storable.xs", line 3445: warning #4276-D: relational operator ">" always evaluates to 'false'
        PUTMARK(re_len);
        ^

"Storable.xs", line 3446: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE(re_pv, re_len);
      ^

"Storable.xs", line 3447: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(flags_len);
      ^

"Storable.xs", line 3448: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE(flags_pv, flags_len);
      ^

"Storable.xs", line 3483: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_HASH);		/* Introduces tied hash */
          ^

"Storable.xs", line 3486: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_ARRAY);		/* Introduces tied array */
          ^

"Storable.xs", line 3489: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_SCALAR);	/* Introduces tied scalar */
          ^

"Storable.xs", line 3548: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_KEY);
          ^

"Storable.xs", line 3562: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_IDX);
          ^

"Storable.xs", line 3570: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(idx);
          ^

"Storable.xs", line 3570: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(idx);
          ^

"Storable.xs", line 3850: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    PUTMARK(SX_HOOK);
  	    ^

"Storable.xs", line 3851: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flags);
              ^

"Storable.xs", line 3853: warning #4276-D: relational operator ">" always evaluates to 'false'
                  PUTMARK(eflags);
                  ^

"Storable.xs", line 3855: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flags);
              ^

"Storable.xs", line 3970: warning #4276-D: relational operator ">" always evaluates to 'false'
  	PUTMARK(SX_HOOK);
  	^

"Storable.xs", line 3971: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(flags);
          ^

"Storable.xs", line 3973: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(eflags);
              ^

"Storable.xs", line 3975: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(flags);
          ^

"Storable.xs", line 3980: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 3980: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 3983: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(cnum);
              ^

"Storable.xs", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3990: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(clen);
              ^

"Storable.xs", line 3992: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(classname, len);		/* Final \0 is omitted */
          ^

"Storable.xs", line 4004: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

"Storable.xs", line 4004: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

"Storable.xs", line 4007: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(clen);
          ^

"Storable.xs", line 4010: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(pv, (SSize_t)len2);	/* Final \0 is omitted */
          ^

"Storable.xs", line 4020: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len3);
              ^

"Storable.xs", line 4020: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len3);
              ^

"Storable.xs", line 4025: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(clen);
              ^

"Storable.xs", line 4046: warning #4276-D: relational operator ">" always evaluates to 'false'
                  WRITE_I32(tagval);
                  ^

"Storable.xs", line 4155: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_IX_BLESS);
          ^

"Storable.xs", line 4158: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(cnum);
              ^

"Storable.xs", line 4161: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flag);
              ^

"Storable.xs", line 4162: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 4162: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 4167: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_BLESS);
          ^

"Storable.xs", line 4170: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(clen);
              ^

"Storable.xs", line 4173: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flag);
              ^

"Storable.xs", line 4174: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

"Storable.xs", line 4174: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

"Storable.xs", line 4176: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(classname, len);	/* Final \0 is omitted */
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4425: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    PUTMARK(SX_OBJECT);
  	    ^

"Storable.xs", line 4426: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    WRITE_I32(ltagval);
  	    ^

"Storable.xs", line 4560: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE( (unsigned char*) header, length);
      ^

"Storable.xs", line 4819: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(10003, classname, len+1, char);
          ^

"Storable.xs", line 5022: warning #4276-D: relational operator ">" always evaluates to 'false'
              New(10003, classname, len+1, char);
              ^

"Storable.xs", line 5913: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(10003, s, len+1, char);
      ^

"Storable.xs", line 6473: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);	/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 6607: warning #4276-D: relational operator ">" always evaluates to 'false'
              KBUFCHK((STRLEN)size);/* Grow hash key read pool if needed */
              ^

"Storable.xs", line 6978: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);			/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 7353: warning #4276-D: relational operator ">" always evaluates to 'false'
              KBUFCHK((STRLEN)len);	/* Grow buffer as necessary */
              ^

"HiRes.c", line 2338: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1202: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1261: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1306: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1347: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.xs", line 995: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(0, buf, bufsize, char);
          ^

"Piece.xs", line 1007: warning #4276-D: relational operator ">" always evaluates to 'false'
              Renew(buf, bufsize, char);
              ^

"Collate.xs", line 458: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    New(0, eachlevel[lv], 2 * (1 + buf_len) + 1, U8);
  	    ^

"Collate.xs", line 601: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(v, d, vlen, U8);
      ^

Making header files for XS...
"Normalize.xs", line 253: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Renew_d_if_not_enough_to(UTF8_MAXLEN * 3)
  	    ^

"Normalize.xs", line 261: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(len)
  		^

"Normalize.xs", line 266: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 331: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 338: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Renew_d_if_not_enough_to(UTF8_MAXLEN)
  	    ^

"Normalize.xs", line 384: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 443: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Renew_d_if_not_enough_to(UTF8_MAXLEN)
  	    ^

"Normalize.xs", line 451: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 480: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 502: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 526: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 551: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, t, tlen+1, U8);
      ^

"Normalize.xs", line 558: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 591: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, t, tlen+1, U8);
      ^

"Normalize.xs", line 598: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, u, ulen+1, U8);
      ^

"Normalize.xs", line 605: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"APItest.c", line 2071: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2090: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2115: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2133: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2151: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2169: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2187: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2205: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2223: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2241: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2259: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2277: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2819: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2838: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3013: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3209: warning #3215-D: function "Perl_ptr_table_clear" (declared at line 2744 of "../../proto.h") was declared deprecated
  	ptr_table_clear(table);
  	^

"APItest.c", line 3658: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3680: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3702: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3724: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3745: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3766: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3787: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3808: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4684: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4803: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4829: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4876: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4897: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 5015: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"APItest.c", line 6177: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"APItest.c", line 6243: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"APItest.xs", line 6439: warning #3215-D: function "Perl_to_utf8_lower" (declared at line 3760 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_lower(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6529: warning #3215-D: function "Perl_to_utf8_fold" (declared at line 3753 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_fold(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6619: warning #3215-D: function "Perl_to_utf8_upper" (declared at line 3774 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_upper(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6702: warning #3215-D: function "Perl_to_utf8_title" (declared at line 3767 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_title(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6147: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s, (U8 *) copy + offset, len, U8);
          ^

"APItest.xs", line 6162: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s, (U8 *) copy + offset, len, U8);
          ^

"XSUB-undef-XS_VERSION.c", line 186: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"XSUB-redefined-macros.c", line 189: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"XSUB-redefined-macros.c", line 208: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Typemap.c", line 1529: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Typemap.c", line 1593: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Typemap.c", line 1691: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"attributes.c", line 314: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"attributes.c", line 418: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"attributes.c", line 457: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 493: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 526: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 562: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 642: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 665: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 920: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"re_exec.c", line 505: warning #2111-D: statement is unreachable
      return FALSE; /* Things like CNTRL are always below 256 */
      ^

"re_exec.c", line 2227: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              REXEC_FBC_CLASS_SCAN(0, ANYOF_BITMAP_TEST(c, *((U8*)s)));
              ^

"re_exec.c", line 2233: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          REXEC_FBC_FIND_NEXT_SCAN(0,
          ^

"re_exec.c", line 2872: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_ac_data *aho = (reg_ac_data*)progi->data->data[ ARG( c ) ];
                                                                  ^

"re_exec.c", line 2910: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                      bitmap=(U8*)ANYOF_BITMAP(c);
                                  ^

"re_exec.c", line 4356: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                  ^

"re_exec.c", line 5835: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5841: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5877: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              if(!NEXTCHR_IS_EOS && !ANYOF_BITMAP_TEST(scan, nextchr)) {
                                     ^

"re_exec.c", line 5883: warning #2111-D: statement is unreachable
                  NOT_REACHED; /* NOTREACHED */
                  ^

"re_exec.c", line 5937: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          	    = (reg_trie_data*)rexi->data->data[ ARG( scan ) ];
          	                                        ^

"re_exec.c", line 5938: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		HV * widecharmap = MUTABLE_HV(rexi->data->data[ ARG( scan ) + 1 ]);
  		                   ^

"re_exec.c", line 6083: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 6113: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = ((reg_trie_data*)rexi->data->data[ARG(ST.me)])->wordinfo;
  		                                        ^

"re_exec.c", line 6137: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = (reg_trie_data*)rexi->data->data[ARG(ST.me)];
  		                                       ^

"re_exec.c", line 6200: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 6203: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    DEBUG_EXECUTE_r({
  	    ^

"re_exec.c", line 6702: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (!REGINCLASS(rex, scan, (U8*)locinput, utf8_target))
  		     ^

"re_exec.c", line 6709: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (NEXTCHR_IS_EOS || (UCHARAT(locinput) & FLAGS(scan)) != ARG(scan)) {
                                                                         ^

"re_exec.c", line 7041: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7108: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              arg= (U32)ARG(scan);
                        ^

"re_exec.c", line 7120: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              startpoint = scan + ARG2L(scan);
                                  ^

"re_exec.c", line 7181: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		n = ARG(scan);
  		    ^

"re_exec.c", line 7417: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                                      ARG2L(scan),
                                      ^

"re_exec.c", line 7484: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7567: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7602: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7624: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_yes_mark = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                                ^

"re_exec.c", line 7625: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              if (ARG2L(scan)){
                  ^

"re_exec.c", line 7632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          n = ARG(cursor);
                              ^

"re_exec.c", line 7638: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              if ( n == ARG(scan) || EVAL_CLOSE_PAREN_IS(cur_eval, n) )
                                        ^

"re_exec.c", line 7648: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7658: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              n = ARG(scan);
                  ^

"re_exec.c", line 7673: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next = scan + ARG(scan);
  		              ^

"re_exec.c", line 7775: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next += ARG(next);
  		        ^

"re_exec.c", line 7797: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7803: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7809: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7845: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7953: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7964: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7968: warning #2111-D: statement is unreachable
  	NOT_REACHED; /* NOTREACHED */
  	^

"re_exec.c", line 7974: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7981: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7991: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8016: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8047: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8053: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ARG(scan);
  	                  ^

"re_exec.c", line 8072: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8076: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  ? MUTABLE_SV(rexi->data->data[ ARG( scan ) ])
                    ^

"re_exec.c", line 8079: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8087: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8091: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8156: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8204: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		if (HAS_TEXT(ST.B) || JUMPABLE(ST.B)) {
  		                      ^

"re_exec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			FIND_NEXT_IMPT(text_node);
  			^

"re_exec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			FIND_NEXT_IMPT(text_node);
  			^

"re_exec.c", line 8285: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8368: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (! HAS_TEXT(next) && ! JUMPABLE(next)) {
                                        ^

"re_exec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    FIND_NEXT_IMPT(text_node);
  		    ^

"re_exec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    FIND_NEXT_IMPT(text_node);
  		    ^

"re_exec.c", line 8463: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8566: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8596: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8624: warning #2111-D: statement is unreachable
  		    NOT_REACHED; /* NOTREACHED */
  		    ^

"re_exec.c", line 8728: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    next = scan + ARG(scan);
  		                  ^

"re_exec.c", line 8745: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8763: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    scan = ST.me + ARG(ST.me);
  	                   ^

"re_exec.c", line 8772: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ARG(scan);
  	                  ^

"re_exec.c", line 8783: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        sv_yes_mark = sv_commit = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
  	                                  ^

"re_exec.c", line 8785: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8791: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8795: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_commit = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                              ^

"re_exec.c", line 8805: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8811: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                    ^

"re_exec.c", line 8815: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8820: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8840: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8853: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  SV *find = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                             ^

"re_exec.c", line 8885: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 9382: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	    while (scan < loceol && ANYOF_BITMAP_TEST(p, *((U8*)scan)))
  	                            ^

"re_exec.c", line 9396: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          scan = (char *) find_span_end_mask((U8 *) scan, (U8 *) loceol, (U8) ARG(p), FLAGS(p));
                                                                              ^

"re_exec.c", line 9712: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	if (ANYOF_BITMAP_TEST(n, c))
  	    ^

"re_exec.c", line 9725: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		&& ANYOF_BITMAP_TEST(n, PL_fold_locale[c]))
  		   ^

"re_exec.c", line 9729: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
              else if (ANYOF_POSIXL_TEST_ANY_SET(n)
                       ^

"re_exec.c", line 9767: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      if (ANYOF_POSIXL_TEST(n, count)
                          ^

"re_exec.c", line 9799: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	else if (    ARG(n) != ANYOF_ONLY_HAS_BITMAP
  	             ^

"re_exec.c", line 3200: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(strbeg + min, prog->subbeg, sublen, char);
              ^

"re_exec.c", line 4452: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c1_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 4453: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c2_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 7909: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    Renew(aux->poscache, size, char);
  			    ^

"re_exec.c", line 7912: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Zero(aux->poscache, size, char);
  			^

"re_exec.c", line 7916: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Newxz(aux->poscache, size, char);
  			^

"re_comp.c", line 3486: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    ARG_SET( convert, data_slot );
  	    ^

"re_comp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
                                      ^

"re_comp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
                                      ^

"re_comp.c", line 3616: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U32 trie_offset = ARG(source);
                              ^

"re_comp.c", line 3641: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          StructCopy(source,op,struct regnode_1);
          ^

"re_comp.c", line 3646: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
          StructCopy(source,op,struct regnode_charclass);
          ^

"re_comp.c", line 3651: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      ARG_SET( stclass, data_slot );
      ^

"re_comp.c", line 4206: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      I32 is_par = OP(scan) == OPEN ? ARG(scan) : 0;
                                      ^

"re_comp.c", line 4287: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    int off = (reg_off_by_arg[OP(scan)] ? ARG(scan) : NEXT_OFF(scan));
  	                                          ^

"re_comp.c", line 4294: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((OP(n) == LONGJMP) && (noff = ARG(n))))
  		                                         ^

"re_comp.c", line 4298: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		ARG(scan) = off;
  		^

"re_comp.c", line 4815: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  paren = ARG(scan);
                          ^

"re_comp.c", line 4816: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  RExC_recurse[ARG2L(scan)] = scan;
                               ^

"re_comp.c", line 5219: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          RExC_open_parens[ARG(nxt1)]=oscan; /*open->CURLYM*/
                                           ^

"re_comp.c", line 5220: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          RExC_close_parens[ARG(nxt1)]=nxt+2; /*close->while*/
                                            ^

"re_comp.c", line 5223: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    oscan->flags = (U8)ARG(nxt);
  		                       ^

"re_comp.c", line 5264: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			oscan->flags = (U8)ARG(nxt);
  			                   ^

"re_comp.c", line 5266: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_open_parens[ARG(nxt1)]=oscan; /*open->CURLYM*/
                                               ^

"re_comp.c", line 5267: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_close_parens[ARG(nxt1)]=nxt2+1; /*close->NOTHING*/
                                                ^

"re_comp.c", line 5312: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			nxt += ARG(nxt);
  			       ^

"re_comp.c", line 5548: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                                  (regnode_charclass *) scan);
                                  ^

"re_comp.c", line 5551: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                                                            (regnode_charclass *) scan);
                                                            ^

"re_comp.c", line 5855: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen != (I32)ARG(scan))
  	                          ^

"re_comp.c", line 5859: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen == (I32)ARG(scan)) {
  	                          ^

"re_comp.c", line 5862: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if ((I32)ARG(scan) == is_par) {
  	             ^

"re_comp.c", line 5869: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		*(data->last_closep) = ARG(scan);
  		                       ^

"re_comp.c", line 5918: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
                                                                          ^

"re_comp.c", line 6117: warning #2111-D: statement is unreachable
      NOT_REACHED; /* NOTREACHED */
      ^

"re_comp.c", line 7514: warning #2187-D: use of "=" where "==" may have been intended
  	while ((OP(first) == OPEN && (sawopen = 1)) ||
  	                             ^

"re_comp.c", line 7518: warning #2187-D: use of "=" where "==" may have been intended
  	    (OP(first) == IFMATCH && !first->flags && (sawlookahead = 1)) ||
  	                                              ^

"re_comp.c", line 7554: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        ((reg_trie_data *)ri->data->data[ ARG(first) ])->minlen>0)
  	                                          ^

"re_comp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          ARG2L_SET( scan, RExC_open_parens[ARG(scan)] - scan );
          ^

"re_comp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          ARG2L_SET( scan, RExC_open_parens[ARG(scan)] - scan );
          ^

"re_comp.c", line 11020: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      ARG(ret) = add_data( pRExC_state,
                      ^

"re_comp.c", line 11022: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      RExC_rxi->data->data[ARG(ret)]=(void*)sv;
                                           ^

"re_comp.c", line 11028: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      ARG2L_SET(ret, internal_argval);
                      ^

"re_comp.c", line 11301: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
                      ^

"re_comp.c", line 11301: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
                      ^

"re_comp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ANYOF_BITMAP_ZERO(node);
      ^

"re_comp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ANYOF_BITMAP_ZERO(node);
      ^

"re_comp.c", line 14382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (! ANYOF_BITMAP_TEST(node, i)) {
  		      ^

"re_comp.c", line 14383: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		    ANYOF_BITMAP_SET(node, i);
  		    ^

"re_comp.c", line 17142: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      ANYOF_POSIXL_ZERO(ret);
                      ^

"re_comp.c", line 17159: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      && ANYOF_POSIXL_TEST(ret, namedclass + ((namedclass % 2)
                         ^

"re_comp.c", line 17170: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                  ANYOF_POSIXL_SET(ret, namedclass);
                  ^

"re_comp.c", line 18705: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(node, ANYOF_ONLY_HAS_BITMAP);
  	^

"re_comp.c", line 18736: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(node, n);
  	^

"re_comp.c", line 19174: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          FILL_ADVANCE_NODE_ARG(ptr, op, arg);
          ^

"re_comp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2);
          ^

"re_comp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2);
          ^

"re_comp.c", line 19348: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          ARG_SET(scan, val - scan);
          ^

"re_comp.c", line 19446: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(scan, val - scan);
  	^

"re_comp.c", line 19463: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U8 lowest = (U8) ARG(n);
                             ^

"re_comp.c", line 19473: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ((i & FLAGS(n)) == ARG(n)) {
                                ^

"re_comp.c", line 19746: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          const U32 n = ARG(o);
                        ^

"re_comp.c", line 19770: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              (void) put_charclass_bitmap_innards(sv,
                     ^

"re_comp.c", line 19798: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          U32 parno= OP(o) == ACCEPT ? (U32)ARG2L(o) : ARG(o);
                                            ^

"re_comp.c", line 19798: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          U32 parno= OP(o) == ACCEPT ? (U32)ARG2L(o) : ARG(o);
                                                       ^

"re_comp.c", line 19826: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              U32 n = ARG(o);  /* which paren pair */
                      ^

"re_comp.c", line 19848: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          Perl_sv_catpvf(aTHX_ sv, "%d[%+d:%d]", (int)ARG(o),(int)ARG2L(o),
                                                      ^

"re_comp.c", line 19848: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          Perl_sv_catpvf(aTHX_ sv, "%d[%+d:%d]", (int)ARG(o),(int)ARG2L(o),
                                                                  ^

"re_comp.c", line 19849: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  (int)((o + (int)ARG2L(o)) - progi->program) );
                                  ^

"re_comp.c", line 19851: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              SV **name= av_fetch(name_list, ARG(o), 0 );
                         ^

"re_comp.c", line 19887: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if (ARG(o) != ANYOF_ONLY_HAS_BITMAP) {
              ^

"re_comp.c", line 19917: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
          do_sep = put_charclass_bitmap_innards(sv,
                   ^

"re_comp.c", line 20055: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ( ARG(o) )
               ^

"re_comp.c", line 20057: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                         SVfARG((MUTABLE_SV(progi->data->data[ ARG( o ) ]))));
                         ^

"re_comp.c", line 21157: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
              if (ANYOF_POSIXL_TEST_ANY_SET(node)) {
                  ^

"re_comp.c", line 21162: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      if (ANYOF_POSIXL_TEST(node,i)) {
                          ^

"re_comp.c", line 21394: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              const U32 n = ARG(node);
                            ^

"re_comp.c", line 3913: warning #4276-D: relational operator ">" always evaluates to 'false'
              Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
              ^

"re_comp.c", line 3977: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Newx(folded, UTF8_MAX_FOLD_CHAR_EXPAND * STR_LEN(scan) + 1, U8);
                  ^

"re_comp.c", line 3982: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 4863: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Zero(RExC_study_chunk_recursed, RExC_study_chunk_recursed_bytes, U8);
                          ^

"re_comp.c", line 4865: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(RExC_study_chunk_recursed + ((recursed_depth-1) * RExC_study_chunk_recursed_bytes),
                          ^

"re_comp.c", line 6127: warning #4276-D: relational operator ">" always evaluates to 'false'
      Renewc(RExC_rxi->data,
      ^

"re_comp.c", line 6131: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Renew(RExC_rxi->data->what, count + n, U8);
  	^

"re_comp.c", line 6133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(RExC_rxi->data->what, n, U8);
  	^

"re_comp.c", line 6135: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(s, RExC_rxi->data->what + count, n, U8);
      ^

"re_comp.c", line 6312: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newx(dst, *plen_p * 2 + 1, U8);
      ^

"re_comp.c", line 6672: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(newpat, newlen, char);
  	^

"re_comp.c", line 7278: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newxc(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode),
      ^

"re_comp.c", line 7284: warning #4276-D: relational operator ">" always evaluates to 'false'
      Zero(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode),
      ^

"re_comp.c", line 7347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Copy(name, p, len, char);
  	    ^

"re_comp.c", line 7362: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(RExC_precomp, p, plen, char);
          ^

"re_comp.c", line 7427: warning #4276-D: relational operator ">" always evaluates to 'false'
          Newx(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 7455: warning #4276-D: relational operator ">" always evaluates to 'false'
          Zero(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 9975: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(SvPVX(invlist), SvPVX(new_invlist), physical_length, char);
      ^

"re_comp.c", line 12729: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy((char *) character, STRING(node), len, char);
              ^

"re_comp.c", line 20656: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat1, buf, l1 , char);
      ^

"re_comp.c", line 20657: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat2, buf + l1, l2 , char);
      ^

"re_comp.c", line 20666: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(message, buf, l1 , char);
      ^

"re.c", line 296: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

[2018-08-09 23:01:24+0200] Skip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2018-08-09 23:01:24+0200] 
[2018-08-09 23:01:24+0200]  Tests start here:
[2018-08-09 23:01:24+0200] TSTENV = stdio	
No saved state, selection will be empty
Subroutine Math::BigInt::carp redefined at t/option_l.t line 16.
Cannot figure out an encoding to use at t/use-Encode-Alias.t line 5.
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
# Connected to 127.0.0.1
# Connected to 127.0.0.1
Integer overflow in hexadecimal number at t/broken_univ_can.t line 7.
Redefining sub xChild::foo at xChild--12109 line 2.
Redefining sub Data::ok at -e line 1.
c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

# Will use Digest::MD5
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
[2018-08-09 23:13:50+0200] 
[2018-08-09 23:13:50+0200] All tests successful.
[2018-08-09 23:13:50+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2018-08-09 23:13:50+0200]     9, 18
[2018-08-09 23:13:50+0200] Archived results...
[2018-08-09 23:13:50+0200] TSTENV = perlio	
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
Cannot figure out an encoding to use at t/use-Encode-Alias.t line 5.
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

Subroutine Math::BigInt::carp redefined at t/option_l.t line 16.
# Will use Digest::MD5
c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
Integer overflow in hexadecimal number at t/broken_univ_can.t line 7.
# Connected to 127.0.0.1
# Connected to 127.0.0.1
[2018-08-09 23:24:23+0200] 
[2018-08-09 23:24:23+0200] All tests successful.
[2018-08-09 23:24:23+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2018-08-09 23:24:23+0200]     9, 18
[2018-08-09 23:24:23+0200] Archived results...
[2018-08-09 23:24:23+0200] TSTENV = locale:en_US.utf8	
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

# Will use Digest::MD5
Subroutine Math::BigInt::carp redefined at t/option_l.t line 16.
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
recv() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at (eval 12) line 28.
Integer overflow in hexadecimal number at t/broken_univ_can.t line 7.
# Connected to 127.0.0.1
syswrite() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 47.
sysread() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 51.
# Connected to 127.0.0.1
syswrite() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 86.
sysread() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 90.
[2018-08-09 23:35:28+0200] 
[2018-08-09 23:35:28+0200] All tests successful.
[2018-08-09 23:35:28+0200] ../lib/B/Deparse.t..........................................PASSED
[2018-08-09 23:35:28+0200]     2
[2018-08-09 23:35:28+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2018-08-09 23:35:28+0200]     9, 18
[2018-08-09 23:35:28+0200] Archived results...
[2018-08-09 23:35:28+0200] Unskip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2018-08-09 23:35:28+0200] 
[2018-08-09 23:35:28+0200] Configuration: -Dusedevel -DDEBUGGING
[2018-08-09 23:35:28+0200] ------------------------------------------------------------------------------
[2018-08-09 23:35:28+0200] make distclean ...
[2018-08-09 23:36:09+0200] 
[2018-08-09 23:36:09+0200] Copy Policy.sh ...
[2018-08-09 23:36:09+0200] 
[2018-08-09 23:36:09+0200] Configure ...
5.29.2 <=> 5.026002
===== PROCURA Policy for hpux/ccache cc ========================
===== PROCURA Policy results ============================
cc:         ccache cc
ccversion:  -
gccversion: -
ccflags:    -DDEBUGGING +Z -z
optimize:   
ld:         
ldflags:    -L/pro/local/lib
libswanted: cl pthread cl pthread socket bind inet nsl ndbm gdbm dbm db malloc dl ld sun m crypt sec util c cposix posix ucb bsd BSD
libsdirs:    /lib /pro/local/lib
locincpth:  /pro/local/include
loclibpth:  /pro/local/lib
useshrplib: 
===== PROCURA Policy done ===============================
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
[2018-08-09 23:37:33+0200] 
[2018-08-09 23:37:33+0200] make ...
"op.c", line 12320: warning #2111-D: statement is unreachable
          ((0) ? (void)0 : __assert("0", "op.c", 12320));  
          ^

"op.c", line 12996: warning #2111-D: statement is unreachable
  	} ((0) ? (void)0 : __assert("0", "op.c", 12996));  
  	  ^

"op.c", line 15228: warning #2549-D: variable "defer_queue" is used before its value is set
                          defer_queue[(defer_base + defer_ix--) % 4];
                          ^

"op.c", line 16274: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "op.c", 16274));  
              ^

"op.c", line 3183: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l)))) ? (size_t)(l) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "op.c", 3183)), ((((void*)(argp->p)) != 0) ? (void)0 : __assert("((void*)(argp->p)) != 0", "op.c", 3183)), (void)memcpy((char*)(p),(const char*)(argp->p), (l) * sizeof(char)));
                                                                                                                                                                                        ^

"op.c", line 5143: warning #4276-D: relational operator ">" always evaluates to 'false'
      PL_compiling.cop_warnings = (((PL_compiling . cop_warnings) == 0L || (PL_compiling . cop_warnings) == (((STRLEN*)0)+1) || (PL_compiling . cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_compiling . cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings)))) ? (size_t)(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(malloc((sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings)))) != 0) ? (void)0 : __assert("((void*)(malloc((sizeof(*PL_compiling.cop_warnings)+*PL_compiling.cop_warnings)))) != 0", "op.c", 5143)), ((((void*)(PL_compiling . cop_warnings)) != 0) ? (void)0 : __assert("((void*)(PL_compiling.cop_warnings)) != 0", "op.c", 5143)), memcpy((char*)(malloc((sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings))),(const char*)(PL_compiling . cop_warnings), (sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 8048: warning #4276-D: relational operator ">" always evaluates to 'false'
      cop->cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) != 0) ? (void)0 : __assert("((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+*PL_curcop->cop_warnings)))) != 0", "op.c", 8048)), ((((void*)(PL_curcop->cop_warnings)) != 0) ? (void)0 : __assert("((void*)(PL_curcop->cop_warnings)) != 0", "op.c", 8048)), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 10502: warning #4276-D: relational operator ">" always evaluates to 'false'
  	 PL_compiling.cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) != 0) ? (void)0 : __assert("((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+*PL_curcop->cop_warnings)))) != 0", "op.c", 10502)), ((((void*)(PL_curcop->cop_warnings)) != 0) ? (void)0 : __assert("((void*)(PL_curcop->cop_warnings)) != 0", "op.c", 10502)), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"op.c", line 12436: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(end - s - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(end - s - 1)))) ? (size_t)(end - s - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(s+1)) != 0) ? (void)0 : __assert("((void*)(s+1)) != 0", "op.c", 12436)), ((((void*)(s+2)) != 0) ? (void)0 : __assert("((void*)(s+2)) != 0", "op.c", 12436)), (void)memmove((char*)(s+1),(const char*)(s+2), (end - s - 1) * sizeof(char)));
  		                                                                                                                                                                                                        ^

"op.c", line 12605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(tmpbuf+1)) != 0) ? (void)0 : __assert("((void*)(tmpbuf+1)) != 0", "op.c", 12605)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "op.c", 12605)), (void)memcpy((char*)(tmpbuf+1),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"perl.c", line 3496: warning #2111-D: statement is unreachable
          ((0) ? (void)0 : __assert("0", "perl.c", 3496));  
          ^

"perl.c", line 4578: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
            if (((((XPVHV*) (dups)->sv_any)->xhv_keys) - (((XPVMG*) (dups)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)dups) : 0))) {
                                                           ^

"gv.c", line 118: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(tmpbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen)))) ? (size_t)(tmplen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"gv.c", line 1464: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(tmpbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen)))) ? (size_t)(tmplen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"gv.c", line 1465: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(namelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(namelen)))) ? (size_t)(namelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "gv.c", 1465)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "gv.c", 1465)), (void)memcpy((char*)(tmpbuf),(const char*)(name), (namelen) * sizeof(char)));
                                                                                                                                                                                              ^

"gv.c", line 1657: warning #4276-D: relational operator ">" always evaluates to 'false'
                              (tmpfullbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(full_len+2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(full_len+2)))) ? (size_t)(full_len+2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((full_len+2)*sizeof(char))))));
                                                                                                                                                                                                                                             ^

"gv.c", line 1660: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*len)))) ? (size_t)(*len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "gv.c", 1660)), ((((void*)(*name)) != 0) ? (void)0 : __assert("((void*)(*name)) != 0", "gv.c", 1660)), (void)memcpy((char*)(tmpbuf),(const char*)(*name), (*len) * sizeof(char)));
                                                                                                                                                                                                     ^

"toke.c", line 1036: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(bufptr+len+highhalf)) != 0) ? (void)0 : __assert("((void*)(bufptr+len+highhalf)) != 0", "toke.c", 1036)), ((((void*)(bufptr)) != 0) ? (void)0 : __assert("((void*)(bufptr)) != 0", "toke.c", 1036)), (void)memmove((char*)(bufptr+len+highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1062: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(bufptr+len-highhalf)) != 0) ? (void)0 : __assert("((void*)(bufptr+len-highhalf)) != 0", "toke.c", 1062)), ((((void*)(bufptr)) != 0) ? (void)0 : __assert("((void*)(bufptr)) != 0", "toke.c", 1062)), (void)memmove((char*)(bufptr+len-highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1082: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(bufptr+len)) != 0) ? (void)0 : __assert("((void*)(bufptr+len)) != 0", "toke.c", 1082)), ((((void*)(bufptr)) != 0) ? (void)0 : __assert("((void*)(bufptr)) != 0", "toke.c", 1082)), (void)memmove((char*)(bufptr+len),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1085: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(bufptr)) != 0) ? (void)0 : __assert("((void*)(bufptr)) != 0", "toke.c", 1085)), ((((void*)(pv)) != 0) ? (void)0 : __assert("((void*)(pv)) != 0", "toke.c", 1085)), (void)memcpy((char*)(bufptr),(const char*)(pv), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 1180: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufend+1-ptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufend+1-ptr)))) ? (size_t)(bufend+1-ptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "toke.c", 1180)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "toke.c", 1180)), (void)memmove((char*)(buf),(const char*)(ptr), (bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                             ^

"toke.c", line 1258: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-ptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-ptr)))) ? (size_t)(PL_parser->bufend+1-ptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "toke.c", 1258)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "toke.c", 1258)), (void)memmove((char*)(buf),(const char*)(ptr), (PL_parser->bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                                                              ^

"toke.c", line 1810: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (tmpbuf2 = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen2 + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen2 + 2)))) ? (size_t)(tmplen2 + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen2 + 2)*sizeof(char))))));
  		                                                                                                                                                                                                                   ^

"toke.c", line 3718: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(e - orig_s + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(e - orig_s + 1)))) ? (size_t)(e - orig_s + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 3718)), ((((void*)(orig_s)) != 0) ? (void)0 : __assert("((void*)(orig_s)) != 0", "toke.c", 3718)), (void)memcpy((char*)(d),(const char*)(orig_s), (e - orig_s + 1) * sizeof(char)));
                                                                                                                                                                                                                                       ^

"toke.c", line 3809: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(initial_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(initial_len)))) ? (size_t)(initial_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 3809)), ((((void*)(initial_text)) != 0) ? (void)0 : __assert("((void*)(initial_text)) != 0", "toke.c", 3809)), (void)memcpy((char*)(d),(const char*)(initial_text), (initial_len) * sizeof(char)));
                                                                                                                                                                                                                                      ^

"toke.c", line 3860: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_length)))) ? (size_t)(output_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 3860)), ((((void*)(hex_string)) != 0) ? (void)0 : __assert("((void*)(hex_string)) != 0", "toke.c", 3860)), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                            ^

"toke.c", line 3881: warning #4276-D: relational operator ">" always evaluates to 'false'
                                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_length)))) ? (size_t)(output_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 3881)), ((((void*)(hex_string)) != 0) ? (void)0 : __assert("((void*)(hex_string)) != 0", "toke.c", 3881)), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                                ^

"toke.c", line 3950: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 3950)), ((((void*)(str)) != 0) ? (void)0 : __assert("((void*)(str)) != 0", "toke.c", 3950)), (void)memcpy((char*)(d),(const char*)(str), (len) * sizeof(char)));
  			                                                                                                                                                                            ^

"toke.c", line 4031: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 4031)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 4031)), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                      ^

"toke.c", line 4093: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((PL_valid_types_PVX[((svtype)((sv)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]", "toke.c", 4093)); ((!((((sv)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((sv)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((sv)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(sv)", "toke.c", 4093)); ((!(((svtype)((sv)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (sv)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(sv) == SVt_PVIO && !(IoFLAGS(sv) & IOf_FAKE_DIRP))", "toke.c", 4093)); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((PL_valid_types_PVX[((svtype)(((sv))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((sv)) & SVt_MASK]", "toke.c", 4093)); ((!(((((sv))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((sv))", "toke.c", 4093)); ((!(((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((sv))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((sv)) == SVt_PVIO && !(IoFLAGS((sv)) & IOf_FAKE_DIRP))", "toke.c", 4093)); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^

"toke.c", line 4837: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  			                                                                                                                                                                                                                                                                                            ^

"toke.c", line 4916: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((PL_parser->lex_casestack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_casemods) + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_casemods) + 2)))) ? (size_t)((PL_parser->lex_casemods) + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_casestack)),(size_t)(((PL_parser->lex_casemods) + 2)*sizeof(char))))));
  		                                                                                                                                                                                                                                                                                            ^

"toke.c", line 5036: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((PL_valid_types_PVX[((svtype)((sv)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]", "toke.c", 5036)); ((!((((sv)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((sv)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((sv)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(sv)", "toke.c", 5036)); ((!(((svtype)((sv)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (sv)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(sv) == SVt_PVIO && !(IoFLAGS(sv) & IOf_FAKE_DIRP))", "toke.c", 5036)); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((PL_valid_types_PVX[((svtype)(((sv))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((sv)) & SVt_MASK]", "toke.c", 5036)); ((!(((((sv))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((sv))", "toke.c", 5036)); ((!(((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((sv))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((sv)) == SVt_PVIO && !(IoFLAGS((sv)) & IOf_FAKE_DIRP))", "toke.c", 5036)); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^

"toke.c", line 5887: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                ^

"toke.c", line 6137: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                ^

"toke.c", line 7179: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(tmpbuf+1)) != 0) ? (void)0 : __assert("((void*)(tmpbuf+1)) != 0", "toke.c", 7179)), ((((void*)((PL_parser->tokenbuf))) != 0) ? (void)0 : __assert("((void*)((PL_parser->tokenbuf))) != 0", "toke.c", 7179)), (void)memcpy((char*)(tmpbuf+1),(const char*)((PL_parser->tokenbuf)), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 7774: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(olen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(olen)))) ? (size_t)(olen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((PL_parser->tokenbuf))) != 0) ? (void)0 : __assert("((void*)((PL_parser->tokenbuf))) != 0", "toke.c", 7774)), ((((void*)((PL_parser->bufptr))) != 0) ? (void)0 : __assert("((void*)((PL_parser->bufptr))) != 0", "toke.c", 7774)), (void)memcpy((char*)((PL_parser->tokenbuf)),(const char*)((PL_parser->bufptr)), (olen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"toke.c", line 9163: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s - w) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s - w)))) ? (size_t)(s - w) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(tmpbuf+1)) != 0) ? (void)0 : __assert("((void*)(tmpbuf+1)) != 0", "toke.c", 9163)), ((((void*)(w)) != 0) ? (void)0 : __assert("((void*)(w)) != 0", "toke.c", 9163)), (void)memcpy((char*)(tmpbuf+1),(const char*)(w), (s - w) * sizeof(char)));
  		                                                                                                                                                                                  ^

"toke.c", line 9342: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(t - *s) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(t - *s)))) ? (size_t)(t - *s) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(*d)) != 0) ? (void)0 : __assert("((void*)(*d)) != 0", "toke.c", 9342)), ((((void*)(*s)) != 0) ? (void)0 : __assert("((void*)(*s)) != 0", "toke.c", 9342)), (void)memcpy((char*)(*d),(const char*)(*s), (t - *s) * sizeof(char)));
                                                                                                                                                                                                   ^

"toke.c", line 9376: warning #4276-D: relational operator ">" always evaluates to 'false'
          (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*s - olds + saw_tick + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*s - olds + saw_tick + 2)))) ? (size_t)(*s - olds + saw_tick + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((*s - olds + saw_tick + 2)*sizeof(char))))));  
                                                                                                                                                                                                                                                          ^

"toke.c", line 10031: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 10031)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 10031)), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"toke.c", line 10151: warning #4276-D: relational operator ">" always evaluates to 'false'
  			(indent = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(indent_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(indent_len + 1)))) ? (size_t)(indent_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((indent_len + 1)*sizeof(char))))));
  			                                                                                                                                                                                                                       ^

"toke.c", line 10203: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufend-s + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufend-s + 1)))) ? (size_t)(bufend-s + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "toke.c", 10203)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 10203)), (void)memmove((char*)(d),(const char*)(s), (bufend-s + 1) * sizeof(char)));
  	                                                                                                                                                                                                       ^

"toke.c", line 10287: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (indent = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(indent_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(indent_len + 1)))) ? (size_t)(indent_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((indent_len + 1)*sizeof(char))))));
  		                                                                                                                                                                                                                           ^

"toke.c", line 10367: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { const STRLEN _lEnGtH = ((XPV*) (tmpstr)->sv_any)->xpv_cur + 1; do { do { ((PL_valid_types_PVX[((svtype)((tmpstr)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(tmpstr) & SVt_MASK]", "toke.c", 10367)); ((!((((tmpstr)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((tmpstr)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((tmpstr)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(tmpstr)", "toke.c", 10367)); ((!(((svtype)((tmpstr)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (tmpstr)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(tmpstr) == SVt_PVIO && !(IoFLAGS(tmpstr) & IOf_FAKE_DIRP))", "toke.c", 10367)); (((XPV*) (tmpstr)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((PL_valid_types_PVX[((svtype)(((tmpstr))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((tmpstr)) & SVt_MASK]", "toke.c", 10367)); ((!(((((tmpstr))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((tmpstr))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((tmpstr))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((tmpstr))", "toke.c", 10367)); ((!(((svtype)(((tmpstr))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((tmpstr))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((tmpstr)) == SVt_PVIO && !(IoFLAGS((tmpstr)) & IOf_FAKE_DIRP))", "toke.c", 10367)); (((tmpstr))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((tmpstr)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"toke.c", line 10647: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(termlen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(termlen)))) ? (size_t)(termlen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(termstr)) != 0) ? (void)0 : __assert("((void*)(termstr)) != 0", "toke.c", 10647)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 10647)), (void)memcpy((char*)(termstr),(const char*)(s), (termlen) * sizeof(U8)));
  	                                                                                                                                                                                    ^

"toke.c", line 10816: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { do { ((PL_valid_types_PVX[((svtype)((sv)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]", "toke.c", 10816)); ((!((((sv)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((sv)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((sv)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(sv)", "toke.c", 10816)); ((!(((svtype)((sv)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (sv)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(sv) == SVt_PVIO && !(IoFLAGS(sv) & IOf_FAKE_DIRP))", "toke.c", 10816)); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)); } while (0); do { ((PL_valid_types_PVX[((svtype)(((sv))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((sv)) & SVt_MASK]", "toke.c", 10816)); ((!(((((sv))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((sv))", "toke.c", 10816)); ((!(((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((sv))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((sv)) == SVt_PVIO && !(IoFLAGS((sv)) & IOf_FAKE_DIRP))", "toke.c", 10816)); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)))))); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"toke.c", line 12245: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                            ^

"pad.c", line 2232: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (((XPVMG*) (proto)->sv_any)->xmg_u . xmg_magic)
           ^

"pad.c", line 2312: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVGV *" may cause misaligned access
  	else if (flags & 1) Perl_sv_sethek( retsv,(((XPVGV*)(cv)->sv_any)->xiv_u . xivu_namehek));
  	                                            ^

"pad.c", line 2746: warning #4276-D: relational operator ">" always evaluates to 'false'
      (alloc2 = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1)))) ? (size_t)(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1),sizeof(char)))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^

"pad.c", line 2753: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((pn)->xpadn_pv)) != 0) ? (void)0 : __assert("((void*)((pn)->xpadn_pv)) != 0", "pad.c", 2753)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "pad.c", 2753)), (void)memcpy((char*)((pn)->xpadn_pv),(const char*)(s), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"regcomp.c", line 3486: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    (((((struct regnode_1 *)convert)->arg1)) = ((data_slot)));
  	        ^

"regcomp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((struct regnode_charclass *)convert)->bitmap)) != 0) ? (void)0 : __assert("((void*)(((struct regnode_charclass *)convert)->bitmap)) != 0", "regcomp.c", 3504)), ((((void*)(trie ->bitmap)) != 0) ? (void)0 : __assert("((void*)(trie->bitmap)) != 0", "regcomp.c", 3504)), (void)memcpy((char*)(((struct regnode_charclass *)convert)->bitmap),(const char*)(trie ->bitmap), (((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                    ^

"regcomp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((struct regnode_charclass *)convert)->bitmap)) != 0) ? (void)0 : __assert("((void*)(((struct regnode_charclass *)convert)->bitmap)) != 0", "regcomp.c", 3504)), ((((void*)(trie ->bitmap)) != 0) ? (void)0 : __assert("((void*)(trie->bitmap)) != 0", "regcomp.c", 3504)), (void)memcpy((char*)(((struct regnode_charclass *)convert)->bitmap),(const char*)(trie ->bitmap), (((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^

"regcomp.c", line 3616: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U32 trie_offset = ((((struct regnode_1 *)source)->arg1));
                                 ^

"regcomp.c", line 3641: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (*((struct regnode_1*)(op)) = *((struct regnode_1*)(source)));
                                          ^

"regcomp.c", line 3646: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
          (*((struct regnode_charclass*)(op)) = *((struct regnode_charclass*)(source)));
                                                  ^

"regcomp.c", line 3651: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      (((((struct regnode_1 *)stclass)->arg1)) = ((data_slot)));
          ^

"regcomp.c", line 4206: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      I32 is_par = ((scan)->type) == 52 ? ((((struct regnode_1 *)scan)->arg1)) : 0;
                                             ^

"regcomp.c", line 4287: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    int off = (reg_off_by_arg[((scan)->type)] ? ((((struct regnode_1 *)scan)->arg1)) : ((scan)->next_off));
  	                                                   ^

"regcomp.c", line 4294: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((((n)->type) == 66) && (noff = ((((struct regnode_1 *)n)->arg1)))))
  		                                             ^

"regcomp.c", line 4298: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		((((struct regnode_1 *)scan)->arg1)) = off;
  		   ^

"regcomp.c", line 4815: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  paren = ((((struct regnode_1 *)scan)->arg1));
                             ^

"regcomp.c", line 4816: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  (pRExC_state ->recurse)[((((struct regnode_2L *)scan)->arg2))] = scan;
                                             ^

"regcomp.c", line 5219: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          (pRExC_state ->open_parens)[((((struct regnode_1 *)nxt1)->arg1))]=oscan;  
                                                         ^

"regcomp.c", line 5220: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          (pRExC_state ->close_parens)[((((struct regnode_1 *)nxt1)->arg1))]=nxt+2;  
                                                          ^

"regcomp.c", line 5223: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    oscan->flags = (U8)((((struct regnode_1 *)nxt)->arg1));
  		                          ^

"regcomp.c", line 5264: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			oscan->flags = (U8)((((struct regnode_1 *)nxt)->arg1));
  			                      ^

"regcomp.c", line 5266: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              (pRExC_state ->open_parens)[((((struct regnode_1 *)nxt1)->arg1))]=oscan;  
                                                             ^

"regcomp.c", line 5267: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              (pRExC_state ->close_parens)[((((struct regnode_1 *)nxt1)->arg1))]=nxt2+1;  
                                                              ^

"regcomp.c", line 5312: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			nxt += ((((struct regnode_1 *)nxt)->arg1));
  			          ^

"regcomp.c", line 5547: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  			S_ssc_and( pRExC_state,data->start_class,(regnode_charclass *) scan);
  			                                         ^

"regcomp.c", line 5550: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  			S_ssc_or( pRExC_state,data->start_class,(regnode_charclass *) scan);
  			                                        ^

"regcomp.c", line 5855: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen != (I32)((((struct regnode_1 *)scan)->arg1)))
  	                             ^

"regcomp.c", line 5859: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen == (I32)((((struct regnode_1 *)scan)->arg1))) {
  	                             ^

"regcomp.c", line 5862: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if ((I32)((((struct regnode_1 *)scan)->arg1)) == is_par) {
  	                ^

"regcomp.c", line 5869: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		*(data->last_closep) = ((((struct regnode_1 *)scan)->arg1));
  		                          ^

"regcomp.c", line 5918: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_trie_data *trie = (reg_trie_data*)(pRExC_state ->rxi)->data->data[ ((((struct regnode_1 *)scan)->arg1)) ];
                                                                                        ^

"regcomp.c", line 6117: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "regcomp.c", 6117));  
      ^

"regcomp.c", line 7514: warning #2187-D: use of "=" where "==" may have been intended
  	while ((((first)->type) == 52 && (sawopen = 1)) ||
  	                                 ^

"regcomp.c", line 7518: warning #2187-D: use of "=" where "==" may have been intended
  	    (((first)->type) == 68 && !first->flags && (sawlookahead = 1)) ||
  	                                               ^

"regcomp.c", line 7554: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        ((reg_trie_data *)ri->data->data[ ((((struct regnode_1 *)first)->arg1)) ])->minlen>0)
  	                                             ^

"regcomp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          (((((struct regnode_2L *)scan)->arg2)) = (((pRExC_state ->open_parens)[((((struct regnode_1 *)scan)->arg1))] - scan)));
              ^

"regcomp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (((((struct regnode_2L *)scan)->arg2)) = (((pRExC_state ->open_parens)[((((struct regnode_1 *)scan)->arg1))] - scan)));
                                                                                    ^

"regcomp.c", line 11020: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      ((((struct regnode_1 *)ret)->arg1)) = S_add_data( pRExC_state,
                         ^

"regcomp.c", line 11022: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      (pRExC_state ->rxi)->data->data[((((struct regnode_1 *)ret)->arg1))]=(void*)sv;
                                                         ^

"regcomp.c", line 11028: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      (((((struct regnode_2L *)ret)->arg2)) = ((internal_argval)));
                          ^

"regcomp.c", line 11301: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      do { if (__builtin_expect(((PL_debug & 0x00000200) ? (_Bool)1 : (_Bool)0),(0))) do {if ((0x100000|0x000002) == (re_debug_flags & (0x100000|0x000002)) ) Perl_re_printf( "%*s%*s Recurse #%" "lu" " to %" "ld" "\n", 22, "|    |", (int)(depth * 2 + 1), "", (UV)((((struct regnode_1 *)ret)->arg1)), (IV)((((struct regnode_2L *)ret)->arg2)));} while (0); } while (0);
                                                                                                                                                                                                                                                                                         ^

"regcomp.c", line 11301: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      do { if (__builtin_expect(((PL_debug & 0x00000200) ? (_Bool)1 : (_Bool)0),(0))) do {if ((0x100000|0x000002) == (re_debug_flags & (0x100000|0x000002)) ) Perl_re_printf( "%*s%*s Recurse #%" "lu" " to %" "ld" "\n", 22, "|    |", (int)(depth * 2 + 1), "", (UV)((((struct regnode_1 *)ret)->arg1)), (IV)((((struct regnode_2L *)ret)->arg2)));} while (0); } while (0);
                                                                                                                                                                                                                                                                                                                                  ^

"regcomp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((regnode_charclass*)(node))->bitmap)) != 0) ? (void)0 : __assert("((void*)(((regnode_charclass*)(node))->bitmap)) != 0", "regcomp.c", 14352)), (void)memset((char*)(((regnode_charclass*)(node))->bitmap),0,(((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                        ^

"regcomp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((regnode_charclass*)(node))->bitmap)) != 0) ? (void)0 : __assert("((void*)(((regnode_charclass*)(node))->bitmap)) != 0", "regcomp.c", 14352)), (void)memset((char*)(((regnode_charclass*)(node))->bitmap),0,(((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"regcomp.c", line 14382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (! (((( (U8*) ((regnode_charclass*)(node))->bitmap) [ ( ( (UV) (i)) >> 3) ] ) & (1U << ((i) & 7))) ? (_Bool)1 : (_Bool)0)) {
  		                  ^

"regcomp.c", line 14383: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		    ((( (U8*) ((regnode_charclass*)(node))->bitmap) [ ( ( (UV) (i)) >> 3) ] ) |= (1U << ((i) & 7)));
  		               ^

"regcomp.c", line 17142: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      do { ((regnode_charclass_posixl*) (ret))->classflags = 0; } while (0);
                            ^

"regcomp.c", line 17159: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      && (((regnode_charclass_posixl*) (ret))->classflags & (1U << (namedclass + ((namedclass % 2) ? -1 : 1)))))
                           ^

"regcomp.c", line 17170: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                  (((regnode_charclass_posixl*) (ret))->classflags |= (1U << (namedclass)));
                    ^

"regcomp.c", line 18705: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	(((((struct regnode_1 *)node)->arg1)) = ((((U32) -1))));
  	    ^

"regcomp.c", line 18736: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	(((((struct regnode_1 *)node)->arg1)) = ((n)));
  	    ^

"regcomp.c", line 18787: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	const U32 n = ((((struct regnode_1 *)node)->arg1));
  	                 ^

"regcomp.c", line 19174: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 1; } while (0);
                   ^

"regcomp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg1))); (((((struct regnode_2L *)ptr)->arg2)) = ((arg2))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 2; } while (0);
                   ^

"regcomp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg1))); (((((struct regnode_2L *)ptr)->arg2)) = ((arg2))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 2; } while (0);
                                                                     ^

"regcomp.c", line 19348: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (((((struct regnode_1 *)scan)->arg1)) = ((val - scan)));
              ^

"regcomp.c", line 19446: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	(((((struct regnode_1 *)scan)->arg1)) = ((val - scan)));
  	    ^

"regcomp.c", line 19463: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U8 lowest = (U8) ((((struct regnode_1 *)n)->arg1));
                                ^

"regcomp.c", line 19473: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ((i & ((n)->flags)) == ((((struct regnode_1 *)n)->arg1))) {
                                       ^

"regcomp.c", line 19746: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          const U32 n = ((((struct regnode_1 *)o)->arg1));
                           ^

"regcomp.c", line 19770: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              (void) S_put_charclass_bitmap_innards( sv,((((op)==78 || (op)==80)) ? ((regnode_charclass*)(o))->bitmap : (((reg_trie_data *)(trie))->bitmap)),0L,0L,0L,(0));
                                                                                     ^

"regcomp.c", line 19798: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          U32 parno= ((o)->type) == 87 ? (U32)((((struct regnode_2L *)o)->arg2)) : ((((struct regnode_1 *)o)->arg1));
                                                 ^

"regcomp.c", line 19798: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          U32 parno= ((o)->type) == 87 ? (U32)((((struct regnode_2L *)o)->arg2)) : ((((struct regnode_1 *)o)->arg1));
                                                                                      ^

"regcomp.c", line 19826: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              U32 n = ((((struct regnode_1 *)o)->arg1));   
                         ^

"regcomp.c", line 19848: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          Perl_sv_catpvf( sv, "%d[%+d:%d]", (int)((((struct regnode_1 *)o)->arg1)),(int)((((struct regnode_2L *)o)->arg2)),
                                                    ^

"regcomp.c", line 19848: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          Perl_sv_catpvf( sv, "%d[%+d:%d]", (int)((((struct regnode_1 *)o)->arg1)),(int)((((struct regnode_2L *)o)->arg2)),
                                                                                           ^

"regcomp.c", line 19849: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  (int)((o + (int)((((struct regnode_2L *)o)->arg2))) - progi->program) );
                                     ^

"regcomp.c", line 19851: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              SV **name= Perl_av_fetch( name_list,((((struct regnode_1 *)o)->arg1)),0);
                                                     ^

"regcomp.c", line 19887: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if (((((struct regnode_1 *)o)->arg1)) != ((U32) -1)) {
                 ^

"regcomp.c", line 19927: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  S_put_charclass_bitmap_innards( sv,((regnode_charclass*)(o))->bitmap,bitmap_range_not_in_bitmap,only_utf8_locale_invlist,o,unresolved != 0L);
                                      ^

"regcomp.c", line 20055: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ( ((((struct regnode_1 *)o)->arg1)) )
                  ^

"regcomp.c", line 20057: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                         ((void*)((((SV *)((void *) (progi->data->data[ ((((struct regnode_1 *)o)->arg1)) ])))))));
                                                                           ^

"regcomp.c", line 20632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      offset = (reg_off_by_arg[((p)->type)] ? ((((struct regnode_1 *)p)->arg1)) : ((p)->next_off));
                                                 ^

"regcomp.c", line 21157: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
              if (((((node)->flags) & 0x02) && (((regnode_charclass_posixl*)(node))->classflags))) {
                                                 ^

"regcomp.c", line 21162: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      if ((((regnode_charclass_posixl*) (node))->classflags & (1U << (i)))) {
                            ^

"regcomp.c", line 21394: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              const U32 n = ((((struct regnode_1 *)node)->arg1));
                               ^

"regcomp.c", line 3913: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((((struct regnode_string *)n)->str_len)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((((struct regnode_string *)n)->str_len))))) ? (size_t)((((struct regnode_string *)n)->str_len)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((((struct regnode_string *)scan)->string) + oldl)) != 0) ? (void)0 : __assert("((void*)((((struct regnode_string *)scan)->string) + oldl)) != 0", "regcomp.c", 3913)), ((((void*)((((struct regnode_string *)n)->string))) != 0) ? (void)0 : __assert("((void*)((((struct regnode_string *)n)->string))) != 0", "regcomp.c", 3913)), (void)memmove((char*)((((struct regnode_string *)scan)->string) + oldl),(const char*)((((struct regnode_string *)n)->string)), ((((struct regnode_string *)n)->str_len)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                      ^

"regcomp.c", line 3977: warning #4276-D: relational operator ">" always evaluates to 'false'
                  (folded = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(3 * (((struct regnode_string *)scan)->str_len) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(3 * (((struct regnode_string *)scan)->str_len) + 1)))) ? (size_t)(3 * (((struct regnode_string *)scan)->str_len) + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((3 * (((struct regnode_string *)scan)->str_len) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                 ^

"regcomp.c", line 3982: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s_len)))) ? (size_t)(s_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "regcomp.c", 3982)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "regcomp.c", 3982)), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s_len)))) ? (size_t)(s_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "regcomp.c", 3987)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "regcomp.c", 3987)), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 4863: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((pRExC_state ->study_chunk_recursed))) != 0) ? (void)0 : __assert("((void*)((pRExC_state->study_chunk_recursed))) != 0", "regcomp.c", 4863)), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 4865: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((pRExC_state ->study_chunk_recursed) + (recursed_depth * (pRExC_state ->study_chunk_recursed_bytes)))) != 0) ? (void)0 : __assert("((void*)((pRExC_state->study_chunk_recursed) + (recursed_depth * (pRExC_state->study_chunk_recursed_bytes)))) != 0", "regcomp.c", 4867)), ((((void*)((pRExC_state ->study_chunk_recursed) + ((recursed_depth-1) * (pRExC_state ->study_chunk_recursed_bytes)))) != 0) ? (void)0 : __assert("((void*)((pRExC_state->study_chunk_recursed) + ((recursed_depth-1) * (pRExC_state->study_chunk_recursed_bytes)))) != 0", "regcomp.c", 4867)), (void)memcpy((char*)((pRExC_state ->study_chunk_recursed) + (recursed_depth * (pRExC_state ->study_chunk_recursed_bytes))),(const char*)((pRExC_state ->study_chunk_recursed) + ((recursed_depth-1) * (pRExC_state ->study_chunk_recursed_bytes))), ((pRExC_state ->study_chunk_recursed_bytes)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 6127: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi)->data = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1))))) ? (size_t)(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (struct reg_data*)(Perl_safesysrealloc((void *)((pRExC_state ->rxi)->data),(size_t)((sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"regcomp.c", line 6131: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((pRExC_state ->rxi)->data->what = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(count + n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(count + n)))) ? (size_t)(count + n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)((pRExC_state ->rxi)->data->what),(size_t)((count + n)*sizeof(U8))))));
  	                                                                                                                                                                                                                             ^

"regcomp.c", line 6133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((pRExC_state ->rxi)->data->what = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((n)*sizeof(U8))))));
  	                                                                                                                                                                                                     ^

"regcomp.c", line 6135: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((pRExC_state ->rxi)->data->what + count)) != 0) ? (void)0 : __assert("((void*)((pRExC_state->rxi)->data->what + count)) != 0", "regcomp.c", 6135)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "regcomp.c", 6135)), (void)memcpy((char*)((pRExC_state ->rxi)->data->what + count),(const char*)(s), (n) * sizeof(U8)));
                                                                                                                                                                        ^

"regcomp.c", line 6312: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*plen_p * 2 + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*plen_p * 2 + 1)))) ? (size_t)(*plen_p * 2 + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((*plen_p * 2 + 1)*sizeof(U8))))));
                                                                                                                                                                                                                         ^

"regcomp.c", line 6672: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(newpat = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(newlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(newlen)))) ? (size_t)(newlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((newlen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"regcomp.c", line 7278: warning #4276-D: relational operator ">" always evaluates to 'false'
      (ri = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode))))) ? (size_t)(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (regexp_internal*)(Perl_safesysmalloc((size_t)((sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                             ^

"regcomp.c", line 7284: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode))))) ? (size_t)(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(ri)) != 0) ? (void)0 : __assert("((void*)(ri)) != 0", "regcomp.c", 7285)), (void)memset((char*)(ri),0,(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 7347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "regcomp.c", 7347)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "regcomp.c", 7347)), (void)memcpy((char*)(p),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"regcomp.c", line 7362: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(plen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(plen)))) ? (size_t)(plen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "regcomp.c", 7362)), ((((void*)((pRExC_state ->precomp))) != 0) ? (void)0 : __assert("((void*)((pRExC_state->precomp))) != 0", "regcomp.c", 7362)), (void)memcpy((char*)(p),(const char*)((pRExC_state ->precomp)), (plen) * sizeof(char)));
                                                                                                                                                                                         ^

"regcomp.c", line 7427: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((pRExC_state ->study_chunk_recursed) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)(((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                                                                    ^

"regcomp.c", line 7455: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((pRExC_state ->study_chunk_recursed))) != 0) ? (void)0 : __assert("((void*)((pRExC_state->study_chunk_recursed))) != 0", "regcomp.c", 7456)), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                                                                            ^

"regcomp.c", line 8708: warning #4276-D: relational operator ">" always evaluates to 'false'
      do { do { ((PL_valid_types_PVX[((svtype)((invlist)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(invlist) & SVt_MASK]", "regcomp.c", 8708)); ((!((((invlist)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((invlist)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((invlist)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(invlist)", "regcomp.c", 8708)); ((!(((svtype)((invlist)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (invlist)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(invlist) == SVt_PVIO && !(IoFLAGS(invlist) & IOf_FAKE_DIRP))", "regcomp.c", 8708)); (((XPV*) (invlist)->sv_any)->xpv_len_u . xpvlenu_len = ((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))); } while (0); do { ((PL_valid_types_PVX[((svtype)(((invlist))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((invlist)) & SVt_MASK]", "regcomp.c", 8708)); ((!(((((invlist))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((invlist))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((invlist))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((invlist))", "regcomp.c", 8708)); ((!(((svtype)(((invlist))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((invlist))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((invlist)) == SVt_PVIO && !(IoFLAGS((invlist)) & IOf_FAKE_DIRP))", "regcomp.c", 8708)); (((invlist))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))))) ? (size_t)((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((invlist)->sv_u . svu_pv), (size_t)(((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))))))); } while (0); } while (0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ^

"regcomp.c", line 9975: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(physical_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(physical_length)))) ? (size_t)(physical_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((new_invlist)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((new_invlist)->sv_u.svu_pv))) != 0", "regcomp.c", 9975)), ((((void*)(((invlist)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((invlist)->sv_u.svu_pv))) != 0", "regcomp.c", 9975)), (void)memcpy((char*)(((new_invlist)->sv_u . svu_pv)),(const char*)(((invlist)->sv_u . svu_pv)), (physical_length) * sizeof(char)));
                                                                                                                                                                                                                      ^

"regcomp.c", line 12729: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((((struct regnode_string *)node)->string))) != 0) ? (void)0 : __assert("((void*)((((struct regnode_string *)node)->string))) != 0", "regcomp.c", 12729)), ((((void*)((char *) character)) != 0) ? (void)0 : __assert("((void*)((char *) character)) != 0", "regcomp.c", 12729)), (void)memcpy((char*)((((struct regnode_string *)node)->string)),(const char*)((char *) character), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"regcomp.c", line 20656: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l1)))) ? (size_t)(l1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "regcomp.c", 20656)), ((((void*)(pat1)) != 0) ? (void)0 : __assert("((void*)(pat1)) != 0", "regcomp.c", 20656)), (void)memcpy((char*)(buf),(const char*)(pat1), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 20657: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l2)))) ? (size_t)(l2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buf + l1)) != 0) ? (void)0 : __assert("((void*)(buf + l1)) != 0", "regcomp.c", 20657)), ((((void*)(pat2)) != 0) ? (void)0 : __assert("((void*)(pat2)) != 0", "regcomp.c", 20657)), (void)memcpy((char*)(buf + l1),(const char*)(pat2), (l2) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 20666: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l1)))) ? (size_t)(l1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "regcomp.c", 20666)), ((((void*)(message)) != 0) ? (void)0 : __assert("((void*)(message)) != 0", "regcomp.c", 20666)), (void)memcpy((char*)(buf),(const char*)(message), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 21596: warning #4276-D: relational operator ">" always evaluates to 'false'
      (lookup_name = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                                 ^

"dump.c", line 1967: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	usedkeys = ((((XPVHV*) (((HV *)((void *) (sv))))->sv_any)->xhv_keys) - (((XPVMG*) (((HV *)((void *) (sv))))->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)((HV *)((void *) (sv)))) : 0));
  	                                                                         ^

"dump.c", line 2672: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "dump.c", 2672));  
              ^

"dump.c", line 2681: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "dump.c", 2681));  
              ^

"dump.c", line 2692: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "dump.c", 2692));  
              ^

"dump.c", line 2702: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "dump.c", 2702));  
              ^

"dump.c", line 2710: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "dump.c", 2710));  
              ^

"util.c", line 1053: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(pvlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(pvlen)))) ? (size_t)(pvlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((pvlen)*sizeof(char))))));
  	                                                                                                                                                                                             ^

"util.c", line 1084: warning #4276-D: relational operator ">" always evaluates to 'false'
      (newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len+1)*sizeof(char))))));
                                                                                                                                                                                                   ^

"util.c", line 1089: warning #4276-D: relational operator ">" always evaluates to 'false'
      	return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(newaddr)) != 0) ? (void)0 : __assert("((void*)(newaddr)) != 0", "util.c", 1089)), ((((void*)(pv)) != 0) ? (void)0 : __assert("((void*)(pv)) != 0", "util.c", 1089)), memcpy((char*)(newaddr),(const char*)(pv), (len) * sizeof(char)));
      	                                                                                                                                                                                            ^

"util.c", line 1092: warning #4276-D: relational operator ">" always evaluates to 'false'
  	return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(newaddr)) != 0) ? (void)0 : __assert("((void*)(newaddr)) != 0", "util.c", 1092)), memset((char*)(newaddr),0,(len+1) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"util.c", line 1170: warning #4276-D: relational operator ">" always evaluates to 'false'
      (newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                             ^

"util.c", line 1171: warning #4276-D: relational operator ">" always evaluates to 'false'
      return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(newaddr)) != 0) ? (void)0 : __assert("((void*)(newaddr)) != 0", "util.c", 1171)), ((((void*)(pv)) != 0) ? (void)0 : __assert("((void*)(pv)) != 0", "util.c", 1171)), memcpy((char*)(newaddr),(const char*)(pv), (len) * sizeof(char)));
                                                                                                                                                                                                  ^

"util.c", line 2047: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((buffer + 1))) != 0) ? (void)0 : __assert("((void*)((buffer + 1))) != 0", "util.c", 2047)), ((((void*)(bits)) != 0) ? (void)0 : __assert("((void*)(bits)) != 0", "util.c", 2047)), (void)memcpy((char*)((buffer + 1)),(const char*)(bits), (size) * sizeof(char)));
                                                                                                                                                                                     ^

"util.c", line 2049: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(18 - size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(18 - size)))) ? (size_t)(18 - size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((char *)(buffer + 1) + size)) != 0) ? (void)0 : __assert("((void*)((char *)(buffer + 1) + size)) != 0", "util.c", 2049)), (void)memset((char*)((char *)(buffer + 1) + size),0,(18 - size) * sizeof(char)));
  	                                                                                                                                                                                              ^

"util.c", line 2150: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(tmpenv[j])) != 0) ? (void)0 : __assert("((void*)(tmpenv[j])) != 0", "util.c", 2150)), ((((void*)(environ[j])) != 0) ? (void)0 : __assert("((void*)(environ[j])) != 0", "util.c", 2150)), (void)memcpy((char*)(tmpenv[j]),(const char*)(environ[j]), (len+1) * sizeof(char)));
                                                                                                                                                                                                    ^

"util.c", line 2181: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(environ[i])) != 0) ? (void)0 : __assert("((void*)(environ[i])) != 0", "util.c", 2181)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2181)), (void)memcpy((char*)(environ[i]),(const char*)(nam), (nlen) * sizeof(char))); *(environ[i]+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(environ[i]+(nlen+1))) != 0) ? (void)0 : __assert("((void*)(environ[i]+(nlen+1))) != 0", "util.c", 2181)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2181)), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                         ^

"util.c", line 2181: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(environ[i])) != 0) ? (void)0 : __assert("((void*)(environ[i])) != 0", "util.c", 2181)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2181)), (void)memcpy((char*)(environ[i]),(const char*)(nam), (nlen) * sizeof(char))); *(environ[i]+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(environ[i]+(nlen+1))) != 0) ? (void)0 : __assert("((void*)(environ[i]+(nlen+1))) != 0", "util.c", 2181)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2181)), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ^

"util.c", line 2207: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(new_env)) != 0) ? (void)0 : __assert("((void*)(new_env)) != 0", "util.c", 2207)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2207)), (void)memcpy((char*)(new_env),(const char*)(nam), (nlen) * sizeof(char))); *(new_env+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(new_env+(nlen+1))) != 0) ? (void)0 : __assert("((void*)(new_env+(nlen+1))) != 0", "util.c", 2207)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2207)), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                             ^

"util.c", line 2207: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(new_env)) != 0) ? (void)0 : __assert("((void*)(new_env)) != 0", "util.c", 2207)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2207)), (void)memcpy((char*)(new_env),(const char*)(nam), (nlen) * sizeof(char))); *(new_env+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(new_env+(nlen+1))) != 0) ? (void)0 : __assert("((void*)(new_env+(nlen+1))) != 0", "util.c", 2207)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2207)), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ^

"util.c", line 3839: warning #4276-D: relational operator ">" always evaluates to 'false'
    (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(buflen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(buflen)))) ? (size_t)(buflen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((buflen)*sizeof(char))))));
                                                                                                                                                                                                ^

"util.c", line 3866: warning #4276-D: relational operator ">" always evaluates to 'false'
      (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufsize)))) ? (size_t)(bufsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(buf),(size_t)((bufsize)*sizeof(char))))));
                                                                                                                                                                                                     ^

"util.c", line 3882: warning #4276-D: relational operator ">" always evaluates to 'false'
        (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufsize)))) ? (size_t)(bufsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(buf),(size_t)((bufsize)*sizeof(char))))));
                                                                                                                                                                                                       ^

"vutil.c", line 335: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    || (((rev) < 0 ? -(rev) : (rev)) > 0x7FFFFFFF )) {
  			                                     ^

"vutil.c", line 535: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(raw + len - under - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(raw + len - under - 1)))) ? (size_t)(raw + len - under - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(under)) != 0) ? (void)0 : __assert("((void*)(under)) != 0", "vutil.c", 535)), ((((void*)(under + 1)) != 0) ? (void)0 : __assert("((void*)(under + 1)) != 0", "vutil.c", 535)), (void)memmove((char*)(under),(const char*)(under + 1), (raw + len - under - 1) * sizeof(char)));
  		                                                                                                                                                                                                                                  ^

"vutil.c", line 585: warning #4276-D: relational operator ">" always evaluates to 'false'
  	   || (((ver)->sv_flags & 0x00000100) && ((XPVIV*) (ver)->sv_any)->xiv_u . xivu_iv > 0x7FFFFFFF) ) {
  	                                                                                   ^

"mg.c", line 1842: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	     i = ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0));
  	                                                  ^

"mg.c", line 2770: warning #2191-D: type qualifier is meaningless on cast type
              (((S_ReANY((const REGEXP *)((REGEXP * const)rx)))->engine))->numbered_buff_STORE( ((REGEXP * const)rx),(paren),(sv));
                                           ^

"mg.c", line 2770: warning #2191-D: type qualifier is meaningless on cast type
              (((S_ReANY((const REGEXP *)((REGEXP * const)rx)))->engine))->numbered_buff_STORE( ((REGEXP * const)rx),(paren),(sv));
                                                                                                  ^

"mro_core.c", line 579: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	    if (!((revstash)->sv_flags & 0x00100000)) ((XPVMG*) (revstash)->sv_any)->xmg_stash = 0L;
  	                                               ^

"mro_core.c", line 707: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
                  if(!((isarev)->sv_u . svu_hash) || !((((XPVHV*) (isarev)->sv_any)->xhv_keys) - (((XPVMG*) (isarev)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)isarev) : 0)))
                                                                                                   ^

"mro_core.c", line 1113: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if(oldstash && ((((XPVHV*) (oldstash)->sv_any)->xhv_keys) - (((XPVMG*) (oldstash)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)oldstash) : 0))) {
                                                                    ^

"mro_core.c", line 1199: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (stash && ((((XPVHV*) (stash)->sv_any)->xhv_keys) - (((XPVMG*) (stash)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)stash) : 0))) {
                                                               ^

"hv.c", line 888: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          const U32 items = (U32)(((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0);
                                   ^

"hv.c", line 918: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      const MAGIC *mg = ((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic;
                         ^

"hv.c", line 965: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      Perl_sv_setuv( sv,((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get((const HV *)hv) : 0)));
                                                                 ^

"hv.c", line 1014: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          size_t nkeys = ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0));
                                                                  ^

"hv.c", line 1071: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (((((XPVHV*) ((HV *)hv)->sv_any)->xhv_keys) - (((XPVMG*) ((HV *)hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(HV *)hv) : 0))) {
                                                         ^

"hv.c", line 1870: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      const U32 items = (U32)(((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0);
                               ^

"hv.c", line 1909: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		    I32 placeholders = (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0);
  		                         ^

"hv.c", line 2783: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	? (((XPVHV*) (hv)->sv_any)->xhv_keys) : ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0))) {
  	                                                                                 ^

"hv.c", line 3865: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	const int nhashkeys = ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0));
  	                                                               ^

"hv.c", line 3866: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	const int nhashplaceholders = (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0);
  	                                ^

"hv.c", line 88: warning #4276-D: relational operator ">" always evaluates to 'false'
      (k = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2)))) ? (size_t)(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2)*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                 ^

"hv.c", line 90: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((hek)->hek_key)) != 0) ? (void)0 : __assert("((void*)((hek)->hek_key)) != 0", "hv.c", 90)), ((((void*)(str)) != 0) ? (void)0 : __assert("((void*)(str)) != 0", "hv.c", 90)), (void)memcpy((char*)((hek)->hek_key),(const char*)(str), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"hv.c", line 357: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((hv)->sv_flags & 0xff)) == (svtype)0xff)
                                            ^

"hv.c", line 588: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((xhv->xhv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((xhv->xhv_max+1) * sizeof(HE*)))))) ? (size_t)(((xhv->xhv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((xhv->xhv_max+1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                                                ^

"hv.c", line 812: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((xhv->xhv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((xhv->xhv_max+1) * sizeof(HE*)))))) ? (size_t)(((xhv->xhv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((xhv->xhv_max+1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                                            ^

"hv.c", line 1429: warning #4276-D: relational operator ">" always evaluates to 'false'
      (a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0))))) ? (size_t)(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(a),(size_t)((((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                       ^

"hv.c", line 1478: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((newsize -oldsize) * sizeof(HE*)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((newsize -oldsize) * sizeof(HE*))))) ? (size_t)((newsize -oldsize) * sizeof(HE*)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(&a[oldsize * sizeof(HE*)])) != 0) ? (void)0 : __assert("((void*)(&a[oldsize * sizeof(HE*)])) != 0", "hv.c", 1478)), (void)memset((char*)(&a[oldsize * sizeof(HE*)]),0,((newsize -oldsize) * sizeof(HE*)) * sizeof(char)));	 
                                                                                                                                                                                                                                                                         ^

"hv.c", line 1567: warning #4276-D: relational operator ">" always evaluates to 'false'
          (a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((newsize) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((newsize) * sizeof(HE*)))))) ? (size_t)(((newsize) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((newsize) * sizeof(HE*))),sizeof(char)))));
                                                                                                                                                                                                                                                             ^

"hv.c", line 1605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((hv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((hv_max+1) * sizeof(HE*)))))) ? (size_t)(((hv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((hv_max+1) * sizeof(HE*)))*sizeof(char))))));
  	                                                                                                                                                                                                                                                      ^

"hv.c", line 2238: warning #4276-D: relational operator ">" always evaluates to 'false'
              (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))))) ? (size_t)(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)),sizeof(char)))));
                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"hv.c", line 2242: warning #4276-D: relational operator ">" always evaluates to 'false'
              (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))))) ? (size_t)(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(array),(size_t)((((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"hv.c", line 3127: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(k = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2)))) ? (size_t)(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"hv.c", line 3133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((hek)->hek_key)) != 0) ? (void)0 : __assert("((void*)((hek)->hek_key)) != 0", "hv.c", 3133)), ((((void*)(str)) != 0) ? (void)0 : __assert("((void*)(str)) != 0", "hv.c", 3133)), (void)memcpy((char*)((hek)->hek_key),(const char*)(str), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"hv.c", line 3276: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((max + 1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((max + 1) * sizeof(HE*)))))) ? (size_t)(((max + 1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((max + 1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                       ^

"hv.c", line 3401: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (q = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(keylen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(keylen)))) ? (size_t)(keylen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((keylen)*sizeof(char))))));
  	                                                                                                                                                                                              ^

"hv.c", line 3577: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (q = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(keylen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(keylen)))) ? (size_t)(keylen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((keylen)*sizeof(char))))));
  	                                                                                                                                                                                              ^

"hv.c", line 3613: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(value_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(value_len + 1)))) ? (size_t)(value_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(he ->refcounted_he_data + 1)) != 0) ? (void)0 : __assert("((void*)(he->refcounted_he_data + 1)) != 0", "hv.c", 3613)), ((((void*)(value_p)) != 0) ? (void)0 : __assert("((void*)(value_p)) != 0", "hv.c", 3613)), (void)memcpy((char*)(he ->refcounted_he_data + 1),(const char*)(value_p), (value_len + 1) * sizeof(char)));
  	                                                                                                                                                                                                          ^

"av.c", line 363: warning #4232-D: conversion from "XPVAV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	const MAGIC *mg = ((XPVMG*) (av)->sv_any)->xmg_u . xmg_magic;
  	                   ^

"av.c", line 476: warning #4232-D: conversion from "XPVAV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	const MAGIC* const mg = ((XPVMG*) (av)->sv_any)->xmg_u . xmg_magic;
  	                         ^

"pp_hot.c", line 1812: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          i = ((((XPVHV*) (hv)->sv_any)->xhv_keys) - (((XPVMG*) (hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hv) : 0));
                                                       ^

"pp_hot.c", line 2579: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              if (((hash)->sv_flags & 0x00800000) || ((((XPVHV*) (hash)->sv_any)->xhv_keys) - (((XPVMG*) (hash)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)hash) : 0)))
                                                                                                ^

"pp_hot.c", line 2733: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              if (((lsv)->sv_flags & 0x00800000) || ((((XPVHV*) ((HV*)lsv)->sv_any)->xhv_keys) - (((XPVMG*) ((HV*)lsv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(HV*)lsv) : 0)))
                                                                                                   ^

"pp_hot.c", line 3088: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "pp_hot.c", 3088));  
      ^

"pp_hot.c", line 803: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(targ_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(targ_len)))) ? (size_t)(targ_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(targ_buf)) != 0) ? (void)0 : __assert("((void*)(targ_buf)) != 0", "pp_hot.c", 803)), ((((void*)(targ_pv)) != 0) ? (void)0 : __assert("((void*)(targ_pv)) != 0", "pp_hot.c", 803)), (void)memmove((char*)(targ_buf),(const char*)(targ_pv), (targ_len) * sizeof(char)));
                                                                                                                                                                                                             ^

"pp_hot.c", line 854: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(targ_pv)) != 0) ? (void)0 : __assert("((void*)(targ_pv)) != 0", "pp_hot.c", 854)), ((((void*)(svpv_p->pv)) != 0) ? (void)0 : __assert("((void*)(svpv_p->pv)) != 0", "pp_hot.c", 854)), (void)memcpy((char*)(targ_pv),(const char*)(svpv_p->pv), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"pp_hot.c", line 870: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(targ_pv)) != 0) ? (void)0 : __assert("((void*)(targ_pv)) != 0", "pp_hot.c", 870)), ((((void*)(const_pv)) != 0) ? (void)0 : __assert("((void*)(const_pv)) != 0", "pp_hot.c", 870)), (void)memcpy((char*)(targ_pv),(const char*)(const_pv), (len) * sizeof(char)));
                                                                                                                                                                                              ^

"pp_hot.c", line 882: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(targ_pv)) != 0) ? (void)0 : __assert("((void*)(targ_pv)) != 0", "pp_hot.c", 882)), ((((void*)(svpv_p->pv)) != 0) ? (void)0 : __assert("((void*)(svpv_p->pv)) != 0", "pp_hot.c", 882)), (void)memcpy((char*)(targ_pv),(const char*)(svpv_p->pv), (len) * sizeof(char)));
                                                                                                                                                                                              ^

"pp_hot.c", line 3297: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((PL_valid_types_PVX[((svtype)((sv)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]", "pp_hot.c", 3297)); ((!((((sv)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((sv)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((sv)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(sv)", "pp_hot.c", 3297)); ((!(((svtype)((sv)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (sv)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(sv) == SVt_PVIO && !(IoFLAGS(sv) & IOf_FAKE_DIRP))", "pp_hot.c", 3297)); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((PL_valid_types_PVX[((svtype)(((sv))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((sv)) & SVt_MASK]", "pp_hot.c", 3297)); ((!(((((sv))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((sv))", "pp_hot.c", 3297)); ((!(((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((sv))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((sv)) == SVt_PVIO && !(IoFLAGS((sv)) & IOf_FAKE_DIRP))", "pp_hot.c", 3297)); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^

"pp_hot.c", line 3306: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    do { do { ((PL_valid_types_PVX[((svtype)((sv)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]", "pp_hot.c", 3306)); ((!((((sv)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((sv)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((sv)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(sv)", "pp_hot.c", 3306)); ((!(((svtype)((sv)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (sv)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(sv) == SVt_PVIO && !(IoFLAGS(sv) & IOf_FAKE_DIRP))", "pp_hot.c", 3306)); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (new_len)); } while (0); do { ((PL_valid_types_PVX[((svtype)(((sv))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((sv)) & SVt_MASK]", "pp_hot.c", 3306)); ((!(((((sv))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((sv))", "pp_hot.c", 3306)); ((!(((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((sv))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((sv)) == SVt_PVIO && !(IoFLAGS((sv)) & IOf_FAKE_DIRP))", "pp_hot.c", 3306)); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_len)))) ? (size_t)(new_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((new_len)))))); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^

"pp_hot.c", line 4301: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(m)) != 0) ? (void)0 : __assert("((void*)(m)) != 0", "pp_hot.c", 4301)), ((((void*)(c)) != 0) ? (void)0 : __assert("((void*)(c)) != 0", "pp_hot.c", 4301)), (void)memcpy((char*)(m),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4306: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(m)) != 0) ? (void)0 : __assert("((void*)(m)) != 0", "pp_hot.c", 4306)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp_hot.c", 4306)), (void)memmove((char*)(m),(const char*)(d), (i) * sizeof(char)));
  		                                                                                                                                                                          ^

"pp_hot.c", line 4316: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d - i)) != 0) ? (void)0 : __assert("((void*)(d - i)) != 0", "pp_hot.c", 4316)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "pp_hot.c", 4316)), (void)memmove((char*)(d - i),(const char*)(s), (i) * sizeof(char)));
                                                                                                                                                                                            ^

"pp_hot.c", line 4319: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp_hot.c", 4319)), ((((void*)(c)) != 0) ? (void)0 : __assert("((void*)(c)) != 0", "pp_hot.c", 4319)), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4337: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp_hot.c", 4337)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "pp_hot.c", 4337)), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(char)));
  			                                                                                                                                                                      ^

"pp_hot.c", line 4341: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp_hot.c", 4341)), ((((void*)(c)) != 0) ? (void)0 : __assert("((void*)(c)) != 0", "pp_hot.c", 4341)), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4352: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i+1)))) ? (size_t)(i+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp_hot.c", 4352)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "pp_hot.c", 4352)), (void)memmove((char*)(d),(const char*)(s), (i+1) * sizeof(char)));		 
  		                                                                                                                                                                            ^

"sv.c", line 1459: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	    do { ((((svtype)((io)->sv_flags & 0xff)) >= SVt_PVMG) ? (void)0 : __assert("SvTYPE(io) >= SVt_PVMG", "sv.c", 1459)); (((XPVMG*) (io)->sv_any)->xmg_stash = (((HV *)((void *) (S_SvREFCNT_inc(((SV *)((void *) ((((0+(iogv)->sv_u . svu_gp))->gp_hv)))))))))); } while (0);
  	                                                                                                                           ^

"sv.c", line 16330: warning #2111-D: statement is unreachable
  	((0) ? (void)0 : __assert("0", "sv.c", 16330));  
  	^

"sv.c", line 16433: warning #2111-D: statement is unreachable
  	((0) ? (void)0 : __assert("0", "sv.c", 16433));  
  	^

"sv.c", line 16640: warning #2111-D: statement is unreachable
  	((0) ? (void)0 : __assert("0", "sv.c", 16640));  
  	^

"sv.c", line 472: warning #4275-D: constant out of range ([0 - 16]) for the operator
  	    if (((svtype)((sv)->sv_flags & 0xff)) != (svtype)0xff
  	                                          ^

"sv.c", line 491: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((sv)->sv_flags & 0xff)) != (svtype)0xff) {
                                            ^

"sv.c", line 1108: warning #4276-D: relational operator ">" always evaluates to 'false'
      (adesc->arena = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(good_arena_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(good_arena_size)))) ? (size_t)(good_arena_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((good_arena_size)*sizeof(char))))));
                                                                                                                                                                                                                                      ^

"sv.c", line 1343: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_type_details->body_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_type_details->body_size)))) ? (size_t)(new_type_details->body_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(new_body)) != 0) ? (void)0 : __assert("((void*)(new_body)) != 0", "sv.c", 1343)), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                    ^

"sv.c", line 1413: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_type_details->body_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_type_details->body_size)))) ? (size_t)(new_type_details->body_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(new_body)) != 0) ? (void)0 : __assert("((void*)(new_body)) != 0", "sv.c", 1413)), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                        ^

"sv.c", line 1434: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(length)))) ? (size_t)(length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)((char *)new_body + offset)) != 0) ? (void)0 : __assert("((void*)((char *)new_body + offset)) != 0", "sv.c", 1435)), ((((void*)((char *)old_body + offset)) != 0) ? (void)0 : __assert("((void*)((char *)old_body + offset)) != 0", "sv.c", 1435)), (void)memcpy((char*)((char *)new_body + offset),(const char*)((char *)old_body + offset), (length) * sizeof(char)));
  	                                                                                                                                                                                         ^

"sv.c", line 1519: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_cur+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_cur+1)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_cur+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((sv)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((sv)->sv_u.svu_pv))) != 0", "sv.c", 1519)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 1519)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (((XPV*) (sv)->sv_any)->xpv_cur+1) * sizeof(char)));
                                                                                                                                                                                                                                                                         ^

"sv.c", line 1602: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_cur)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 1602)), ((((void*)(((const char*)(0 + (sv)->sv_u . svu_pv)))) != 0) ? (void)0 : __assert("((void*)(((const char*)(0 + (sv)->sv_u.svu_pv)))) != 0", "sv.c", 1602)), (void)memmove((char*)(s),(const char*)(((const char*)(0 + (sv)->sv_u . svu_pv))), (((XPV*) (sv)->sv_any)->xpv_cur) * sizeof(char)));
                                                                                                                                                                                                                                                                               ^

"sv.c", line 3039: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(buffer = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
  		                                                                                                                                                                                      ^

"sv.c", line 3097: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 3097)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 3097)), (void)memmove((char*)(s),(const char*)(ptr), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 4386: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((dstr)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((dstr)->sv_u.svu_pv))) != 0", "sv.c", 4386)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 4386)), (void)memcpy((char*)(((dstr)->sv_u . svu_pv)),(const char*)(ptr), (len + 1) * sizeof(char)));
                                                                                                                                                                                                      ^

"sv.c", line 4641: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cur)))) ? (size_t)(cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((dstr)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((dstr)->sv_u.svu_pv))) != 0", "sv.c", 4641)), ((((void*)(((const char*)(0 + (sstr)->sv_u . svu_pv)))) != 0) ? (void)0 : __assert("((void*)(((const char*)(0 + (sstr)->sv_u.svu_pv)))) != 0", "sv.c", 4641)), (void)memmove((char*)(((dstr)->sv_u . svu_pv)),(const char*)(((const char*)(0 + (sstr)->sv_u . svu_pv))), (cur) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 4905: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(dptr)) != 0) ? (void)0 : __assert("((void*)(dptr)) != 0", "sv.c", 4905)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 4905)), (void)memmove((char*)(dptr),(const char*)(ptr), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 4956: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((sv)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((sv)->sv_u.svu_pv))) != 0", "sv.c", 4956)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 4956)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 5087: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(new_ptr)) != 0) ? (void)0 : __assert("((void*)(new_ptr)) != 0", "sv.c", 5087)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 5087)), (void)memcpy((char*)(new_ptr),(const char*)(ptr), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 5088: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (void)memset((char*)(ptr), (U8)(0xEF), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 5161: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cur)))) ? (size_t)(cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((sv)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((sv)->sv_u.svu_pv))) != 0", "sv.c", 5161)), ((((void*)(pvx)) != 0) ? (void)0 : __assert("((void*)(pvx)) != 0", "sv.c", 5161)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (cur) * sizeof(char)));
                                                                                                                                                                                              ^

"sv.c", line 5345: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((sv)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((sv)->sv_u.svu_pv))) != 0", "sv.c", 5345)), ((((void*)(pvx)) != 0) ? (void)0 : __assert("((void*)(pvx)) != 0", "sv.c", 5345)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 5440: warning #4276-D: relational operator ">" always evaluates to 'false'
        ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(slen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(slen)))) ? (size_t)(slen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((dsv)->sv_u . svu_pv) + dlen)) != 0) ? (void)0 : __assert("((void*)(((dsv)->sv_u.svu_pv) + dlen)) != 0", "sv.c", 5440)), ((((void*)(sstr)) != 0) ? (void)0 : __assert("((void*)(sstr)) != 0", "sv.c", 5440)), (void)memmove((char*)(((dsv)->sv_u . svu_pv) + dlen),(const char*)(sstr), (slen) * sizeof(char)));
                                                                                                                                                                                       ^

"sv.c", line 5532: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((sv)->sv_u . svu_pv)+tlen)) != 0) ? (void)0 : __assert("((void*)(((sv)->sv_u.svu_pv)+tlen)) != 0", "sv.c", 5532)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 5532)), (void)memmove((char*)(((sv)->sv_u . svu_pv)+tlen),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 6311: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(offset+len-curlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(offset+len-curlen)))) ? (size_t)(offset+len-curlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((bigstr)->sv_u . svu_pv)+curlen)) != 0) ? (void)0 : __assert("((void*)(((bigstr)->sv_u.svu_pv)+curlen)) != 0", "sv.c", 6311)), (void)memset((char*)(((bigstr)->sv_u . svu_pv)+curlen),0,(offset+len-curlen) * sizeof(char)));
  	                                                                                                                                                                                                                      ^

"sv.c", line 6325: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(big+offset)) != 0) ? (void)0 : __assert("((void*)(big+offset)) != 0", "sv.c", 6325)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6325)), (void)memmove((char*)(big+offset),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 6331: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((bigstr)->sv_u . svu_pv)+offset)) != 0) ? (void)0 : __assert("((void*)(((bigstr)->sv_u.svu_pv)+offset)) != 0", "sv.c", 6331)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6331)), (void)memmove((char*)(((bigstr)->sv_u . svu_pv)+offset),(const char*)(little), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 6347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(mid)) != 0) ? (void)0 : __assert("((void*)(mid)) != 0", "sv.c", 6347)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6347)), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6352: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(mid)) != 0) ? (void)0 : __assert("((void*)(mid)) != 0", "sv.c", 6352)), ((((void*)(midend)) != 0) ? (void)0 : __assert("((void*)(midend)) != 0", "sv.c", 6352)), (void)memmove((char*)(mid),(const char*)(midend), (i) * sizeof(char)));
  	                                                                                                                                                                          ^

"sv.c", line 6361: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(midend - i)) != 0) ? (void)0 : __assert("((void*)(midend - i)) != 0", "sv.c", 6361)), ((((void*)(big)) != 0) ? (void)0 : __assert("((void*)(big)) != 0", "sv.c", 6361)), (void)memmove((char*)(midend - i),(const char*)(big), (i) * sizeof(char)));
  	                                                                                                                                                                      ^

"sv.c", line 6364: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(mid)) != 0) ? (void)0 : __assert("((void*)(mid)) != 0", "sv.c", 6364)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6364)), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6369: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(midend)) != 0) ? (void)0 : __assert("((void*)(midend)) != 0", "sv.c", 6369)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6369)), (void)memmove((char*)(midend),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 6512: warning #4275-D: constant out of range ([0 - 16]) for the operator
  	((((svtype)((sv)->sv_flags & 0xff)) != (svtype)0xff) ? (void)0 : __assert("SvTYPE(sv) != (svtype)SVTYPEMASK", "sv.c", 6512));
  	                                    ^

"sv.c", line 8645: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(got) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(got)))) ? (size_t)(got) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(bp)) != 0) ? (void)0 : __assert("((void*)(bp)) != 0", "sv.c", 8645)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 8645)), (void)memcpy((char*)(bp),(const char*)(ptr), (got) * sizeof(unsigned char)));
                                                                                                                                                                                                                    ^

"sv.c", line 8651: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cnt) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cnt)))) ? (size_t)(cnt) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(bp)) != 0) ? (void)0 : __assert("((void*)(bp)) != 0", "sv.c", 8651)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 8651)), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(unsigned char)));
                                                                                                                                                                                                                ^

"sv.c", line 8658: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cnt) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cnt)))) ? (size_t)(cnt) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(bp)) != 0) ? (void)0 : __assert("((void*)(bp)) != 0", "sv.c", 8658)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 8658)), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(char)));	      
  	                                                                                                                                                                                    ^

"sv.c", line 9708: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((old)->sv_flags & 0xff)) == (svtype)0xff) {
                                             ^

"sv.c", line 10042: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((sv)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((sv)->sv_u.svu_pv))) != 0", "sv.c", 10042)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 10042)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 10934: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(end)) != 0) ? (void)0 : __assert("((void*)(end)) != 0", "sv.c", 10934)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "sv.c", 10934)), (void)memcpy((char*)(end),(const char*)(buf), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 11676: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vn - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vn - 1)))) ? (size_t)(vn - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(v0 + 1)) != 0) ? (void)0 : __assert("((void*)(v0 + 1)) != 0", "sv.c", 11676)), ((((void*)(v0)) != 0) ? (void)0 : __assert("((void*)(v0)) != 0", "sv.c", 11676)), (void)memmove((char*)(v0 + 1),(const char*)(v0), (vn - 1) * sizeof(char)));
                                                                                                                                                                                                               ^

"sv.c", line 11719: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "sv.c", 11719)), ((((void*)(r)) != 0) ? (void)0 : __assert("((void*)(r)) != 0", "sv.c", 11719)), (void)memcpy((char*)(p),(const char*)(r), (n) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 11768: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nmove) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nmove)))) ? (size_t)(nmove) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(zerox + nzero)) != 0) ? (void)0 : __assert("((void*)(zerox + nzero)) != 0", "sv.c", 11768)), ((((void*)(zerox)) != 0) ? (void)0 : __assert("((void*)(zerox)) != 0", "sv.c", 11768)), (void)memmove((char*)(zerox + nzero),(const char*)(zerox), (nmove) * sizeof(char)));
                                                                                                                                                                                                ^

"sv.c", line 11773: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buf + gap)) != 0) ? (void)0 : __assert("((void*)(buf + gap)) != 0", "sv.c", 11774)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "sv.c", 11774)), (void)memmove((char*)(buf + gap),(const char*)(buf), (elen) * sizeof(char)));
                                                                                                                                                                                             ^

"sv.c", line 13031: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(PL_efloatbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_efloatsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_efloatsize)))) ? (size_t)(PL_efloatsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((PL_efloatsize)*sizeof(char))))));
  		                                                                                                                                                                                                                          ^

"sv.c", line 13273: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 13273)), ((((void*)(eptr)) != 0) ? (void)0 : __assert("((void*)(eptr)) != 0", "sv.c", 13273)), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 13294: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 13294)), ((((void*)(eptr)) != 0) ? (void)0 : __assert("((void*)(eptr)) != 0", "sv.c", 13294)), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 15962: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(((sv)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((sv)->sv_u.svu_pv))) != 0", "sv.c", 15962)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 15962)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len + 1) * sizeof(char)));
  	                                                                                                                                                                                            ^

"pp.c", line 2177: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "pp.c", 2177));  
  	    ^

"pp.c", line 6745: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          if (((targ)->sv_flags & 0x00800000) || ((((XPVHV*) ((HV*)targ)->sv_any)->xhv_keys) - (((XPVMG*) ((HV*)targ)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(HV*)targ) : 0))) {
                                                                                                 ^

"pp.c", line 3903: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tculen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tculen)))) ? (size_t)(tculen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 3903)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 3903)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  	                                                                                                                                                                                     ^

"pp.c", line 3916: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tculen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tculen)))) ? (size_t)(tculen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 3916)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 3916)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  		                                                                                                                                                                                 ^

"pp.c", line 3933: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(slen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(slen)))) ? (size_t)(slen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d + 1)) != 0) ? (void)0 : __assert("((void*)(d + 1)) != 0", "pp.c", 3933)), ((((void*)(s + 1)) != 0) ? (void)0 : __assert("((void*)(s + 1)) != 0", "pp.c", 3933)), (void)memcpy((char*)(d + 1),(const char*)(s + 1), (slen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4037: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(capital_iota_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(capital_iota_len)))) ? (size_t)(capital_iota_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 4037)), ((((void*)("\xCE\x99")) != 0) ? (void)0 : __assert("((void*)(\"\\xCE\\x99\")) != 0", "pp.c", 4037)), (void)memcpy((char*)(d),(const char*)("\xCE\x99"), (capital_iota_len) * sizeof(U8)));
  		                                                                                                                                                                                                               ^

"pp.c", line 4071: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 4071)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4071)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                             ^

"pp.c", line 4077: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(capital_iota_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(capital_iota_len)))) ? (size_t)(capital_iota_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 4077)), ((((void*)("\xCE\x99")) != 0) ? (void)0 : __assert("((void*)(\"\\xCE\\x99\")) != 0", "pp.c", 4077)), (void)memcpy((char*)(d),(const char*)("\xCE\x99"), (capital_iota_len) * sizeof(U8)));
                                                                                                                                                                                                                             ^

"pp.c", line 4295: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 4295)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4295)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4495: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 4495)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4495)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                         ^

"pp.c", line 4542: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(small_mu_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(small_mu_len)))) ? (size_t)(small_mu_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 4542)), ((((void*)("\xCE\xBC")) != 0) ? (void)0 : __assert("((void*)(\"\\xCE\\xBC\")) != 0", "pp.c", 4542)), (void)memcpy((char*)(d),(const char*)("\xCE\xBC"), (small_mu_len) * sizeof(U8)));
                                                                                                                                                                                                                         ^

"pp.c", line 4559: warning #4276-D: relational operator ">" always evaluates to 'false'
                              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp.c", 4559)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4559)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                                         ^

"scope.c", line 385: warning #4232-D: conversion from "XPVAV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (__builtin_expect(((((XPVMG*) (oav)->sv_any)->xmg_u . xmg_magic) ? (_Bool)1 : (_Bool)0),(0)))
                              ^

"scope.c", line 403: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      if (__builtin_expect(((((XPVMG*) (ohv)->sv_any)->xmg_u . xmg_magic) ? (_Bool)1 : (_Bool)0),(0)))
                              ^

"pp_ctl.c", line 290: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "pp_ctl.c", 290));  
  	    ^

"pp_ctl.c", line 4914: warning #4232-D: conversion from "XPVHV *const" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		else if(((((XPVHV*) ((const HV *) hv)->sv_any)->xhv_keys) - (((XPVMG*) ((const HV *) hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(const HV *) hv) : 0)) != ((((XPVHV*) (other_hv)->sv_any)->xhv_keys) - (((XPVMG*) (other_hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)other_hv) : 0)))
  		                                                              ^

"pp_ctl.c", line 4914: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		else if(((((XPVHV*) ((const HV *) hv)->sv_any)->xhv_keys) - (((XPVMG*) ((const HV *) hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)(const HV *) hv) : 0)) != ((((XPVHV*) (other_hv)->sv_any)->xhv_keys) - (((XPVMG*) (other_hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)other_hv) : 0)))
  		                                                                                                                                                                                                                                      ^

"pp_ctl.c", line 4939: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		other_key_count = ((((XPVHV*) (other_hv)->sv_any)->xhv_keys) - (((XPVMG*) (other_hv)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)other_hv) : 0));
  		                                                                 ^

"pp_ctl.c", line 800: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(to_copy) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(to_copy)))) ? (size_t)(to_copy) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(t)) != 0) ? (void)0 : __assert("((void*)(t)) != 0", "pp_ctl.c", 800)), ((((void*)(source)) != 0) ? (void)0 : __assert("((void*)(source)) != 0", "pp_ctl.c", 800)), (void)memcpy((char*)(t),(const char*)(source), (to_copy) * sizeof(char)));
  		                                                                                                                                                                                        ^

"pp_ctl.c", line 3479: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (((oldcurcop->cop_warnings) == 0L || (oldcurcop->cop_warnings) == (((STRLEN*)0)+1) || (oldcurcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(oldcurcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings)))) ? (size_t)(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(malloc((sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings)))) != 0) ? (void)0 : __assert("((void*)(malloc((sizeof(*oldcurcop->cop_warnings)+*oldcurcop->cop_warnings)))) != 0", "pp_ctl.c", 3479)), ((((void*)(oldcurcop->cop_warnings)) != 0) ? (void)0 : __assert("((void*)(oldcurcop->cop_warnings)) != 0", "pp_ctl.c", 3479)), memcpy((char*)(malloc((sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings))),(const char*)(oldcurcop->cop_warnings), (sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"pp_sys.c", line 2997: warning #2186-D: pointless comparison of unsigned integer with zero
  	    neg = PL_statcache.st_ino < 0;
  	                              ^

"pp_sys.c", line 325: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((PL_valid_types_PVX[((svtype)((sv)->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]", "pp_sys.c", 325)); ((!((((sv)->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)((sv)->sv_flags & 0xff)) == SVt_PVGV || ((svtype)((sv)->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP(sv)", "pp_sys.c", 325)); ((!(((svtype)((sv)->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) (sv)->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE(sv) == SVt_PVIO && !(IoFLAGS(sv) & IOf_FAKE_DIRP))", "pp_sys.c", 325)); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((PL_valid_types_PVX[((svtype)(((sv))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((sv)) & SVt_MASK]", "pp_sys.c", 325)); ((!(((((sv))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((sv))", "pp_sys.c", 325)); ((!(((svtype)(((sv))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((sv))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((sv)) == SVt_PVIO && !(IoFLAGS((sv)) & IOf_FAKE_DIRP))", "pp_sys.c", 325)); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"pp_sys.c", line 1237: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(fd_sets[i] = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(growsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(growsize)))) ? (size_t)(growsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((growsize)*sizeof(char))))));
  	                                                                                                                                                                                                         ^

"pp_sys.c", line 1825: warning #4276-D: relational operator ">" always evaluates to 'false'
      	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(offset-orig_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(offset-orig_size)))) ? (size_t)(offset-orig_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buffer+orig_size)) != 0) ? (void)0 : __assert("((void*)(buffer+orig_size)) != 0", "pp_sys.c", 1825)), (void)memset((char*)(buffer+orig_size),0,(offset-orig_size) * sizeof(char)));
      	                                                                                                                                                                                                                   ^

"doop.c", line 1299: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  		i = ((((XPVHV*) (keys)->sv_any)->xhv_keys) - (((XPVMG*) (keys)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)keys) : 0));
  		                                               ^

"doop.c", line 71: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len*2+1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len*2+1)))) ? (size_t)(len*2+1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len*2+1)*sizeof(U8))))));
  	                                                                                                                                                                                             ^

"doop.c", line 87: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "doop.c", 87)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "doop.c", 87)), (void)memmove((char*)(d),(const char*)(s), (ulen) * sizeof(U8)));
  		                                                                                                                                                                           ^

"doop.c", line 223: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len*2+1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len*2+1)))) ? (size_t)(len*2+1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len*2+1)*sizeof(U8))))));
  	                                                                                                                                                                                             ^

"doop.c", line 249: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "doop.c", 249)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "doop.c", 249)), (void)memmove((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                          ^

"doop.c", line 328: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len * 3 + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len * 3 + 13)))) ? (size_t)(len * 3 + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len * 3 + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 346: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "doop.c", 346)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "doop.c", 346)), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  	                                                                                                                                                                      ^

"doop.c", line 363: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 491: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len * 3 + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len * 3 + 13)))) ? (size_t)(len * 3 + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len * 3 + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 510: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  		                                                                                                                                                                                                    ^

"doop.c", line 525: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "doop.c", 525)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "doop.c", 525)), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  		                                                                                                                                                                  ^

"doop.c", line 544: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "doop.c", 544)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "doop.c", 544)), (void)memmove((char*)(d),(const char*)(s), (len) * sizeof(U8)));
  			                                                                                                                                                                        ^

"doop.c", line 564: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  		                                                                                                                                                                                                    ^

"doop.c", line 576: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "doop.c", 576)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "doop.c", 576)), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  		                                                                                                                                                                  ^

"doop.c", line 1135: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(dc = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(needlen + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(needlen + 1)))) ? (size_t)(needlen + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((needlen + 1),sizeof(char)))));
  	                                                                                                                                                                                                          ^

"doio.c", line 2299: warning #4276-D: relational operator ">" always evaluates to 'false'
      (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cmdlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cmdlen)))) ? (size_t)(cmdlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((cmdlen)*sizeof(char))))));
                                                                                                                                                                                                  ^

"doio.c", line 3177: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(msize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(msize)))) ? (size_t)(msize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(mbuf)) != 0) ? (void)0 : __assert("((void*)(mbuf)) != 0", "doio.c", 3177)), ((((void*)(shm + mpos)) != 0) ? (void)0 : __assert("((void*)(shm + mpos)) != 0", "doio.c", 3177)), (void)memcpy((char*)(mbuf),(const char*)(shm + mpos), (msize) * sizeof(char)));
  	                                                                                                                                                                                  ^

"doio.c", line 3189: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(shm + mpos)) != 0) ? (void)0 : __assert("((void*)(shm + mpos)) != 0", "doio.c", 3189)), ((((void*)(mbuf)) != 0) ? (void)0 : __assert("((void*)(mbuf)) != 0", "doio.c", 3189)), (void)memcpy((char*)(shm + mpos),(const char*)(mbuf), (n) * sizeof(char)));
  	                                                                                                                                                                      ^

"regexec.c", line 505: warning #2111-D: statement is unreachable
      return (0);  
      ^

"regexec.c", line 2227: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              do { while (s < strend) { if ((((( (U8*) ((regnode_charclass*)(c))->bitmap) [ ( ( (UV) (*((U8*)s))) >> 3) ] ) & (1U << ((*((U8*)s)) & 7))) ? (_Bool)1 : (_Bool)0)) { if ( ( doevery || s != previous_occurrence_end) && (reginfo->intuit || S_regtry( reginfo,&s))) { goto got_it; } s += ((0) ? PL_utf8skip[*(const U8*)(s)] : 1); previous_occurrence_end = s; } else { s += ((0) ? PL_utf8skip[*(const U8*)(s)] : 1); } } } while (0);
                                                        ^

"regexec.c", line 2233: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          while (s < strend) { s = ((char *) S_find_next_masked((U8 *) s, (U8 *) strend, (U8) ((((struct regnode_1 *)c)->arg1)), ((c)->flags))); if (s >= strend) { break; } if ( ( doevery || s != previous_occurrence_end) && (reginfo->intuit || S_regtry( reginfo,&s))) { goto got_it; } s += (0) ? PL_utf8skip[*(const U8*)(s)] : 1; previous_occurrence_end = s; };
                                                                                                 ^

"regexec.c", line 2872: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_ac_data *aho = (reg_ac_data*)progi->data->data[ ((((struct regnode_1 *)c)->arg1)) ];
                                                                     ^

"regexec.c", line 2910: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                      bitmap=(U8*)((regnode_charclass*)(c))->bitmap;
                                   ^

"regexec.c", line 4356: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      SV *sv_dat= ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                         ^

"regexec.c", line 5835: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 5835));  
  	    ^

"regexec.c", line 5841: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 5841));  
  	    ^

"regexec.c", line 5877: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              if(!(nextchr < 0) && !(((( (U8*) ((regnode_charclass*)(scan))->bitmap) [ ( ( (UV) (nextchr)) >> 3) ] ) & (1U << ((nextchr) & 7))) ? (_Bool)1 : (_Bool)0)) {
                                                ^

"regexec.c", line 5883: warning #2111-D: statement is unreachable
                  ((0) ? (void)0 : __assert("0", "regexec.c", 5883));  
                  ^

"regexec.c", line 5937: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          	    = (reg_trie_data*)rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ];
          	                                           ^

"regexec.c", line 5938: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		HV * widecharmap = ((HV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) + 1 ])));
  		                                                          ^

"regexec.c", line 6083: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 6083));  
  	    ^

"regexec.c", line 6113: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = ((reg_trie_data*)rexi->data->data[((((struct regnode_1 *)st->u . trie . me)->arg1))])->wordinfo;
  		                                           ^

"regexec.c", line 6137: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = (reg_trie_data*)rexi->data->data[((((struct regnode_1 *)st->u . trie . me)->arg1))];
  		                                          ^

"regexec.c", line 6200: warning #2111-D: statement is unreachable
  		((0) ? (void)0 : __assert("0", "regexec.c", 6200));  
  		^

"regexec.c", line 6203: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    do { if (__builtin_expect(((PL_debug & 0x00000200) ? (_Bool)1 : (_Bool)0),(0))) do {if (re_debug_flags & 0x00FF00) { AV *const trie_words = ((AV *)((void *) (rexi->data->data[((((struct regnode_1 *)st->u . trie . me)->arg1))+2]))); SV * * const tmp = trie_words ? Perl_av_fetch(trie_words,st->u . trie . nextword - 1,0) : 0L; SV *sv= tmp ? Perl_sv_newmortal() : 0L; Perl_re_exec_indentf( "%sTRIE: only one match left, short-circuiting: #%d <%s>%s\n", depth, PL_colors[4], st->u . trie . nextword, tmp ? Perl_pv_pretty(sv,((((*tmp)->sv_flags & (0x00000400|0x00200000)) == 0x00000400) ? ((const char*)(0 + (*tmp)->sv_u . svu_pv)) : Perl_sv_2pv_flags(*tmp,0,2|32)),((XPV*) (*tmp)->sv_any)->xpv_cur,0,PL_colors[0],PL_colors[1],(((*tmp)->sv_flags & 0x20000000) ? 0x000100 : 0)|0x000400) : "not compiled under -Dr", PL_colors[5] ); };} while (0); } while (0);
  	                                                                                                                                                                                      ^

"regexec.c", line 6702: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (!(((scan)->flags) ? S_reginclass( rex,scan,(U8*)locinput,(U8*)locinput+1,utf8_target) : (((( (U8*) ((regnode_charclass*)(scan))->bitmap) [ ( ( (UV) (*((U8*)locinput))) >> 3) ] ) & (1U << ((*((U8*)locinput)) & 7))) ? (_Bool)1 : (_Bool)0)))
  		                                                                                                        ^

"regexec.c", line 6709: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if ((nextchr < 0) || (((int)*(const U8*)(locinput)) & ((scan)->flags)) != ((((struct regnode_1 *)scan)->arg1))) {
                                                                                           ^

"regexec.c", line 7041: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7108: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              arg= (U32)((((struct regnode_1 *)scan)->arg1));
                           ^

"regexec.c", line 7120: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              startpoint = scan + ((((struct regnode_2L *)scan)->arg2));
                                     ^

"regexec.c", line 7181: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		n = ((((struct regnode_1 *)scan)->arg1));
  		       ^

"regexec.c", line 7417: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                                      ((((struct regnode_2L *)scan)->arg2)),
                                         ^

"regexec.c", line 7484: warning #2111-D: statement is unreachable
  		((0) ? (void)0 : __assert("0", "regexec.c", 7484));  
  		^

"regexec.c", line 7567: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7602: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7624: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_yes_mark = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                                       ^

"regexec.c", line 7625: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              if (((((struct regnode_2L *)scan)->arg2))){
                     ^

"regexec.c", line 7632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          n = ((((struct regnode_1 *)cursor)->arg1));
                                 ^

"regexec.c", line 7638: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              if ( n == ((((struct regnode_1 *)scan)->arg1)) || ( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (n) + 1 ) ) ) )
                                           ^

"regexec.c", line 7648: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7658: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              n = ((((struct regnode_1 *)scan)->arg1));
                     ^

"regexec.c", line 7673: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next = scan + ((((struct regnode_1 *)scan)->arg1));
  		                 ^

"regexec.c", line 7775: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next += ((((struct regnode_1 *)next)->arg1));
  		           ^

"regexec.c", line 7797: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 7797));  
  	    ^

"regexec.c", line 7803: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 7803));  
  	    ^

"regexec.c", line 7809: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 7809));  
  	    ^

"regexec.c", line 7845: warning #2111-D: statement is unreachable
  		((0) ? (void)0 : __assert("0", "regexec.c", 7845));  
  		^

"regexec.c", line 7953: warning #2111-D: statement is unreachable
  		((0) ? (void)0 : __assert("0", "regexec.c", 7953));  
  		^

"regexec.c", line 7964: warning #2111-D: statement is unreachable
  		((0) ? (void)0 : __assert("0", "regexec.c", 7964));  
  		^

"regexec.c", line 7968: warning #2111-D: statement is unreachable
  	((0) ? (void)0 : __assert("0", "regexec.c", 7968));  
  	^

"regexec.c", line 7974: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 7974));  
  	    ^

"regexec.c", line 7981: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 7981));  
  	    ^

"regexec.c", line 7991: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 7991));  
  	    ^

"regexec.c", line 8016: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8016));  
  	    ^

"regexec.c", line 8047: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8047));  
  	    ^

"regexec.c", line 8053: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ((((struct regnode_1 *)scan)->arg1));
  	                     ^

"regexec.c", line 8072: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8072));  
  	    ^

"regexec.c", line 8076: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  ? ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])))
                                                           ^

"regexec.c", line 8079: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8079));  
              ^

"regexec.c", line 8087: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8087));  
              ^

"regexec.c", line 8091: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8091));  
              ^

"regexec.c", line 8156: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8156));  
  	    ^

"regexec.c", line 8204: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		if (( (PL_regkind[((st->u . curlym . B)->type)] == 34) || PL_regkind[((st->u . curlym . B)->type)] == 56 ) || ( ((st->u . curlym . B)->type) == 52 || (((st->u . curlym . B)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)st->u . curlym . B)->arg1))) + 1 ) ) ) ) || ((st->u . curlym . B)->type) == 73 || ((st->u . curlym . B)->type) == 70 || ((st->u . curlym . B)->type) == 68 || ((st->u . curlym . B)->type) == 46 || ((st->u . curlym . B)->type) == 74 || ((st->u . curlym . B)->type) == 94 || (PL_regkind[((st->u . curlym . B)->type)] == 47 && ((((struct regnode_2 *)st->u . curlym . B)->arg1)) > 0) )) {
  		                                                                                                                                                                                                                                                                                                                    ^

"regexec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  			                                                                                                                                                                                                ^

"regexec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  			                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^

"regexec.c", line 8285: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8285));  
  	    ^

"regexec.c", line 8368: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (! ( (PL_regkind[((next)->type)] == 34) || PL_regkind[((next)->type)] == 56 ) && ! ( ((next)->type) == 52 || (((next)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)next)->arg1))) + 1 ) ) ) ) || ((next)->type) == 73 || ((next)->type) == 70 || ((next)->type) == 68 || ((next)->type) == 46 || ((next)->type) == 74 || ((next)->type) == 94 || (PL_regkind[((next)->type)] == 47 && ((((struct regnode_2 *)next)->arg1)) > 0) )) {
                                                                                                                                                                                                                                                                              ^

"regexec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  		                                                                                                                                                                                                    ^

"regexec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 52 || (((text_node)->type) == 53 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 73 || ((text_node)->type) == 70 || ((text_node)->type) == 68 || ((text_node)->type) == 46 || ((text_node)->type) == 74 || ((text_node)->type) == 94 || (PL_regkind[((text_node)->type)] == 47 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 70 || PL_regkind[type] == 47) text_node = ((((text_node) + 1)) + 1); else if (type == 46) text_node = ((text_node) + 1); else if (type == 68) text_node = (text_node ->flags == 0) ? ((((text_node) + 1)) + 1) : text_node + ((((struct regnode_1 *)text_node)->arg1)); else text_node += ((text_node)->next_off); } } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ^

"regexec.c", line 8463: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8463));  
  	    ^

"regexec.c", line 8566: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8566));  
  	    ^

"regexec.c", line 8596: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8596));  
  	    ^

"regexec.c", line 8624: warning #2111-D: statement is unreachable
  		    ((0) ? (void)0 : __assert("0", "regexec.c", 8624));  
  		    ^

"regexec.c", line 8728: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    next = scan + ((((struct regnode_1 *)scan)->arg1));
  		                     ^

"regexec.c", line 8745: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8745));  
  	    ^

"regexec.c", line 8763: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    scan = st->u . ifmatch .me + ((((struct regnode_1 *)st->u . ifmatch . me)->arg1));
  	                                    ^

"regexec.c", line 8772: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ((((struct regnode_1 *)scan)->arg1));
  	                     ^

"regexec.c", line 8783: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        sv_yes_mark = sv_commit = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
  	                                                                         ^

"regexec.c", line 8785: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8785));  
  	    ^

"regexec.c", line 8791: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8791));  
              ^

"regexec.c", line 8795: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_commit = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                                     ^

"regexec.c", line 8805: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8805));  
  	    ^

"regexec.c", line 8811: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                           ^

"regexec.c", line 8815: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8815));  
              ^

"regexec.c", line 8820: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8820));  
              ^

"regexec.c", line 8840: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8840));  
              ^

"regexec.c", line 8853: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  SV *find = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                                    ^

"regexec.c", line 8885: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8885));  
              ^

"regexec.c", line 9382: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	    while (scan < loceol && (((( (U8*) ((regnode_charclass*)(p))->bitmap) [ ( ( (UV) (*((U8*)scan))) >> 3) ] ) & (1U << ((*((U8*)scan)) & 7))) ? (_Bool)1 : (_Bool)0))
  	                                        ^

"regexec.c", line 9396: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          scan = (char *) S_find_span_end_mask((U8 *) scan, (U8 *) loceol, (U8) ((((struct regnode_1 *)p)->arg1)), ((p)->flags));
                                                                                   ^

"regexec.c", line 9712: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	if ((((( (U8*) ((regnode_charclass*)(n))->bitmap) [ ( ( (UV) (c)) >> 3) ] ) & (1U << ((c) & 7))) ? (_Bool)1 : (_Bool)0))
  	                ^

"regexec.c", line 9725: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		&& (((( (U8*) ((regnode_charclass*)(n))->bitmap) [ ( ( (UV) (PL_fold_locale[c])) >> 3) ] ) & (1U << ((PL_fold_locale[c]) & 7))) ? (_Bool)1 : (_Bool)0))
  		               ^

"regexec.c", line 9729: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
              else if (((((n)->flags) & 0x02) && (((regnode_charclass_posixl*)(n))->classflags))
                                                   ^

"regexec.c", line 9767: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      if ((((regnode_charclass_posixl*) (n))->classflags & (1U << (count)))
                            ^

"regexec.c", line 9799: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	else if (    ((((struct regnode_1 *)n)->arg1)) != ((U32) -1)
  	                ^

"regexec.c", line 3200: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sublen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sublen)))) ? (size_t)(sublen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(prog->subbeg)) != 0) ? (void)0 : __assert("((void*)(prog->subbeg)) != 0", "regexec.c", 3200)), ((((void*)(strbeg + min)) != 0) ? (void)0 : __assert("((void*)(strbeg + min)) != 0", "regexec.c", 3200)), (void)memcpy((char*)(prog->subbeg),(const char*)(strbeg + min), (sublen) * sizeof(char)));
                                                                                                                                                                                                   ^

"regexec.c", line 4452: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_utf8skip[*(const U8*)(pat)]) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_utf8skip[*(const U8*)(pat)])))) ? (size_t)(PL_utf8skip[*(const U8*)(pat)]) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(c1_utf8)) != 0) ? (void)0 : __assert("((void*)(c1_utf8)) != 0", "regexec.c", 4452)), ((((void*)(pat)) != 0) ? (void)0 : __assert("((void*)(pat)) != 0", "regexec.c", 4452)), (void)memcpy((char*)(c1_utf8),(const char*)(pat), (PL_utf8skip[*(const U8*)(pat)]) * sizeof(U8)));
                                                                                                                                                                                                                                                                       ^

"regexec.c", line 4453: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_utf8skip[*(const U8*)(pat)]) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_utf8skip[*(const U8*)(pat)])))) ? (size_t)(PL_utf8skip[*(const U8*)(pat)]) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(c2_utf8)) != 0) ? (void)0 : __assert("((void*)(c2_utf8)) != 0", "regexec.c", 4453)), ((((void*)(pat)) != 0) ? (void)0 : __assert("((void*)(pat)) != 0", "regexec.c", 4453)), (void)memcpy((char*)(c2_utf8),(const char*)(pat), (PL_utf8skip[*(const U8*)(pat)]) * sizeof(U8)));
                                                                                                                                                                                                                                                                       ^

"regexec.c", line 7909: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    (aux->poscache = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(aux->poscache),(size_t)((size)*sizeof(char))))));
  			                                                                                                                                                                                                    ^

"regexec.c", line 7912: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(aux->poscache)) != 0) ? (void)0 : __assert("((void*)(aux->poscache)) != 0", "regexec.c", 7912)), (void)memset((char*)(aux->poscache),0,(size) * sizeof(char)));
  			                                                                                                                                                                               ^

"regexec.c", line 7916: warning #4276-D: relational operator ">" always evaluates to 'false'
  			(aux->poscache = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((size),sizeof(char)))));
  			                                                                                                                                                                                                ^

"utf8.c", line 3282: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "utf8.c", 3282));  
      ^

"utf8.c", line 1086: warning #4276-D: relational operator ">" always evaluates to 'false'
      (output = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_len)))) ? (size_t)(output_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((output_len)*sizeof(char))))));
                                                                                                                                                                                                                 ^

"utf8.c", line 2578: warning #4276-D: relational operator ">" always evaluates to 'false'
      (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((*lenp) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((*lenp) + 1)))) ? (size_t)((*lenp) + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)(((*lenp) + 1)*sizeof(U8))))));
                                                                                                                                                                                                           ^

"utf8.c", line 2615: warning #4276-D: relational operator ">" always evaluates to 'false'
      (converted_start = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp + 1)))) ? (size_t)(*lenp + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(converted_start),(size_t)((*lenp + 1)*sizeof(U8))))));
                                                                                                                                                                                                                   ^

"utf8.c", line 2652: warning #4276-D: relational operator ">" always evaluates to 'false'
      (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((*lenp) * 2 + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((*lenp) * 2 + 1)))) ? (size_t)((*lenp) * 2 + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)(((*lenp) * 2 + 1)*sizeof(U8))))));
                                                                                                                                                                                                                       ^

"utf8.c", line 2664: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp + 1)))) ? (size_t)(*lenp + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dst),(size_t)((*lenp + 1)*sizeof(U8))))));
                                                                                                                                                                                                       ^

"utf8.c", line 3039: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "utf8.c", 3040)), ((((void*)("\xC5\xBF" "\xC5\xBF")) != 0) ? (void)0 : __assert("((void*)(\"\\xC5\\xBF\" \"\\xC5\\xBF\")) != 0", "utf8.c", 3040)), (void)memcpy((char*)(p),(const char*)("\xC5\xBF" "\xC5\xBF"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                            ^

"utf8.c", line 3508: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(ustrp)) != 0) ? (void)0 : __assert("((void*)(ustrp)) != 0", "utf8.c", 3508)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "utf8.c", 3508)), (void)memcpy((char*)(ustrp),(const char*)(p), (len) * sizeof(U8)));
                                                                                                                                                                                      ^

"utf8.c", line 3638: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(ustrp)) != 0) ? (void)0 : __assert("((void*)(ustrp)) != 0", "utf8.c", 3638)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "utf8.c", 3638)), (void)memcpy((char*)(ustrp),(const char*)(p), (*lenp) * sizeof(char)));
                                                                                                                                                                                        ^

"utf8.c", line 4034: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(ustrp)) != 0) ? (void)0 : __assert("((void*)(ustrp)) != 0", "utf8.c", 4034)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "utf8.c", 4034)), (void)memcpy((char*)(ustrp),(const char*)(p), (*lenp) * sizeof(char)));
  		                                                                                                                                                                                      ^

"utf8.c", line 4066: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(ustrp)) != 0) ? (void)0 : __assert("((void*)(ustrp)) != 0", "utf8.c", 4067)), ((((void*)("\xC5\xBF" "\xC5\xBF")) != 0) ? (void)0 : __assert("((void*)(\"\\xC5\\xBF\" \"\\xC5\\xBF\")) != 0", "utf8.c", 4067)), (void)memcpy((char*)(ustrp),(const char*)("\xC5\xBF" "\xC5\xBF"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                    ^

"utf8.c", line 4075: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*lenp) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*lenp)))) ? (size_t)(*lenp) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(ustrp)) != 0) ? (void)0 : __assert("((void*)(ustrp)) != 0", "utf8.c", 4075)), ((((void*)("\xEF\xAC\x86")) != 0) ? (void)0 : __assert("((void*)(\"\\xEF\\xAC\\x86\")) != 0", "utf8.c", 4075)), (void)memcpy((char*)(ustrp),(const char*)("\xEF\xAC\x86"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                    ^

"utf8.c", line 4551: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(klen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(klen)))) ? (size_t)(klen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(PL_last_swash_key)) != 0) ? (void)0 : __assert("((void*)(PL_last_swash_key)) != 0", "utf8.c", 4551)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "utf8.c", 4551)), (void)memcpy((char*)(PL_last_swash_key),(const char*)(ptr), (klen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"universal.c", line 386: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	    pkg = ((XPVMG*) (( (sv) && ( ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVLV ) && (0+(sv)->sv_u . svu_gp) ? ((0+(sv)->sv_u . svu_gp)->gp_io) : 0L ))->sv_any)->xmg_stash;
  	           ^

"universal.c", line 389: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          pkg = ((XPVMG*) (( (sv) && ( ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((const SV*)(sv))->sv_flags & 0xff)) == SVt_PVLV ) && (0+(sv)->sv_u . svu_gp) ? ((0+(sv)->sv_u . svu_gp)->gp_io) : 0L ))->sv_any)->xmg_stash;
                 ^

"universal.c", line 391: warning #4232-D: conversion from "XPVIO *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          pkg = ((XPVMG*) (( (iogv) && ( ((svtype)(((const SV*)(iogv))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((const SV*)(iogv))->sv_flags & 0xff)) == SVt_PVLV ) && (0+(iogv)->sv_u . svu_gp) ? ((0+(iogv)->sv_u . svu_gp)->gp_io) : 0L ))->sv_any)->xmg_stash;
                 ^

"universal.c", line 986: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "universal.c", 986));  
      ^

"universal.c", line 938: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(reflags + left)) != 0) ? (void)0 : __assert("((void*)(reflags + left)) != 0", "universal.c", 938)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "universal.c", 938)), (void)memcpy((char*)(reflags + left),(const char*)(name), (len) * sizeof(char)));
  		                                                                                                                                                                            ^

"perlio.c", line 2062: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      ((PerlIOBuf *)(*(f)))->posn = old;
       ^

"perlio.c", line 2760: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "perlio.c", 2760));  
      ^

"perlio.c", line 2789: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "perlio.c", 2789));  
      ^

"perlio.c", line 3844: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
                      ^

"perlio.c", line 3947: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4009: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4081: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
          const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                       ^

"perlio.c", line 4093: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4152: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4203: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	    PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                    ^

"perlio.c", line 4213: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4244: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4257: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4269: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                   ^

"perlio.c", line 4278: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                   ^

"perlio.c", line 4289: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4308: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      const PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                                   ^

"perlio.c", line 4317: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4407: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4565: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
      PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
                              ^

"perlio.c", line 4574: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                ^

"perlio.c", line 4620: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4624: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
  	PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
  	                        ^

"perlio.c", line 4692: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4693: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
      PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
                              ^

"perlio.c", line 4750: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
  	                       ^

"perlio.c", line 4797: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOCrlf *" may cause misaligned access
      PerlIOCrlf * const c = ((PerlIOCrlf *)(*(f)));
                              ^

"perlio.c", line 1138: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (temp = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tab->size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tab->size)))) ? (size_t)(tab->size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((tab->size),sizeof(char)))));
  	                                                                                                                                                                                                          ^

"perlio.c", line 2086: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(take) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(take)))) ? (size_t)(take) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "perlio.c", 2086)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "perlio.c", 2086)), (void)memcpy((char*)(buf),(const char*)(ptr), (take) * sizeof(unsigned char)));
  		                                                                                                                                                                                                 ^

"perlio.c", line 4055: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(avail) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(avail)))) ? (size_t)(avail) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(b->buf)) != 0) ? (void)0 : __assert("((void*)(b->buf)) != 0", "perlio.c", 4055)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "perlio.c", 4055)), (void)memcpy((char*)(b->buf),(const char*)(ptr), (avail) * sizeof(unsigned char)));
  	                                                                                                                                                                                                        ^

"perlio.c", line 4136: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(avail) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(avail)))) ? (size_t)(avail) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(b->ptr)) != 0) ? (void)0 : __assert("((void*)(b->ptr)) != 0", "perlio.c", 4136)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "perlio.c", 4136)), (void)memcpy((char*)(b->ptr),(const char*)(buf), (avail) * sizeof(unsigned char)));
  		                                                                                                                                                                                                    ^

"perlio.c", line 4178: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(avail) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(avail)))) ? (size_t)(avail) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(b->ptr)) != 0) ? (void)0 : __assert("((void*)(b->ptr)) != 0", "perlio.c", 4178)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "perlio.c", 4178)), (void)memcpy((char*)(b->ptr),(const char*)(buf), (avail) * sizeof(unsigned char)));
  	                                                                                                                                                                                                        ^

"perlio.c", line 4295: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(b->buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(b->bufsiz) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(b->bufsiz)))) ? (size_t)(b->bufsiz) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (unsigned char*)(Perl_safesysmalloc((size_t)((b->bufsiz)*sizeof(unsigned char))))));
  	                                                                                                                                                                                                                          ^

"numeric.c", line 1618: warning #2111-D: statement is unreachable
      *value = result[2];
      ^

"numeric.c", line 745: warning #4277-D: logical AND with a constant, do you mean to use '&'?
                          !(nantype && 0x01)) {
                                    ^

"numeric.c", line 1457: warning #4276-D: relational operator ">" always evaluates to 'false'
              (copy = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len + 1)*sizeof(char))))));
                                                                                                                                                                                                              ^

"numeric.c", line 1458: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(copy)) != 0) ? (void)0 : __assert("((void*)(copy)) != 0", "numeric.c", 1458)), ((((void*)(orig)) != 0) ? (void)0 : __assert("((void*)(orig)) != 0", "numeric.c", 1458)), (void)memcpy((char*)(copy),(const char*)(orig), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"locale.c", line 148: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(locs)) != 0) ? (void)0 : __assert("((void*)(locs)) != 0", "locale.c", 148)), ((((void*)(s + 1)) != 0) ? (void)0 : __assert("((void*)(s + 1)) != 0", "locale.c", 148)), (void)memmove((char*)(locs),(const char*)(s + 1), (len) * sizeof(char)));
  		                                                                                                                                                                            ^

"locale.c", line 310: warning #4276-D: relational operator ">" always evaluates to 'false'
          (unknown = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(length)))) ? (size_t)(length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((length)*sizeof(char))))));
                                                                                                                                                                                                          ^

"locale.c", line 2301: warning #4276-D: relational operator ">" always evaluates to 'false'
          (*buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(string_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(string_size)))) ? (size_t)(string_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((string_size)*sizeof(char))))));
                                                                                                                                                                                                                      ^

"locale.c", line 2305: warning #4276-D: relational operator ">" always evaluates to 'false'
          (*buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(string_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(string_size)))) ? (size_t)(string_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(*buf),(size_t)((string_size)*sizeof(char))))));
                                                                                                                                                                                                                      ^

"locale.c", line 2309: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(string_size - offset) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(string_size - offset)))) ? (size_t)(string_size - offset) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(*buf + offset)) != 0) ? (void)0 : __assert("((void*)(*buf + offset)) != 0", "locale.c", 2309)), ((((void*)(string)) != 0) ? (void)0 : __assert("((void*)(string)) != 0", "locale.c", 2309)), (void)memcpy((char*)(*buf + offset),(const char*)(string), (string_size - offset) * sizeof(char)));
                                                                                                                                                                                                                                     ^

"locale.c", line 3918: warning #4276-D: relational operator ">" always evaluates to 'false'
          (sans_nuls = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sans_nuls_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sans_nuls_len)))) ? (size_t)(sans_nuls_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((sans_nuls_len)*sizeof(char))))));
                                                                                                                                                                                                                                 ^

"locale.c", line 4050: warning #4276-D: relational operator ">" always evaluates to 'false'
                  (s = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                                   ^

"locale.c", line 4071: warning #4276-D: relational operator ">" always evaluates to 'false'
                      (s = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(d) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(d)))) ? (size_t)(d) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(s),(size_t)((d)*sizeof(char))))));    
                                                                                                                                                                                                 ^

"locale.c", line 4094: warning #4276-D: relational operator ">" always evaluates to 'false'
      (xbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(xAlloc) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(xAlloc)))) ? (size_t)(xAlloc) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((xAlloc)*sizeof(char))))));
                                                                                                                                                                                                   ^

"locale.c", line 4228: warning #4276-D: relational operator ">" always evaluates to 'false'
          (xbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(xAlloc) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(xAlloc)))) ? (size_t)(xAlloc) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(xbuf),(size_t)((xAlloc)*sizeof(char))))));
                                                                                                                                                                                                       ^

"locale.c", line 4253: warning #4276-D: relational operator ">" always evaluates to 'false'
      (xbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(PL_collation_ix) + *xlen + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(PL_collation_ix) + *xlen + 1)))) ? (size_t)(sizeof(PL_collation_ix) + *xlen + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(xbuf),(size_t)((sizeof(PL_collation_ix) + *xlen + 1)*sizeof(char))))));
                                                                                                                                                                                                                                                                                          ^

"locale.c", line 4495: warning #4276-D: relational operator ">" always evaluates to 'false'
      (delimited = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len_with_overhead) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len_with_overhead)))) ? (size_t)(input_name_len_with_overhead) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((input_name_len_with_overhead)*sizeof(char))))));
                                                                                                                                                                                                                                                                          ^

"locale.c", line 4497: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len)))) ? (size_t)(input_name_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(delimited + 1)) != 0) ? (void)0 : __assert("((void*)(delimited + 1)) != 0", "locale.c", 4497)), ((((void*)(save_input_locale)) != 0) ? (void)0 : __assert("((void*)(save_input_locale)) != 0", "locale.c", 4497)), (void)memcpy((char*)(delimited + 1),(const char*)(save_input_locale), (input_name_len) * sizeof(char)));
                                                                                                                                                                                                                   ^

"locale.c", line 4520: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(name_pos - utf8ness_cache) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(name_pos - utf8ness_cache)))) ? (size_t)(name_pos - utf8ness_cache) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(utf8ness_cache + input_name_len_with_overhead)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache + input_name_len_with_overhead)) != 0", "locale.c", 4522)), ((((void*)(utf8ness_cache)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache)) != 0", "locale.c", 4522)), (void)memmove((char*)(utf8ness_cache + input_name_len_with_overhead),(const char*)(utf8ness_cache), (name_pos - utf8ness_cache) * sizeof(char)));
                                                                                                                                                                                                                                                            ^

"locale.c", line 4523: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len_with_overhead - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len_with_overhead - 1)))) ? (size_t)(input_name_len_with_overhead - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(utf8ness_cache)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache)) != 0", "locale.c", 4525)), ((((void*)(delimited)) != 0) ? (void)0 : __assert("((void*)(delimited)) != 0", "locale.c", 4525)), (void)memcpy((char*)(utf8ness_cache),(const char*)(delimited), (input_name_len_with_overhead - 1) * sizeof(char)));
                                                                                                                                                                                                                                                                                 ^

"locale.c", line 4947: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(utf8ness_cache_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(utf8ness_cache_len + 1)))) ? (size_t)(utf8ness_cache_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(utf8ness_cache + input_name_len_with_overhead)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache + input_name_len_with_overhead)) != 0", "locale.c", 4949)), ((((void*)(utf8ness_cache)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache)) != 0", "locale.c", 4949)), (void)memmove((char*)(utf8ness_cache + input_name_len_with_overhead),(const char*)(utf8ness_cache), (utf8ness_cache_len + 1) * sizeof(char)));
                                                                                                                                                                                                                                               ^

"locale.c", line 4952: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(input_name_len_with_overhead - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(input_name_len_with_overhead - 1)))) ? (size_t)(input_name_len_with_overhead - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(utf8ness_cache)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache)) != 0", "locale.c", 4952)), ((((void*)(delimited)) != 0) ? (void)0 : __assert("((void*)(delimited)) != 0", "locale.c", 4952)), (void)memcpy((char*)(utf8ness_cache),(const char*)(delimited), (input_name_len_with_overhead - 1) * sizeof(char)));
                                                                                                                                                                                                                                                                             ^

"pp_pack.c", line 2017: warning #4276-D: relational operator ">" always evaluates to 'false'
      (to_start = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                              ^

"pp_pack.c", line 2018: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(from_ptr-from_start) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(from_ptr-from_start)))) ? (size_t)(from_ptr-from_start) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(to_start)) != 0) ? (void)0 : __assert("((void*)(to_start)) != 0", "pp_pack.c", 2018)), ((((void*)(from_start)) != 0) ? (void)0 : __assert("((void*)(from_start)) != 0", "pp_pack.c", 2018)), (void)memcpy((char*)(to_start),(const char*)(from_start), (from_ptr-from_start) * sizeof(char)));
                                                                                                                                                                                                                                  ^

"pp_pack.c", line 2221: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 2221)), (void)memset((char*)(cur),0,(len) * sizeof(char)));
  			                                                                                                                                                                            ^

"pp_pack.c", line 2414: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(fromlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(fromlen)))) ? (size_t)(fromlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 2414)), ((((void*)(aptr)) != 0) ? (void)0 : __assert("((void*)(aptr)) != 0", "pp_pack.c", 2414)), (void)memcpy((char*)(cur),(const char*)(aptr), (fromlen) * sizeof(char)));
  		                                                                                                                                                                                        ^

"pp_pack.c", line 2488: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(field_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(field_len)))) ? (size_t)(field_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 2488)), (void)memset((char*)(cur),0,(field_len) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"pp_pack.c", line 2563: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(field_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(field_len)))) ? (size_t)(field_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 2563)), (void)memset((char*)(cur),0,(field_len) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"pp_pack.c", line 2898: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN glen = ((buf + sizeof(buf)) - in); STRLEN gl = glen; if (utf8) do { if ((gl) > (ssize_t)(~(size_t)0 >> 1) / 2) Perl_croak( "%s", "Out of memory during pack()"); (gl) = (gl) * 2; } while (0); if ((cur) + gl >= (start) + ((XPV*) (cat)->sv_any)->xpv_len_u . xpvlenu_len) { *cur = '\0'; do { ((PL_valid_types_PVX[((svtype)(((cat))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((cat)) & SVt_MASK]", "pp_pack.c", 2899)); ((!(((((cat))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((cat))", "pp_pack.c", 2899)); ((!(((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((cat))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((cat)) == SVt_PVIO && !(IoFLAGS((cat)) & IOf_FAKE_DIRP))", "pp_pack.c", 2899)); (((XPV*) ((cat))->sv_any)->xpv_cur = ((cur) - (start))); } while (0); (start) = S_sv_exp_grow( cat,gl); (cur) = (start) + ((XPV*) (cat)->sv_any)->xpv_cur; } do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) in, glen, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(in), cur, glen); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(glen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(glen)))) ? (size_t)(glen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 2899)), ((((void*)(in)) != 0) ? (void)0 : __assert("((void*)(in)) != 0", "pp_pack.c", 2899)), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ^

"pp_pack.c", line 2931: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN glen = ((buf + sizeof(buf)) - in); STRLEN gl = glen; if (utf8) do { if ((gl) > (ssize_t)(~(size_t)0 >> 1) / 2) Perl_croak( "%s", "Out of memory during pack()"); (gl) = (gl) * 2; } while (0); if ((cur) + gl >= (start) + ((XPV*) (cat)->sv_any)->xpv_len_u . xpvlenu_len) { *cur = '\0'; do { ((PL_valid_types_PVX[((svtype)(((cat))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((cat)) & SVt_MASK]", "pp_pack.c", 2932)); ((!(((((cat))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((cat))", "pp_pack.c", 2932)); ((!(((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((cat))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((cat)) == SVt_PVIO && !(IoFLAGS((cat)) & IOf_FAKE_DIRP))", "pp_pack.c", 2932)); (((XPV*) ((cat))->sv_any)->xpv_cur = ((cur) - (start))); } while (0); (start) = S_sv_exp_grow( cat,gl); (cur) = (start) + ((XPV*) (cat)->sv_any)->xpv_cur; } do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) in, glen, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(in), cur, glen); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(glen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(glen)))) ? (size_t)(glen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 2932)), ((((void*)(in)) != 0) ? (void)0 : __assert("((void*)(in)) != 0", "pp_pack.c", 2932)), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ^

"pp_pack.c", line 2946: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (result = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
  		                                                                                                                                                                                          ^

"pp_pack.c", line 2951: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN glen = ((result + len) - in); STRLEN gl = glen; if (utf8) do { if ((gl) > (ssize_t)(~(size_t)0 >> 1) / 2) Perl_croak( "%s", "Out of memory during pack()"); (gl) = (gl) * 2; } while (0); if ((cur) + gl >= (start) + ((XPV*) (cat)->sv_any)->xpv_len_u . xpvlenu_len) { *cur = '\0'; do { ((PL_valid_types_PVX[((svtype)(((cat))->sv_flags & 0xff)) & 0xf]) ? (void)0 : __assert("PL_valid_types_PVX[SvTYPE((cat)) & SVt_MASK]", "pp_pack.c", 2952)); ((!(((((cat))->sv_flags & (0x00004000|0x00008000)) == 0x00008000) && (((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVGV || ((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVLV))) ? (void)0 : __assert("!isGV_with_GP((cat))", "pp_pack.c", 2952)); ((!(((svtype)(((cat))->sv_flags & 0xff)) == SVt_PVIO && !(((XPVIO*) ((cat))->sv_any)->xio_flags & 64))) ? (void)0 : __assert("!(SvTYPE((cat)) == SVt_PVIO && !(IoFLAGS((cat)) & IOf_FAKE_DIRP))", "pp_pack.c", 2952)); (((XPV*) ((cat))->sv_any)->xpv_cur = ((cur) - (start))); } while (0); (start) = S_sv_exp_grow( cat,gl); (cur) = (start) + ((XPV*) (cat)->sv_any)->xpv_cur; } do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) in, glen, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(in), cur, glen); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(glen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(glen)))) ? (size_t)(glen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 2952)), ((((void*)(in)) != 0) ? (void)0 : __assert("((void*)(in)) != 0", "pp_pack.c", 2952)), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"pp_pack.c", line 3119: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { if (__builtin_expect(((utf8) ? (_Bool)1 : (_Bool)0),(0))) (cur) = S_my_bytes_to_utf8((U8 *) hunk, end-hunk, (cur), 0); else { if (__builtin_expect(((0) ? (_Bool)1 : (_Bool)0),(0))) S_reverse_copy((char *)(hunk), cur, end-hunk); else ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(end-hunk) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(end-hunk)))) ? (size_t)(end-hunk) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur)) != 0) ? (void)0 : __assert("((void*)(cur)) != 0", "pp_pack.c", 3119)), ((((void*)(hunk)) != 0) ? (void)0 : __assert("((void*)(hunk)) != 0", "pp_pack.c", 3119)), (void)memcpy((char*)(cur),(const char*)(hunk), (end-hunk) * sizeof(char))); (cur) += (end-hunk); } } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                         ^

cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
"op.c", line 12320: warning #2111-D: statement is unreachable
          ((0) ? (void)0 : __assert("0", "op.c", 12320));  
          ^

"op.c", line 12996: warning #2111-D: statement is unreachable
  	} ((0) ? (void)0 : __assert("0", "op.c", 12996));  
  	  ^

"op.c", line 15228: warning #2549-D: variable "defer_queue" is used before its value is set
                          defer_queue[(defer_base + defer_ix--) % 4];
                          ^

"op.c", line 16274: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "op.c", 16274));  
              ^

"op.c", line 3183: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l)))) ? (size_t)(l) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "op.c", 3183)), ((((void*)(argp->p)) != 0) ? (void)0 : __assert("((void*)(argp->p)) != 0", "op.c", 3183)), (void)memcpy((char*)(p),(const char*)(argp->p), (l) * sizeof(char)));
                                                                                                                                                                                        ^

"op.c", line 5143: warning #4276-D: relational operator ">" always evaluates to 'false'
      PL_compiling.cop_warnings = (((PL_compiling . cop_warnings) == 0L || (PL_compiling . cop_warnings) == (((STRLEN*)0)+1) || (PL_compiling . cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_compiling . cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings)))) ? (size_t)(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(malloc((sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings)))) != 0) ? (void)0 : __assert("((void*)(malloc((sizeof(*PL_compiling.cop_warnings)+*PL_compiling.cop_warnings)))) != 0", "op.c", 5143)), ((((void*)(PL_compiling . cop_warnings)) != 0) ? (void)0 : __assert("((void*)(PL_compiling.cop_warnings)) != 0", "op.c", 5143)), memcpy((char*)(malloc((sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings))),(const char*)(PL_compiling . cop_warnings), (sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 8048: warning #4276-D: relational operator ">" always evaluates to 'false'
      cop->cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) != 0) ? (void)0 : __assert("((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+*PL_curcop->cop_warnings)))) != 0", "op.c", 8048)), ((((void*)(PL_curcop->cop_warnings)) != 0) ? (void)0 : __assert("((void*)(PL_curcop->cop_warnings)) != 0", "op.c", 8048)), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 10502: warning #4276-D: relational operator ">" always evaluates to 'false'
  	 PL_compiling.cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) != 0) ? (void)0 : __assert("((void*)(malloc((sizeof(*PL_curcop->cop_warnings)+*PL_curcop->cop_warnings)))) != 0", "op.c", 10502)), ((((void*)(PL_curcop->cop_warnings)) != 0) ? (void)0 : __assert("((void*)(PL_curcop->cop_warnings)) != 0", "op.c", 10502)), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"op.c", line 12436: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(end - s - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(end - s - 1)))) ? (size_t)(end - s - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(s+1)) != 0) ? (void)0 : __assert("((void*)(s+1)) != 0", "op.c", 12436)), ((((void*)(s+2)) != 0) ? (void)0 : __assert("((void*)(s+2)) != 0", "op.c", 12436)), (void)memmove((char*)(s+1),(const char*)(s+2), (end - s - 1) * sizeof(char)));
  		                                                                                                                                                                                                        ^

"op.c", line 12605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(tmpbuf+1)) != 0) ? (void)0 : __assert("((void*)(tmpbuf+1)) != 0", "op.c", 12605)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "op.c", 12605)), (void)memcpy((char*)(tmpbuf+1),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"perl.c", line 3496: warning #2111-D: statement is unreachable
          ((0) ? (void)0 : __assert("0", "perl.c", 3496));  
          ^

"perl.c", line 4578: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
            if (((((XPVHV*) (dups)->sv_any)->xhv_keys) - (((XPVMG*) (dups)->sv_any)->xmg_u . xmg_magic ? Perl_hv_placeholders_get( (const HV *)dups) : 0))) {
                                                           ^

cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
parts/inc/mess provides vmess, which is still marked todo for 5.6.0
"B.c", line 1431: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.c", line 1525: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.xs", line 1314: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1322: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1331: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1340: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.xs", line 1348: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"B.c", line 1801: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.c", line 1947: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.c", line 2465: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"B.xs", line 2035: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	if (HvUSEDKEYS(hv) > 0) {
  	    ^

"B.xs", line 2040: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
  	    assert(HvUSEDKEYS(hv) <= (SSize_t_MAX >> 1));
  	    ^

"B.xs", line 2041: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              extend_size = (SSize_t)HvUSEDKEYS(hv) * 2;
                                     ^

"B.c", line 3435: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Bzip2.xs", line 832: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        Move(s->stream.next_in, SvPVX(buf), in, char) ;	
  	        ^

"bzlib.c", line 868: warning #2111-D: statement is unreachable
     AssertH ( 0, 6001 );
     ^

"Zlib.xs", line 1108: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s->deflateParams_out_buffer, s->stream.next_out, plen, Bytef) ;	
          ^

"Zlib.xs", line 1237: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s->deflateParams_out_buffer, s->stream.next_out, plen, Bytef) ;	
          ^

"Zlib.xs", line 1669: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        Move(s->stream.next_in, SvPVX(buf), in, char) ;	
  	        ^

"Zlib.xs", line 1732: warning #4276-D: relational operator ">" always evaluates to 'false'
       	    Move(s->stream.next_in, SvPVX(buf), in, char) ;	
       	    ^

"Zlib.xs", line 1977: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Move(s->stream.next_in, SvPVX(buf), in, char) ;	
                  ^

"DB_File.xs", line 637: warning #4232-D: conversion from "_Bool *" to a more strictly aligned type "int *" may cause misaligned access
      SAVEINT(CurrentDB->in_compare);
      ^

"DB_File.xs", line 725: warning #4232-D: conversion from "_Bool *" to a more strictly aligned type "int *" may cause misaligned access
      SAVEINT(CurrentDB->in_prefix);
      ^

"DB_File.xs", line 810: warning #4232-D: conversion from "_Bool *" to a more strictly aligned type "int *" may cause misaligned access
      SAVEINT(CurrentDB->in_hash);
      ^

"Dumper.xs", line 908: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    New(0, iname, namelen+28, char);
  	    ^

"Dumper.xs", line 1140: warning #4276-D: relational operator ">" always evaluates to 'false'
  			New(0, nkey_buffer, klen+nticks+3, char);
  			^

"Dumper.xs", line 1146: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    (void)Copy(key, nkey+1, klen, char);
  			          ^

"Dumper.xs", line 1167: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    New(0, extra, klen+4+1, char);
  		    ^

"Dumper.xs", line 1256: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        New(0, npack_buffer, plen+pticks+1, char);
  	        ^

parts/inc/mess provides vmess, which is still marked todo for 5.6.0
"RealPPPort.c", line 1187: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 1648: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2149: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2171: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2193: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2215: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2237: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2258: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2279: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2300: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2321: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 2342: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3201: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3267: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3328: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"RealPPPort.c", line 3369: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3399: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.xs", line 1816: warning #2068-D: integer conversion resulted in a change of sign
                  if (SvUTF8(utf8_key)) klen *= -1;
                                                ^

"RealPPPort.c", line 3622: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3645: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3664: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3686: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3724: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3752: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3771: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3790: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 3883: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4035: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4060: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4100: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4422: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4446: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4469: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4683: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.c", line 4751: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"RealPPPort.xs", line 655: warning #4276-D: relational operator ">" always evaluates to 'false'
                  SvPV_renew(sv, nlen);
                  ^

"RealPPPort.xs", line 656: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Copy(str, SvPVX(sv), slen + 1, char);
                  ^

"RealPPPort.xs", line 1435: warning #4276-D: relational operator ">" always evaluates to 'false'
                  New(42, copy, len+1, char);
                  ^

"RealPPPort.xs", line 1436: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Copy(str, copy, len+1, char);
                  ^

"MD5.xs", line 510: warning #2191-D: type qualifier is meaningless on cast type
  	    && mg->mg_virtual == (const MGVTBL * const)&vtbl_md5) {
  	                          ^

"MD5.xs", line 532: warning #2191-D: type qualifier is meaningless on cast type
  	sv_magicext(sv, NULL, PERL_MAGIC_ext, (const MGVTBL * const)&vtbl_md5, (const char *)context, 0);
  	                                       ^

"MD5.c", line 799: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 827: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 876: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 938: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"MD5.c", line 963: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 1017: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.c", line 1086: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"MD5.xs", line 439: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Copy(buf, ctx->buffer + fill, len, U8);
  	    ^

"MD5.xs", line 442: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(buf, ctx->buffer + fill, missing, U8);
  	^

"MD5.xs", line 452: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(buf + (blocks << 6), ctx->buffer, len, U8);
  	^

"MD5.xs", line 466: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(PADDING, ctx->buffer + fill, padlen, U8);
      ^

"SHA.c", line 504: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SHA.c", line 623: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SHA.c", line 654: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SHA.c", line 715: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"src/sha.c", line 331: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(bitstr, s->block, NBYTES(bitcnt), char);
  		^

"src/sha.c", line 347: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(bitstr, s->block+offset, nbits>>3, char);
  		^

"src/sha.c", line 354: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(bitstr, s->block+offset, NBYTES(bitcnt), char);
  		^

"src/sha.c", line 455: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(in, byte, n, UCHR);
  	^

"src/sha.c", line 495: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(key, h->key, keylen, char);
  		^

"src/sha.c", line 501: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Copy(digcpy(&ksha), h->key, ksha.digestlen, char);
  		^

"SHA.xs", line 307: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(digcpy(state), ptr, state->alg <= SHA256 ? 32 : 64, UCHR);
  	^

"SHA.xs", line 309: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(state->block, ptr, state->alg <= SHA256 ? 64 : 128, UCHR);
  	^

"SHA.xs", line 336: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(data, state->block, state->blocksize >> 3, UCHR);
  	^

"Unicode.c", line 512: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Unicode.c", line 657: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Unicode.xs", line 332: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Move(s,SvPVX(str),e-s,U8);
  	    ^

"Unicode.xs", line 342: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Unicode.xs", line 342: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Unicode.xs", line 457: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Move(s,SvPVX(utf8),e-s,U8);
  	    ^

"Unicode.xs", line 467: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Unicode.xs", line 467: warning #4276-D: relational operator ">" always evaluates to 'false'
      if (!temp_result) shrink_buffer(result);
                        ^

"Encode.c", line 906: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Encode.c", line 1001: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Encode.xs", line 514: warning #4276-D: relational operator ">" always evaluates to 'false'
          Move(s, d, len, U8);
          ^

"Encode.xs", line 1040: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(83, dest, len, U8); /* I think */
          ^

"bsd_glob.c", line 893: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(copy, p-path, char);
  	^

"Util.c", line 266: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 354: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"Util.c", line 371: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 409: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.xs", line 161: warning #4232-D: conversion from "XPVHV *const" to a more strictly aligned type "XPVMG *" may cause misaligned access
          U32 total_keys= HvUSEDKEYS(hv);
                          ^

"Util.c", line 528: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 622: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 656: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 684: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Util.c", line 712: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"IO.c", line 558: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"IO.c", line 591: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"SysV.c", line 311: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 356: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 394: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 435: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 477: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 522: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"SysV.c", line 583: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"SysV.c", line 622: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"SysV.c", line 654: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"SysV.c", line 688: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"SysV.c", line 712: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"SysV.xs", line 360: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(caddr + pos, dst, size, char);
      ^

"SysV.xs", line 381: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(src, caddr + pos, n, char);
      ^

"ListUtil.c", line 355: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 536: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 582: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 654: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 732: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 806: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 866: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 908: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 965: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 999: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1033: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1126: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1389: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.c", line 1439: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1606: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1627: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1800: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1865: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"ListUtil.c", line 1939: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"ListUtil.c", line 1980: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"ListUtil.xs", line 1634: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
      mg = SvMAGIC(cv);
           ^

"ListUtil.xs", line 1639: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          mg->mg_moremagic = SvMAGIC(cv);
                             ^

"ListUtil.xs", line 1642: warning #4232-D: conversion from "XPVCV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          SvMAGIC_set(cv, mg);
          ^

"ListUtil.c", line 2159: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"FastCalc.c", line 332: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"FastCalc.c", line 385: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"FastCalc.c", line 432: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"FastCalc.c", line 512: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Opcode.xs", line 138: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Zero(SvPVX_const(opset), opset_len + 1, char);
  	^

Warning (mostly harmless): No library found for -lposix
Warning (mostly harmless): No library found for -lcposix
"POSIX.c", line 2010: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"POSIX.c", line 2171: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"POSIX.c", line 5030: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"encoding.xs", line 57: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 93: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 178: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 201: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 238: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 397: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 514: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"encoding.xs", line 543: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
                     ^

"encoding.xs", line 559: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
  	PerlIOEncode *fe = PerlIOSelf(f, PerlIOEncode);
  	                   ^

"encoding.xs", line 560: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
  	PerlIOEncode *oe = PerlIOSelf(o, PerlIOEncode);
  	                   ^

"encoding.xs", line 574: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOEncode *" may cause misaligned access
      PerlIOEncode *e = PerlIOSelf(f, PerlIOEncode);
                        ^

"mmap.xs", line 30: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 36: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
  	                      ^

"mmap.xs", line 94: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 122: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 155: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 186: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 213: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOMmap *" may cause misaligned access
      PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
                             ^

"mmap.xs", line 241: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
                            ^

"scalar.xs", line 22: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
          PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                            ^

"scalar.xs", line 35: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 91: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 117: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 151: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 168: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 216: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 291: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 303: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 313: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 328: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
  	                  ^

"scalar.xs", line 338: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 369: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
                        ^

"scalar.xs", line 390: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
      PerlIOScalar * const os = PerlIOSelf(o, PerlIOScalar);
                                ^

"scalar.xs", line 395: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOScalar *" may cause misaligned access
  	fs = PerlIOSelf(f, PerlIOScalar);
  	     ^

"scalar.xs", line 205: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(p + (STRLEN)(s->posn), vbuf, got, STDCHAR);
  	^

"scalar.xs", line 252: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Zero(SvPVX(sv) + cur, (STRLEN)s->posn - cur, char);
  		^

"scalar.xs", line 261: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Move(vbuf, dst + offset, count, char);
  	^

"via.xs", line 438: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Move(SvPVX(buf), vbuf, rd, char);
  		^

"Socket.c", line 963: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"Socket.xs", line 706: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(sa, addr_len, char);
  	^

"Socket.xs", line 707: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(SvPV_nolen(addr), sa, addr_len, char);
  	^

"Socket.xs", line 858: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Copy(pathname_pv, sun_ad.sun_path, len, char);
  	^

"Socket.xs", line 1155: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Copy(ip_address, &addr, addrlen, char);
  	    ^

"Socket.xs", line 1156: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Zero(((char*)&addr) + addrlen, sizeof(addr) - addrlen, char);
  	    ^

"Storable.xs", line 2817: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
          TRACEME(("size = %d, used = %d", (int)l, (int)HvUSEDKEYS(hv)));
          ^

"Storable.xs", line 2887: warning #4232-D: conversion from "XPVHV *" to a more strictly aligned type "XPVMG *" may cause misaligned access
              int placeholders = (int)HvPLACEHOLDERS_get(hv);
                                      ^

"Storable.c", line 7945: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Storable.xs", line 2357: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(is_weak ? SX_WEAKOVERLOAD : SX_OVERLOAD);
              ^

"Storable.xs", line 2359: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(is_weak ? SX_WEAKREF : SX_REF);
              ^

"Storable.xs", line 2361: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(is_weak ? SX_WEAKREF : SX_REF);
          ^

"Storable.xs", line 2419: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SV_UNDEF);
              ^

"Storable.xs", line 2422: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_UNDEF);
              ^

"Storable.xs", line 2461: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SV_YES);
              ^

"Storable.xs", line 2464: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SV_NO);
              ^

"Storable.xs", line 2508: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_BYTE);
              ^

"Storable.xs", line 2509: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(siv);
              ^

"Storable.xs", line 2534: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_NETINT);
              ^

"Storable.xs", line 2535: warning #4276-D: relational operator ">" always evaluates to 'false'
              WRITE_I32(niv);
              ^

"Storable.xs", line 2538: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_INTEGER);
              ^

"Storable.xs", line 2539: warning #4276-D: relational operator ">" always evaluates to 'false'
              WRITE(&iv, sizeof(iv));
              ^

"Storable.xs", line 2578: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_DOUBLE);
          ^

"Storable.xs", line 2579: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(&nv, sizeof(nv));
          ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2603: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_PV_LEN((const char *)mg->mg_ptr,
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2610: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_UTF8STR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2612: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SCALAR(pv, wlen);
              ^

"Storable.xs", line 2657: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_ARRAY);
          ^

"Storable.xs", line 2658: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2658: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2683: warning #4276-D: relational operator ">" always evaluates to 'false'
              STORE_SV_UNDEF();
              ^

"Storable.xs", line 2695: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_SVUNDEF_ELEM);
              ^

"Storable.xs", line 2810: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_FLAG_HASH);
              ^

"Storable.xs", line 2811: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(hash_flags);
              ^

"Storable.xs", line 2814: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(SX_HASH);
              ^

"Storable.xs", line 2816: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2816: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(l);
          ^

"Storable.xs", line 2984: warning #4276-D: relational operator ">" always evaluates to 'false'
                  PUTMARK(flags);
                  ^

"Storable.xs", line 2996: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(keylen);
              ^

"Storable.xs", line 2996: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(keylen);
              ^

"Storable.xs", line 2998: warning #4276-D: relational operator ">" always evaluates to 'false'
                  WRITE(keyval, keylen);
                  ^

"Storable.xs", line 3177: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flags);
              ^

"Storable.xs", line 3193: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3193: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3195: warning #4276-D: relational operator ">" always evaluates to 'false'
                  WRITE(key, len);
                  ^

"Storable.xs", line 3350: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(SX_CODE);
      ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3360: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_UTF8STR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3362: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(SvPV_nolen(text), len);
          ^

"Storable.xs", line 3438: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(SX_REGEXP);
      ^

"Storable.xs", line 3439: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(op_flags);
      ^

"Storable.xs", line 3442: warning #4276-D: relational operator ">" always evaluates to 'false'
        WLEN(re_len32);
        ^

"Storable.xs", line 3442: warning #4276-D: relational operator ">" always evaluates to 'false'
        WLEN(re_len32);
        ^

"Storable.xs", line 3445: warning #4276-D: relational operator ">" always evaluates to 'false'
        PUTMARK(re_len);
        ^

"Storable.xs", line 3446: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE(re_pv, re_len);
      ^

"Storable.xs", line 3447: warning #4276-D: relational operator ">" always evaluates to 'false'
      PUTMARK(flags_len);
      ^

"Storable.xs", line 3448: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE(flags_pv, flags_len);
      ^

"Storable.xs", line 3483: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_HASH);		/* Introduces tied hash */
          ^

"Storable.xs", line 3486: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_ARRAY);		/* Introduces tied array */
          ^

"Storable.xs", line 3489: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_SCALAR);	/* Introduces tied scalar */
          ^

"Storable.xs", line 3548: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_KEY);
          ^

"Storable.xs", line 3562: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_TIED_IDX);
          ^

"Storable.xs", line 3570: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(idx);
          ^

"Storable.xs", line 3570: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(idx);
          ^

"Storable.xs", line 3850: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    PUTMARK(SX_HOOK);
  	    ^

"Storable.xs", line 3851: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flags);
              ^

"Storable.xs", line 3853: warning #4276-D: relational operator ">" always evaluates to 'false'
                  PUTMARK(eflags);
                  ^

"Storable.xs", line 3855: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flags);
              ^

"Storable.xs", line 3970: warning #4276-D: relational operator ">" always evaluates to 'false'
  	PUTMARK(SX_HOOK);
  	^

"Storable.xs", line 3971: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(flags);
          ^

"Storable.xs", line 3973: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(eflags);
              ^

"Storable.xs", line 3975: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(flags);
          ^

"Storable.xs", line 3980: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 3980: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 3983: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(cnum);
              ^

"Storable.xs", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);
              ^

"Storable.xs", line 3990: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(clen);
              ^

"Storable.xs", line 3992: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(classname, len);		/* Final \0 is omitted */
          ^

"Storable.xs", line 4004: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

"Storable.xs", line 4004: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

"Storable.xs", line 4007: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(clen);
          ^

"Storable.xs", line 4010: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(pv, (SSize_t)len2);	/* Final \0 is omitted */
          ^

"Storable.xs", line 4020: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len3);
              ^

"Storable.xs", line 4020: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len3);
              ^

"Storable.xs", line 4025: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(clen);
              ^

"Storable.xs", line 4046: warning #4276-D: relational operator ">" always evaluates to 'false'
                  WRITE_I32(tagval);
                  ^

"Storable.xs", line 4155: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_IX_BLESS);
          ^

"Storable.xs", line 4158: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(cnum);
              ^

"Storable.xs", line 4161: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flag);
              ^

"Storable.xs", line 4162: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 4162: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(classnum);
              ^

"Storable.xs", line 4167: warning #4276-D: relational operator ">" always evaluates to 'false'
          PUTMARK(SX_BLESS);
          ^

"Storable.xs", line 4170: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(clen);
              ^

"Storable.xs", line 4173: warning #4276-D: relational operator ">" always evaluates to 'false'
              PUTMARK(flag);
              ^

"Storable.xs", line 4174: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

"Storable.xs", line 4174: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

"Storable.xs", line 4176: warning #4276-D: relational operator ">" always evaluates to 'false'
          WRITE(classname, len);	/* Final \0 is omitted */
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
          STORE_SCALAR(buf, len);
          ^

"Storable.xs", line 4425: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    PUTMARK(SX_OBJECT);
  	    ^

"Storable.xs", line 4426: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    WRITE_I32(ltagval);
  	    ^

"Storable.xs", line 4560: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE( (unsigned char*) header, length);
      ^

"Storable.xs", line 4819: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(10003, classname, len+1, char);
          ^

"Storable.xs", line 5022: warning #4276-D: relational operator ">" always evaluates to 'false'
              New(10003, classname, len+1, char);
              ^

"Storable.xs", line 5913: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(10003, s, len+1, char);
      ^

"Storable.xs", line 6473: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);	/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 6607: warning #4276-D: relational operator ">" always evaluates to 'false'
              KBUFCHK((STRLEN)size);/* Grow hash key read pool if needed */
              ^

"Storable.xs", line 6978: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);			/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 7353: warning #4276-D: relational operator ">" always evaluates to 'false'
              KBUFCHK((STRLEN)len);	/* Grow buffer as necessary */
              ^

"HiRes.c", line 2338: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1202: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1261: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1306: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.c", line 1347: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Piece.xs", line 995: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(0, buf, bufsize, char);
          ^

"Piece.xs", line 1007: warning #4276-D: relational operator ">" always evaluates to 'false'
              Renew(buf, bufsize, char);
              ^

"Collate.xs", line 458: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    New(0, eachlevel[lv], 2 * (1 + buf_len) + 1, U8);
  	    ^

"Collate.xs", line 601: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(v, d, vlen, U8);
      ^

Making header files for XS...
"Normalize.xs", line 253: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Renew_d_if_not_enough_to(UTF8_MAXLEN * 3)
  	    ^

"Normalize.xs", line 261: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(len)
  		^

"Normalize.xs", line 266: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 331: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 338: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Renew_d_if_not_enough_to(UTF8_MAXLEN)
  	    ^

"Normalize.xs", line 384: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 443: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Renew_d_if_not_enough_to(UTF8_MAXLEN)
  	    ^

"Normalize.xs", line 451: warning #4276-D: relational operator ">" always evaluates to 'false'
  		Renew_d_if_not_enough_to(UTF8_MAXLEN)
  		^

"Normalize.xs", line 480: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 502: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 526: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 551: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, t, tlen+1, U8);
      ^

"Normalize.xs", line 558: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"Normalize.xs", line 591: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, t, tlen+1, U8);
      ^

"Normalize.xs", line 598: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, u, ulen+1, U8);
      ^

"Normalize.xs", line 605: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(0, d, dlen+1, U8);
      ^

"APItest.c", line 2071: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2090: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2115: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2133: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2151: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2169: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2187: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2205: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2223: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2241: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2259: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2277: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2819: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 2838: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3013: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3209: warning #3215-D: function "Perl_ptr_table_clear" (declared at line 2744 of "../../proto.h") was declared deprecated
  	ptr_table_clear(table);
  	^

"APItest.c", line 3658: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3680: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3702: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3724: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3745: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3766: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3787: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 3808: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4684: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4803: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4829: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4876: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 4897: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"APItest.c", line 5015: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"APItest.c", line 6177: warning #2128-D: loop is not reachable
      XSRETURN_EMPTY;
      ^

"APItest.c", line 6243: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"APItest.xs", line 6439: warning #3215-D: function "Perl_to_utf8_lower" (declared at line 3760 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_lower(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6529: warning #3215-D: function "Perl_to_utf8_fold" (declared at line 3753 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_fold(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6619: warning #3215-D: function "Perl_to_utf8_upper" (declared at line 3774 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_upper(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6702: warning #3215-D: function "Perl_to_utf8_title" (declared at line 3767 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_title(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6147: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s, (U8 *) copy + offset, len, U8);
          ^

"APItest.xs", line 6162: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s, (U8 *) copy + offset, len, U8);
          ^

"XSUB-undef-XS_VERSION.c", line 186: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"XSUB-redefined-macros.c", line 189: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"XSUB-redefined-macros.c", line 208: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Typemap.c", line 1529: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Typemap.c", line 1593: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"Typemap.c", line 1691: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

"attributes.c", line 314: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"attributes.c", line 418: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"attributes.c", line 457: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 493: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 526: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 562: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 642: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 665: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"mro.c", line 920: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

"re_exec.c", line 505: warning #2111-D: statement is unreachable
      return FALSE; /* Things like CNTRL are always below 256 */
      ^

"re_exec.c", line 2227: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              REXEC_FBC_CLASS_SCAN(0, ANYOF_BITMAP_TEST(c, *((U8*)s)));
              ^

"re_exec.c", line 2233: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          REXEC_FBC_FIND_NEXT_SCAN(0,
          ^

"re_exec.c", line 2872: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_ac_data *aho = (reg_ac_data*)progi->data->data[ ARG( c ) ];
                                                                  ^

"re_exec.c", line 2910: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                      bitmap=(U8*)ANYOF_BITMAP(c);
                                  ^

"re_exec.c", line 4356: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                  ^

"re_exec.c", line 5835: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5841: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5877: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              if(!NEXTCHR_IS_EOS && !ANYOF_BITMAP_TEST(scan, nextchr)) {
                                     ^

"re_exec.c", line 5883: warning #2111-D: statement is unreachable
                  NOT_REACHED; /* NOTREACHED */
                  ^

"re_exec.c", line 5937: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          	    = (reg_trie_data*)rexi->data->data[ ARG( scan ) ];
          	                                        ^

"re_exec.c", line 5938: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		HV * widecharmap = MUTABLE_HV(rexi->data->data[ ARG( scan ) + 1 ]);
  		                   ^

"re_exec.c", line 6083: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 6113: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = ((reg_trie_data*)rexi->data->data[ARG(ST.me)])->wordinfo;
  		                                        ^

"re_exec.c", line 6137: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = (reg_trie_data*)rexi->data->data[ARG(ST.me)];
  		                                       ^

"re_exec.c", line 6200: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 6203: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    DEBUG_EXECUTE_r({
  	    ^

"re_exec.c", line 6702: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (!REGINCLASS(rex, scan, (U8*)locinput, utf8_target))
  		     ^

"re_exec.c", line 6709: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (NEXTCHR_IS_EOS || (UCHARAT(locinput) & FLAGS(scan)) != ARG(scan)) {
                                                                         ^

"re_exec.c", line 7041: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7108: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              arg= (U32)ARG(scan);
                        ^

"re_exec.c", line 7120: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              startpoint = scan + ARG2L(scan);
                                  ^

"re_exec.c", line 7181: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		n = ARG(scan);
  		    ^

"re_exec.c", line 7417: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                                      ARG2L(scan),
                                      ^

"re_exec.c", line 7484: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7567: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7602: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7624: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_yes_mark = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                                ^

"re_exec.c", line 7625: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              if (ARG2L(scan)){
                  ^

"re_exec.c", line 7632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          n = ARG(cursor);
                              ^

"re_exec.c", line 7638: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              if ( n == ARG(scan) || EVAL_CLOSE_PAREN_IS(cur_eval, n) )
                                        ^

"re_exec.c", line 7648: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ARG(scan);  /* which paren pair */
  	        ^

"re_exec.c", line 7658: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              n = ARG(scan);
                  ^

"re_exec.c", line 7673: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next = scan + ARG(scan);
  		              ^

"re_exec.c", line 7775: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next += ARG(next);
  		        ^

"re_exec.c", line 7797: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7803: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7809: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7845: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7953: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7964: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7968: warning #2111-D: statement is unreachable
  	NOT_REACHED; /* NOTREACHED */
  	^

"re_exec.c", line 7974: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7981: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7991: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8016: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8047: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8053: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ARG(scan);
  	                  ^

"re_exec.c", line 8072: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8076: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  ? MUTABLE_SV(rexi->data->data[ ARG( scan ) ])
                    ^

"re_exec.c", line 8079: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8087: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8091: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8156: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8204: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		if (HAS_TEXT(ST.B) || JUMPABLE(ST.B)) {
  		                      ^

"re_exec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			FIND_NEXT_IMPT(text_node);
  			^

"re_exec.c", line 8207: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			FIND_NEXT_IMPT(text_node);
  			^

"re_exec.c", line 8285: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8368: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (! HAS_TEXT(next) && ! JUMPABLE(next)) {
                                        ^

"re_exec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    FIND_NEXT_IMPT(text_node);
  		    ^

"re_exec.c", line 8375: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    FIND_NEXT_IMPT(text_node);
  		    ^

"re_exec.c", line 8463: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8566: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8596: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8624: warning #2111-D: statement is unreachable
  		    NOT_REACHED; /* NOTREACHED */
  		    ^

"re_exec.c", line 8728: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    next = scan + ARG(scan);
  		                  ^

"re_exec.c", line 8745: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8763: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    scan = ST.me + ARG(ST.me);
  	                   ^

"re_exec.c", line 8772: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ARG(scan);
  	                  ^

"re_exec.c", line 8783: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        sv_yes_mark = sv_commit = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
  	                                  ^

"re_exec.c", line 8785: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8791: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8795: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_commit = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                              ^

"re_exec.c", line 8805: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8811: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                    ^

"re_exec.c", line 8815: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8820: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8840: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8853: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  SV *find = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
                             ^

"re_exec.c", line 8885: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 9382: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	    while (scan < loceol && ANYOF_BITMAP_TEST(p, *((U8*)scan)))
  	                            ^

"re_exec.c", line 9396: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          scan = (char *) find_span_end_mask((U8 *) scan, (U8 *) loceol, (U8) ARG(p), FLAGS(p));
                                                                              ^

"re_exec.c", line 9712: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	if (ANYOF_BITMAP_TEST(n, c))
  	    ^

"re_exec.c", line 9725: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		&& ANYOF_BITMAP_TEST(n, PL_fold_locale[c]))
  		   ^

"re_exec.c", line 9729: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
              else if (ANYOF_POSIXL_TEST_ANY_SET(n)
                       ^

"re_exec.c", line 9767: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      if (ANYOF_POSIXL_TEST(n, count)
                          ^

"re_exec.c", line 9799: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	else if (    ARG(n) != ANYOF_ONLY_HAS_BITMAP
  	             ^

"re_exec.c", line 3200: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(strbeg + min, prog->subbeg, sublen, char);
              ^

"re_exec.c", line 4452: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c1_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 4453: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c2_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 7909: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    Renew(aux->poscache, size, char);
  			    ^

"re_exec.c", line 7912: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Zero(aux->poscache, size, char);
  			^

"re_exec.c", line 7916: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Newxz(aux->poscache, size, char);
  			^

"re_comp.c", line 3486: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    ARG_SET( convert, data_slot );
  	    ^

"re_comp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
                                      ^

"re_comp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
                                      ^

"re_comp.c", line 3616: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U32 trie_offset = ARG(source);
                              ^

"re_comp.c", line 3641: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          StructCopy(source,op,struct regnode_1);
          ^

"re_comp.c", line 3646: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
          StructCopy(source,op,struct regnode_charclass);
          ^

"re_comp.c", line 3651: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      ARG_SET( stclass, data_slot );
      ^

"re_comp.c", line 4206: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      I32 is_par = OP(scan) == OPEN ? ARG(scan) : 0;
                                      ^

"re_comp.c", line 4287: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    int off = (reg_off_by_arg[OP(scan)] ? ARG(scan) : NEXT_OFF(scan));
  	                                          ^

"re_comp.c", line 4294: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((OP(n) == LONGJMP) && (noff = ARG(n))))
  		                                         ^

"re_comp.c", line 4298: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		ARG(scan) = off;
  		^

"re_comp.c", line 4815: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  paren = ARG(scan);
                          ^

"re_comp.c", line 4816: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  RExC_recurse[ARG2L(scan)] = scan;
                               ^

"re_comp.c", line 5219: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          RExC_open_parens[ARG(nxt1)]=oscan; /*open->CURLYM*/
                                           ^

"re_comp.c", line 5220: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          RExC_close_parens[ARG(nxt1)]=nxt+2; /*close->while*/
                                            ^

"re_comp.c", line 5223: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    oscan->flags = (U8)ARG(nxt);
  		                       ^

"re_comp.c", line 5264: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			oscan->flags = (U8)ARG(nxt);
  			                   ^

"re_comp.c", line 5266: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_open_parens[ARG(nxt1)]=oscan; /*open->CURLYM*/
                                               ^

"re_comp.c", line 5267: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_close_parens[ARG(nxt1)]=nxt2+1; /*close->NOTHING*/
                                                ^

"re_comp.c", line 5312: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			nxt += ARG(nxt);
  			       ^

"re_comp.c", line 5548: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                                  (regnode_charclass *) scan);
                                  ^

"re_comp.c", line 5551: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                                                            (regnode_charclass *) scan);
                                                            ^

"re_comp.c", line 5855: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen != (I32)ARG(scan))
  	                          ^

"re_comp.c", line 5859: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen == (I32)ARG(scan)) {
  	                          ^

"re_comp.c", line 5862: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if ((I32)ARG(scan) == is_par) {
  	             ^

"re_comp.c", line 5869: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		*(data->last_closep) = ARG(scan);
  		                       ^

"re_comp.c", line 5918: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
                                                                          ^

"re_comp.c", line 6117: warning #2111-D: statement is unreachable
      NOT_REACHED; /* NOTREACHED */
      ^

"re_comp.c", line 7514: warning #2187-D: use of "=" where "==" may have been intended
  	while ((OP(first) == OPEN && (sawopen = 1)) ||
  	                             ^

"re_comp.c", line 7518: warning #2187-D: use of "=" where "==" may have been intended
  	    (OP(first) == IFMATCH && !first->flags && (sawlookahead = 1)) ||
  	                                              ^

"re_comp.c", line 7554: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        ((reg_trie_data *)ri->data->data[ ARG(first) ])->minlen>0)
  	                                          ^

"re_comp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          ARG2L_SET( scan, RExC_open_parens[ARG(scan)] - scan );
          ^

"re_comp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          ARG2L_SET( scan, RExC_open_parens[ARG(scan)] - scan );
          ^

"re_comp.c", line 11020: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      ARG(ret) = add_data( pRExC_state,
                      ^

"re_comp.c", line 11022: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      RExC_rxi->data->data[ARG(ret)]=(void*)sv;
                                           ^

"re_comp.c", line 11028: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      ARG2L_SET(ret, internal_argval);
                      ^

"re_comp.c", line 11301: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
                      ^

"re_comp.c", line 11301: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
                      ^

"re_comp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ANYOF_BITMAP_ZERO(node);
      ^

"re_comp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ANYOF_BITMAP_ZERO(node);
      ^

"re_comp.c", line 14382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (! ANYOF_BITMAP_TEST(node, i)) {
  		      ^

"re_comp.c", line 14383: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		    ANYOF_BITMAP_SET(node, i);
  		    ^

"re_comp.c", line 17142: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      ANYOF_POSIXL_ZERO(ret);
                      ^

"re_comp.c", line 17159: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      && ANYOF_POSIXL_TEST(ret, namedclass + ((namedclass % 2)
                         ^

"re_comp.c", line 17170: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                  ANYOF_POSIXL_SET(ret, namedclass);
                  ^

"re_comp.c", line 18705: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(node, ANYOF_ONLY_HAS_BITMAP);
  	^

"re_comp.c", line 18736: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(node, n);
  	^

"re_comp.c", line 19174: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          FILL_ADVANCE_NODE_ARG(ptr, op, arg);
          ^

"re_comp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2);
          ^

"re_comp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2);
          ^

"re_comp.c", line 19348: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          ARG_SET(scan, val - scan);
          ^

"re_comp.c", line 19446: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(scan, val - scan);
  	^

"re_comp.c", line 19463: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U8 lowest = (U8) ARG(n);
                             ^

"re_comp.c", line 19473: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ((i & FLAGS(n)) == ARG(n)) {
                                ^

"re_comp.c", line 19746: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          const U32 n = ARG(o);
                        ^

"re_comp.c", line 19770: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              (void) put_charclass_bitmap_innards(sv,
                     ^

"re_comp.c", line 19798: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          U32 parno= OP(o) == ACCEPT ? (U32)ARG2L(o) : ARG(o);
                                            ^

"re_comp.c", line 19798: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          U32 parno= OP(o) == ACCEPT ? (U32)ARG2L(o) : ARG(o);
                                                       ^

"re_comp.c", line 19826: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              U32 n = ARG(o);  /* which paren pair */
                      ^

"re_comp.c", line 19848: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          Perl_sv_catpvf(aTHX_ sv, "%d[%+d:%d]", (int)ARG(o),(int)ARG2L(o),
                                                      ^

"re_comp.c", line 19848: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          Perl_sv_catpvf(aTHX_ sv, "%d[%+d:%d]", (int)ARG(o),(int)ARG2L(o),
                                                                  ^

"re_comp.c", line 19849: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  (int)((o + (int)ARG2L(o)) - progi->program) );
                                  ^

"re_comp.c", line 19851: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              SV **name= av_fetch(name_list, ARG(o), 0 );
                         ^

"re_comp.c", line 19887: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if (ARG(o) != ANYOF_ONLY_HAS_BITMAP) {
              ^

"re_comp.c", line 19917: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
          do_sep = put_charclass_bitmap_innards(sv,
                   ^

"re_comp.c", line 20055: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ( ARG(o) )
               ^

"re_comp.c", line 20057: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                         SVfARG((MUTABLE_SV(progi->data->data[ ARG( o ) ]))));
                         ^

"re_comp.c", line 21157: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
              if (ANYOF_POSIXL_TEST_ANY_SET(node)) {
                  ^

"re_comp.c", line 21162: warning #4232-D: conversion from "const regnode *const" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      if (ANYOF_POSIXL_TEST(node,i)) {
                          ^

"re_comp.c", line 21394: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              const U32 n = ARG(node);
                            ^

"re_comp.c", line 3913: warning #4276-D: relational operator ">" always evaluates to 'false'
              Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
              ^

"re_comp.c", line 3977: warning #4276-D: relational operator ">" always evaluates to 'false'
                  Newx(folded, UTF8_MAX_FOLD_CHAR_EXPAND * STR_LEN(scan) + 1, U8);
                  ^

"re_comp.c", line 3982: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 4863: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Zero(RExC_study_chunk_recursed, RExC_study_chunk_recursed_bytes, U8);
                          ^

"re_comp.c", line 4865: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(RExC_study_chunk_recursed + ((recursed_depth-1) * RExC_study_chunk_recursed_bytes),
                          ^

"re_comp.c", line 6127: warning #4276-D: relational operator ">" always evaluates to 'false'
      Renewc(RExC_rxi->data,
      ^

"re_comp.c", line 6131: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Renew(RExC_rxi->data->what, count + n, U8);
  	^

"re_comp.c", line 6133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(RExC_rxi->data->what, n, U8);
  	^

"re_comp.c", line 6135: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(s, RExC_rxi->data->what + count, n, U8);
      ^

"re_comp.c", line 6312: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newx(dst, *plen_p * 2 + 1, U8);
      ^

"re_comp.c", line 6672: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(newpat, newlen, char);
  	^

"re_comp.c", line 7278: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newxc(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode),
      ^

"re_comp.c", line 7284: warning #4276-D: relational operator ">" always evaluates to 'false'
      Zero(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode),
      ^

"re_comp.c", line 7347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    Copy(name, p, len, char);
  	    ^

"re_comp.c", line 7362: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(RExC_precomp, p, plen, char);
          ^

"re_comp.c", line 7427: warning #4276-D: relational operator ">" always evaluates to 'false'
          Newx(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 7455: warning #4276-D: relational operator ">" always evaluates to 'false'
          Zero(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 9975: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(SvPVX(invlist), SvPVX(new_invlist), physical_length, char);
      ^

"re_comp.c", line 12729: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy((char *) character, STRING(node), len, char);
              ^

"re_comp.c", line 20656: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat1, buf, l1 , char);
      ^

"re_comp.c", line 20657: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat2, buf + l1, l2 , char);
      ^

"re_comp.c", line 20666: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(message, buf, l1 , char);
      ^

"re.c", line 296: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

[2018-08-09 23:55:35+0200] Skip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2018-08-09 23:55:35+0200] 
[2018-08-09 23:55:35+0200]  Tests start here:
[2018-08-09 23:55:35+0200] TSTENV = stdio	
No saved state, selection will be empty
Subroutine Math::BigInt::carp redefined at t/option_l.t line 16.
Cannot figure out an encoding to use at t/use-Encode-Alias.t line 5.
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
# Connected to 127.0.0.1
# Connected to 127.0.0.1
Integer overflow in hexadecimal number at t/broken_univ_can.t line 7.
Redefining sub xChild::foo at xChild--6954 line 2.
Redefining sub Data::ok at -e line 1.
c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

# Will use Digest::MD5
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
[2018-08-10 00:09:14+0200] 
[2018-08-10 00:09:14+0200] All tests successful.
[2018-08-10 00:09:14+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2018-08-10 00:09:14+0200]     9, 18
[2018-08-10 00:09:14+0200] Archived results...
[2018-08-10 00:09:14+0200] TSTENV = perlio	
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
Cannot figure out an encoding to use at t/use-Encode-Alias.t line 5.
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

Subroutine Math::BigInt::carp redefined at t/option_l.t line 16.
# Will use Digest::MD5
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
Integer overflow in hexadecimal number at t/broken_univ_can.t line 7.
# Connected to 127.0.0.1
# Connected to 127.0.0.1
[2018-08-10 00:20:59+0200] 
[2018-08-10 00:20:59+0200] All tests successful.
[2018-08-10 00:20:59+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2018-08-10 00:20:59+0200]     9, 18
[2018-08-10 00:20:59+0200] Archived results...
[2018-08-10 00:20:59+0200] TSTENV = locale:en_US.utf8	
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

Subroutine Math::BigInt::carp redefined at t/option_l.t line 16.
# Will use Digest::MD5
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
recv() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at (eval 12) line 28.
Integer overflow in hexadecimal number at t/broken_univ_can.t line 7.
# Connected to 127.0.0.1
syswrite() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 47.
sysread() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 51.
# Connected to 127.0.0.1
syswrite() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 86.
sysread() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at t/Socket.t line 90.
[2018-08-10 00:32:58+0200] 
[2018-08-10 00:32:58+0200] All tests successful.
[2018-08-10 00:32:58+0200] ../lib/B/Deparse.t..........................................PASSED
[2018-08-10 00:32:58+0200]     2
[2018-08-10 00:32:58+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2018-08-10 00:32:58+0200]     9, 18
[2018-08-10 00:32:58+0200] Archived results...
[2018-08-10 00:32:58+0200] Unskip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2018-08-10 00:32:58+0200] 
[2018-08-10 00:32:58+0200] Configuration: -Dusedevel -Duse64bitall
[2018-08-10 00:32:58+0200] ------------------------------------------------------------------------------
[2018-08-10 00:32:58+0200] make distclean ...
[2018-08-10 00:33:39+0200] 
[2018-08-10 00:33:39+0200] Copy Policy.sh ...
[2018-08-10 00:33:39+0200] 
[2018-08-10 00:33:39+0200] Configure ...
5.29.2 <=> 5.026002
===== PROCURA Policy for hpux/ccache cc ========================
===== PROCURA Policy results ============================
cc:         ccache cc
ccversion:  -
gccversion: -
ccflags:     +Z -z
optimize:   
ld:         
ldflags:    -L/pro/local/lib
libswanted: cl pthread cl pthread socket bind inet nsl ndbm gdbm dbm db malloc dl ld sun m crypt sec util c cposix posix ucb bsd BSD
libsdirs:    /lib /pro/local/lib
locincpth:  /pro/local/include
loclibpth:  /pro/local/lib
useshrplib: 
===== PROCURA Policy done ===============================
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
[2018-08-10 00:35:00+0200] 
[2018-08-10 00:35:00+0200] make ...
"op.c", line 12320: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

"op.c", line 12996: warning #2111-D: statement is unreachable
  	} ((void)0);  
  	  ^

"op.c", line 15228: warning #2549-D: variable "defer_queue" is used before its value is set
                          defer_queue[(defer_base + defer_ix--) % 4];
                          ^

"op.c", line 16274: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"op.c", line 3183: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l)))) ? (size_t)(l) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)(argp->p), (l) * sizeof(char)));
                                                                                                                                                                                        ^

"op.c", line 5143: warning #4276-D: relational operator ">" always evaluates to 'false'
      PL_compiling.cop_warnings = (((PL_compiling . cop_warnings) == 0L || (PL_compiling . cop_warnings) == (((STRLEN*)0)+1) || (PL_compiling . cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_compiling . cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings)))) ? (size_t)(sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings))),(const char*)(PL_compiling . cop_warnings), (sizeof(*PL_compiling . cop_warnings)+ *PL_compiling . cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 8048: warning #4276-D: relational operator ">" always evaluates to 'false'
      cop->cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ^

"op.c", line 10502: warning #4276-D: relational operator ">" always evaluates to 'false'
  	 PL_compiling.cop_warnings = (((PL_curcop->cop_warnings) == 0L || (PL_curcop->cop_warnings) == (((STRLEN*)0)+1) || (PL_curcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(PL_curcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings)))) ? (size_t)(sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings))),(const char*)(PL_curcop->cop_warnings), (sizeof(*PL_curcop->cop_warnings)+ *PL_curcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"op.c", line 12436: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(end - s - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(end - s - 1)))) ? (size_t)(end - s - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(s+1),(const char*)(s+2), (end - s - 1) * sizeof(char)));
  		                                                                                                                                                                                                        ^

"op.c", line 12605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf+1),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"perl.c", line 3496: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

"gv.c", line 118: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(tmpbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen)))) ? (size_t)(tmplen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"gv.c", line 1464: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(tmpbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen)))) ? (size_t)(tmplen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"gv.c", line 1465: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(namelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(namelen)))) ? (size_t)(namelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf),(const char*)(name), (namelen) * sizeof(char)));
                                                                                                                                                                                              ^

"gv.c", line 1657: warning #4276-D: relational operator ">" always evaluates to 'false'
                              (tmpfullbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(full_len+2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(full_len+2)))) ? (size_t)(full_len+2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((full_len+2)*sizeof(char))))));
                                                                                                                                                                                                                                             ^

"gv.c", line 1660: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*len)))) ? (size_t)(*len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf),(const char*)(*name), (*len) * sizeof(char)));
                                                                                                                                                                                                     ^

"toke.c", line 1036: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(bufptr+len+highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1062: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(bufptr+len-highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1082: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-bufptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-bufptr)))) ? (size_t)(PL_parser->bufend+1-bufptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(bufptr+len),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1085: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bufptr),(const char*)(pv), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 1180: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufend+1-ptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufend+1-ptr)))) ? (size_t)(bufend+1-ptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(buf),(const char*)(ptr), (bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                             ^

"toke.c", line 1258: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_parser->bufend+1-ptr) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_parser->bufend+1-ptr)))) ? (size_t)(PL_parser->bufend+1-ptr) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(buf),(const char*)(ptr), (PL_parser->bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                                                              ^

"toke.c", line 1810: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (tmpbuf2 = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tmplen2 + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tmplen2 + 2)))) ? (size_t)(tmplen2 + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((tmplen2 + 2)*sizeof(char))))));
  		                                                                                                                                                                                                                   ^

"toke.c", line 3718: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(e - orig_s + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(e - orig_s + 1)))) ? (size_t)(e - orig_s + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(orig_s), (e - orig_s + 1) * sizeof(char)));
                                                                                                                                                                                                                                       ^

"toke.c", line 3809: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(initial_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(initial_len)))) ? (size_t)(initial_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(initial_text), (initial_len) * sizeof(char)));
                                                                                                                                                                                                                                      ^

"toke.c", line 3860: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_length)))) ? (size_t)(output_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                            ^

"toke.c", line 3881: warning #4276-D: relational operator ">" always evaluates to 'false'
                                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(output_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(output_length)))) ? (size_t)(output_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                                ^

"toke.c", line 3950: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(str), (len) * sizeof(char)));
  			                                                                                                                                                                            ^

"toke.c", line 4031: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                      ^

"toke.c", line 4093: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                              ^

"toke.c", line 4837: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  			                                                                                                                                                                                                                                                                                            ^

"toke.c", line 4916: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((PL_parser->lex_casestack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_casemods) + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_casemods) + 2)))) ? (size_t)((PL_parser->lex_casemods) + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_casestack)),(size_t)(((PL_parser->lex_casemods) + 2)*sizeof(char))))));
  		                                                                                                                                                                                                                                                                                            ^

"toke.c", line 5036: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                              ^

"toke.c", line 5887: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                ^

"toke.c", line 6137: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                ^

"toke.c", line 7179: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf+1),(const char*)((PL_parser->tokenbuf)), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 7774: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(olen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(olen)))) ? (size_t)(olen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((PL_parser->tokenbuf)),(const char*)((PL_parser->bufptr)), (olen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"toke.c", line 9163: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s - w) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s - w)))) ? (size_t)(s - w) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpbuf+1),(const char*)(w), (s - w) * sizeof(char)));
  		                                                                                                                                                                                  ^

"toke.c", line 9342: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(t - *s) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(t - *s)))) ? (size_t)(t - *s) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(*d),(const char*)(*s), (t - *s) * sizeof(char)));
                                                                                                                                                                                                   ^

"toke.c", line 9376: warning #4276-D: relational operator ">" always evaluates to 'false'
          (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*s - olds + saw_tick + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*s - olds + saw_tick + 2)))) ? (size_t)(*s - olds + saw_tick + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((*s - olds + saw_tick + 2)*sizeof(char))))));  
                                                                                                                                                                                                                                                          ^

"toke.c", line 10031: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"toke.c", line 10151: warning #4276-D: relational operator ">" always evaluates to 'false'
  			(indent = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(indent_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(indent_len + 1)))) ? (size_t)(indent_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((indent_len + 1)*sizeof(char))))));
  			                                                                                                                                                                                                                       ^

"toke.c", line 10203: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufend-s + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufend-s + 1)))) ? (size_t)(bufend-s + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (bufend-s + 1) * sizeof(char)));
  	                                                                                                                                                                                                       ^

"toke.c", line 10287: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    (indent = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(indent_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(indent_len + 1)))) ? (size_t)(indent_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((indent_len + 1)*sizeof(char))))));
  		                                                                                                                                                                                                                           ^

"toke.c", line 10367: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { const STRLEN _lEnGtH = ((XPV*) (tmpstr)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (tmpstr)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((tmpstr))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((tmpstr)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"toke.c", line 10647: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(termlen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(termlen)))) ? (size_t)(termlen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(termstr),(const char*)(s), (termlen) * sizeof(U8)));
  	                                                                                                                                                                                    ^

"toke.c", line 10816: warning #4276-D: relational operator ">" always evaluates to 'false'
  	do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len)))))); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"toke.c", line 12245: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((PL_parser->lex_brackstack) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((PL_parser->lex_brackets) + 10) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((PL_parser->lex_brackets) + 10)))) ? (size_t)((PL_parser->lex_brackets) + 10) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)((PL_parser->lex_brackstack)),(size_t)(((PL_parser->lex_brackets) + 10)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                            ^

"pad.c", line 2746: warning #4276-D: relational operator ">" always evaluates to 'false'
      (alloc2 = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1)))) ? (size_t)(((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((size_t)((char *)&((struct padname_with_str *)0)->xpadn_str[0] - (char *)0)) + len + 1),sizeof(char)))));
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^

"pad.c", line 2753: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((pn)->xpadn_pv),(const char*)(s), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"regcomp.c", line 1625: warning #4232-D: conversion from "const regnode_charclass *" to a more strictly aligned type "regnode_ssc *" may cause misaligned access
          anded_cp_list = ((regnode_ssc *)and_with)->invlist;
                           ^

"regcomp.c", line 1643: warning #4232-D: conversion from "const regnode_charclass *" to a more strictly aligned type "regnode_ssc *" may cause misaligned access
          if (S_ssc_is_anything((regnode_ssc *)and_with)) {
                                ^

"regcomp.c", line 1758: warning #4232-D: conversion from "const regnode_charclass *" to a more strictly aligned type "regnode_ssc *" may cause misaligned access
               || ! S_ssc_is_cp_posixl_init(pRExC_state, (regnode_ssc *)and_with))
                                                         ^

"regcomp.c", line 1764: warning #4232-D: conversion from "const regnode_charclass *" to a more strictly aligned type "regnode_ssc *" may cause misaligned access
                  (*((regnode_ssc*)(ssc)) = *((regnode_ssc*)(and_with)));
                                              ^

"regcomp.c", line 1807: warning #4232-D: conversion from "const regnode_charclass *" to a more strictly aligned type "regnode_ssc *" may cause misaligned access
          ored_cp_list = ((regnode_ssc*) or_with)->invlist;
                          ^

"regcomp.c", line 3486: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    (((((struct regnode_1 *)convert)->arg1)) = ((data_slot)));
  	        ^

"regcomp.c", line 3504: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(((struct regnode_charclass *)convert)->bitmap),(const char*)(trie ->bitmap), (((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                                                    ^

"regcomp.c", line 3616: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U32 trie_offset = ((((struct regnode_1 *)source)->arg1));
                                 ^

"regcomp.c", line 3641: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (*((struct regnode_1*)(op)) = *((struct regnode_1*)(source)));
                                          ^

"regcomp.c", line 3646: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_charclass *" may cause misaligned access
          (*((struct regnode_charclass*)(op)) = *((struct regnode_charclass*)(source)));
                                                  ^

"regcomp.c", line 3651: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      (((((struct regnode_1 *)stclass)->arg1)) = ((data_slot)));
          ^

"regcomp.c", line 4206: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      I32 is_par = ((scan)->type) == 52 ? ((((struct regnode_1 *)scan)->arg1)) : 0;
                                             ^

"regcomp.c", line 4287: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    int off = (reg_off_by_arg[((scan)->type)] ? ((((struct regnode_1 *)scan)->arg1)) : ((scan)->next_off));
  	                                                   ^

"regcomp.c", line 4294: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((((n)->type) == 66) && (noff = ((((struct regnode_1 *)n)->arg1)))))
  		                                             ^

"regcomp.c", line 4298: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		((((struct regnode_1 *)scan)->arg1)) = off;
  		   ^

"regcomp.c", line 4815: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  paren = ((((struct regnode_1 *)scan)->arg1));
                             ^

"regcomp.c", line 4816: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  (pRExC_state ->recurse)[((((struct regnode_2L *)scan)->arg2))] = scan;
                                             ^

"regcomp.c", line 5219: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          (pRExC_state ->open_parens)[((((struct regnode_1 *)nxt1)->arg1))]=oscan;  
                                                         ^

"regcomp.c", line 5220: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          (pRExC_state ->close_parens)[((((struct regnode_1 *)nxt1)->arg1))]=nxt+2;  
                                                          ^

"regcomp.c", line 5223: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    oscan->flags = (U8)((((struct regnode_1 *)nxt)->arg1));
  		                          ^

"regcomp.c", line 5264: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			oscan->flags = (U8)((((struct regnode_1 *)nxt)->arg1));
  			                      ^

"regcomp.c", line 5266: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              (pRExC_state ->open_parens)[((((struct regnode_1 *)nxt1)->arg1))]=oscan;  
                                                             ^

"regcomp.c", line 5267: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              (pRExC_state ->close_parens)[((((struct regnode_1 *)nxt1)->arg1))]=nxt2+1;  
                                                              ^

"regcomp.c", line 5312: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			nxt += ((((struct regnode_1 *)nxt)->arg1));
  			          ^

"regcomp.c", line 5547: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  			S_ssc_and( pRExC_state,data->start_class,(regnode_charclass *) scan);
  			                                         ^

"regcomp.c", line 5550: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  			S_ssc_or( pRExC_state,data->start_class,(regnode_charclass *) scan);
  			                                        ^

"regcomp.c", line 5855: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen != (I32)((((struct regnode_1 *)scan)->arg1)))
  	                             ^

"regcomp.c", line 5859: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if (stopparen == (I32)((((struct regnode_1 *)scan)->arg1))) {
  	                             ^

"regcomp.c", line 5862: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    if ((I32)((((struct regnode_1 *)scan)->arg1)) == is_par) {
  	                ^

"regcomp.c", line 5869: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		*(data->last_closep) = ((((struct regnode_1 *)scan)->arg1));
  		                          ^

"regcomp.c", line 5918: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_trie_data *trie = (reg_trie_data*)(pRExC_state ->rxi)->data->data[ ((((struct regnode_1 *)scan)->arg1)) ];
                                                                                        ^

"regcomp.c", line 6117: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"regcomp.c", line 7514: warning #2187-D: use of "=" where "==" may have been intended
  	while ((((first)->type) == 52 && (sawopen = 1)) ||
  	                                 ^

"regcomp.c", line 7518: warning #2187-D: use of "=" where "==" may have been intended
  	    (((first)->type) == 68 && !first->flags && (sawlookahead = 1)) ||
  	                                               ^

"regcomp.c", line 7554: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	        ((reg_trie_data *)ri->data->data[ ((((struct regnode_1 *)first)->arg1)) ])->minlen>0)
  	                                             ^

"regcomp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          (((((struct regnode_2L *)scan)->arg2)) = (((pRExC_state ->open_parens)[((((struct regnode_1 *)scan)->arg1))] - scan)));
              ^

"regcomp.c", line 7925: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (((((struct regnode_2L *)scan)->arg2)) = (((pRExC_state ->open_parens)[((((struct regnode_1 *)scan)->arg1))] - scan)));
                                                                                    ^

"regcomp.c", line 11020: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      ((((struct regnode_1 *)ret)->arg1)) = S_add_data( pRExC_state,
                         ^

"regcomp.c", line 11022: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      (pRExC_state ->rxi)->data->data[((((struct regnode_1 *)ret)->arg1))]=(void*)sv;
                                                         ^

"regcomp.c", line 11028: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                      (((((struct regnode_2L *)ret)->arg2)) = ((internal_argval)));
                          ^

"regcomp.c", line 14352: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((1 << 8) / 8)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((1 << 8) / 8))))) ? (size_t)(((1 << 8) / 8)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(((regnode_charclass*)(node))->bitmap),0,(((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                             ^

"regcomp.c", line 14382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (! (((( (U8*) ((regnode_charclass*)(node))->bitmap) [ ( ( (UV) (i)) >> 3) ] ) & (1U << ((i) & 7))) ? (_Bool)1 : (_Bool)0)) {
  		                  ^

"regcomp.c", line 14383: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		    ((( (U8*) ((regnode_charclass*)(node))->bitmap) [ ( ( (UV) (i)) >> 3) ] ) |= (1U << ((i) & 7)));
  		               ^

"regcomp.c", line 17142: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      do { ((regnode_charclass_posixl*) (ret))->classflags = 0; } while (0);
                            ^

"regcomp.c", line 17159: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                      && (((regnode_charclass_posixl*) (ret))->classflags & (1U << (namedclass + ((namedclass % 2) ? -1 : 1)))))
                           ^

"regcomp.c", line 17170: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
                  (((regnode_charclass_posixl*) (ret))->classflags |= (1U << (namedclass)));
                    ^

"regcomp.c", line 18705: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	(((((struct regnode_1 *)node)->arg1)) = ((((U32) -1))));
  	    ^

"regcomp.c", line 18736: warning #4232-D: conversion from "regnode *const" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	(((((struct regnode_1 *)node)->arg1)) = ((n)));
  	    ^

"regcomp.c", line 18787: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	const U32 n = ((((struct regnode_1 *)node)->arg1));
  	                 ^

"regcomp.c", line 19174: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 1; } while (0);
                   ^

"regcomp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg1))); (((((struct regnode_2L *)ptr)->arg2)) = ((arg2))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 2; } while (0);
                   ^

"regcomp.c", line 19193: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          do { (((((struct regnode_1 *)ptr)->arg1)) = ((arg1))); (((((struct regnode_2L *)ptr)->arg2)) = ((arg2))); do { (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } while (0); (ptr) += 2; } while (0);
                                                                     ^

"regcomp.c", line 19348: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          (((((struct regnode_1 *)scan)->arg1)) = ((val - scan)));
              ^

"regcomp.c", line 19463: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      const U8 lowest = (U8) ((((struct regnode_1 *)n)->arg1));
                                ^

"regcomp.c", line 19473: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          if ((i & ((n)->flags)) == ((((struct regnode_1 *)n)->arg1))) {
                                       ^

"regcomp.c", line 20632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      offset = (reg_off_by_arg[((p)->type)] ? ((((struct regnode_1 *)p)->arg1)) : ((p)->next_off));
                                                 ^

"regcomp.c", line 3913: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((((struct regnode_string *)n)->str_len)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((((struct regnode_string *)n)->str_len))))) ? (size_t)((((struct regnode_string *)n)->str_len)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)((((struct regnode_string *)scan)->string) + oldl),(const char*)((((struct regnode_string *)n)->string)), ((((struct regnode_string *)n)->str_len)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                      ^

"regcomp.c", line 3977: warning #4276-D: relational operator ">" always evaluates to 'false'
                  (folded = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(3 * (((struct regnode_string *)scan)->str_len) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(3 * (((struct regnode_string *)scan)->str_len) + 1)))) ? (size_t)(3 * (((struct regnode_string *)scan)->str_len) + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((3 * (((struct regnode_string *)scan)->str_len) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                 ^

"regcomp.c", line 3982: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s_len)))) ? (size_t)(s_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 3987: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(s_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(s_len)))) ? (size_t)(s_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 4863: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 4865: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((pRExC_state ->study_chunk_recursed) + (recursed_depth * (pRExC_state ->study_chunk_recursed_bytes))),(const char*)((pRExC_state ->study_chunk_recursed) + ((recursed_depth-1) * (pRExC_state ->study_chunk_recursed_bytes))), ((pRExC_state ->study_chunk_recursed_bytes)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 6127: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi)->data = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1))))) ? (size_t)(sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (struct reg_data*)(Perl_safesysrealloc((void *)((pRExC_state ->rxi)->data),(size_t)((sizeof(*(pRExC_state ->rxi)->data) + sizeof(void*) * (count + n - 1))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"regcomp.c", line 6131: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((pRExC_state ->rxi)->data->what = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(count + n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(count + n)))) ? (size_t)(count + n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)((pRExC_state ->rxi)->data->what),(size_t)((count + n)*sizeof(U8))))));
  	                                                                                                                                                                                                                             ^

"regcomp.c", line 6133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((pRExC_state ->rxi)->data->what = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((n)*sizeof(U8))))));
  	                                                                                                                                                                                                     ^

"regcomp.c", line 6135: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((pRExC_state ->rxi)->data->what + count),(const char*)(s), (n) * sizeof(U8)));
                                                                                                                                                                        ^

"regcomp.c", line 6312: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*plen_p * 2 + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*plen_p * 2 + 1)))) ? (size_t)(*plen_p * 2 + 1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((*plen_p * 2 + 1)*sizeof(U8))))));
                                                                                                                                                                                                                         ^

"regcomp.c", line 6672: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(newpat = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(newlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(newlen)))) ? (size_t)(newlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((newlen)*sizeof(char))))));
  	                                                                                                                                                                                               ^

"regcomp.c", line 7278: warning #4276-D: relational operator ">" always evaluates to 'false'
      (ri = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode))))) ? (size_t)(sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (regexp_internal*)(Perl_safesysmalloc((size_t)((sizeof(regexp_internal) + (unsigned)(pRExC_state ->size) * sizeof(regnode))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                             ^

"regcomp.c", line 7347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"regcomp.c", line 7362: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(plen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(plen)))) ? (size_t)(plen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)((pRExC_state ->precomp)), (plen) * sizeof(char)));
                                                                                                                                                                                         ^

"regcomp.c", line 7427: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((pRExC_state ->study_chunk_recursed) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)(((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                                                                    ^

"regcomp.c", line 7455: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->npar)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                                                                            ^

"regcomp.c", line 8708: warning #4276-D: relational operator ">" always evaluates to 'false'
      do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (invlist)->sv_any)->xpv_len_u . xpvlenu_len = ((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))); } while (0); do { ((void)0); ((void)0); ((void)0); (((invlist))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))))) ? (size_t)((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((invlist)->sv_u . svu_pv), (size_t)(((((min_size)>(((XPV*) (invlist)->sv_any)->xpv_cur + 1))?(min_size):(((XPV*) (invlist)->sv_any)->xpv_cur + 1)))))))); } while (0); } while (0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ^

"regcomp.c", line 9975: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(physical_length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(physical_length)))) ? (size_t)(physical_length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(((new_invlist)->sv_u . svu_pv)),(const char*)(((invlist)->sv_u . svu_pv)), (physical_length) * sizeof(char)));
                                                                                                                                                                                                                      ^

"regcomp.c", line 12729: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((((struct regnode_string *)node)->string)),(const char*)((char *) character), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"regcomp.c", line 20656: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l1)))) ? (size_t)(l1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(buf),(const char*)(pat1), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 20657: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l2)))) ? (size_t)(l2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(buf + l1),(const char*)(pat2), (l2) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 20666: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(l1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(l1)))) ? (size_t)(l1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(buf),(const char*)(message), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 21596: warning #4276-D: relational operator ">" always evaluates to 'false'
      (lookup_name = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                                 ^

"dump.c", line 2672: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2681: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2692: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2702: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"dump.c", line 2710: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"util.c", line 4517: warning #2069-D: integer conversion resulted in truncation
      u += 26107 * (U32)(UV)(&when);
                   ^

"util.c", line 1053: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(pvlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(pvlen)))) ? (size_t)(pvlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((pvlen)*sizeof(char))))));
  	                                                                                                                                                                                             ^

"util.c", line 1084: warning #4276-D: relational operator ">" always evaluates to 'false'
      (newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len+1)*sizeof(char))))));
                                                                                                                                                                                                   ^

"util.c", line 1089: warning #4276-D: relational operator ">" always evaluates to 'false'
      	return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(newaddr),(const char*)(pv), (len) * sizeof(char)));
      	                                                                                                                                                                                            ^

"util.c", line 1092: warning #4276-D: relational operator ">" always evaluates to 'false'
  	return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), memset((char*)(newaddr),0,(len+1) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"util.c", line 1170: warning #4276-D: relational operator ">" always evaluates to 'false'
      (newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
                                                                                                                                                                                             ^

"util.c", line 1171: warning #4276-D: relational operator ">" always evaluates to 'false'
      return (char *) ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(newaddr),(const char*)(pv), (len) * sizeof(char)));
                                                                                                                                                                                                  ^

"util.c", line 2047: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(size)))) ? (size_t)(size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((buffer + 1)),(const char*)(bits), (size) * sizeof(char)));
                                                                                                                                                                                     ^

"util.c", line 2049: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(18 - size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(18 - size)))) ? (size_t)(18 - size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)((char *)(buffer + 1) + size),0,(18 - size) * sizeof(char)));
  	                                                                                                                                                                                              ^

"util.c", line 2150: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(tmpenv[j]),(const char*)(environ[j]), (len+1) * sizeof(char)));
                                                                                                                                                                                                    ^

"util.c", line 2181: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]),(const char*)(nam), (nlen) * sizeof(char))); *(environ[i]+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                         ^

"util.c", line 2181: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]),(const char*)(nam), (nlen) * sizeof(char))); *(environ[i]+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ^

"util.c", line 2207: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env),(const char*)(nam), (nlen) * sizeof(char))); *(new_env+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                             ^

"util.c", line 2207: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen)))) ? (size_t)(nlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env),(const char*)(nam), (nlen) * sizeof(char))); *(new_env+nlen) = '='; ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vlen)))) ? (size_t)(vlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"util.c", line 3839: warning #4276-D: relational operator ">" always evaluates to 'false'
    (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(buflen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(buflen)))) ? (size_t)(buflen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((buflen)*sizeof(char))))));
                                                                                                                                                                                                ^

"util.c", line 3866: warning #4276-D: relational operator ">" always evaluates to 'false'
      (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufsize)))) ? (size_t)(bufsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(buf),(size_t)((bufsize)*sizeof(char))))));
                                                                                                                                                                                                     ^

"util.c", line 3882: warning #4276-D: relational operator ">" always evaluates to 'false'
        (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(bufsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(bufsize)))) ? (size_t)(bufsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(buf),(size_t)((bufsize)*sizeof(char))))));
                                                                                                                                                                                                       ^

"vutil.c", line 335: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    || (((rev) < 0 ? -(rev) : (rev)) > 0x7FFFFFFF )) {
  			                                     ^

"vutil.c", line 535: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(raw + len - under - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(raw + len - under - 1)))) ? (size_t)(raw + len - under - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(under),(const char*)(under + 1), (raw + len - under - 1) * sizeof(char)));
  		                                                                                                                                                                                                                                  ^

"mg.c", line 2770: warning #2191-D: type qualifier is meaningless on cast type
              (((S_ReANY((const REGEXP *)((REGEXP * const)rx)))->engine))->numbered_buff_STORE( ((REGEXP * const)rx),(paren),(sv));
                                           ^

"mg.c", line 2770: warning #2191-D: type qualifier is meaningless on cast type
              (((S_ReANY((const REGEXP *)((REGEXP * const)rx)))->engine))->numbered_buff_STORE( ((REGEXP * const)rx),(paren),(sv));
                                                                                                  ^

"hv.c", line 88: warning #4276-D: relational operator ">" always evaluates to 'false'
      (k = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2)))) ? (size_t)(((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((size_t)((char *)&((HEK *)0)->hek_key[0] - (char *)0)) + len + 2)*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                 ^

"hv.c", line 90: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((hek)->hek_key),(const char*)(str), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"hv.c", line 357: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((hv)->sv_flags & 0xff)) == (svtype)0xff)
                                            ^

"hv.c", line 588: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((xhv->xhv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((xhv->xhv_max+1) * sizeof(HE*)))))) ? (size_t)(((xhv->xhv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((xhv->xhv_max+1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                                                ^

"hv.c", line 812: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((xhv->xhv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((xhv->xhv_max+1) * sizeof(HE*)))))) ? (size_t)(((xhv->xhv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((xhv->xhv_max+1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                                            ^

"hv.c", line 1429: warning #4276-D: relational operator ">" always evaluates to 'false'
      (a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0))))) ? (size_t)(((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(a),(size_t)((((newsize) * sizeof(HE*)) + (do_aux ? sizeof(struct xpvhv_aux) : 0))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                       ^

"hv.c", line 1478: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((newsize -oldsize) * sizeof(HE*)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((newsize -oldsize) * sizeof(HE*))))) ? (size_t)((newsize -oldsize) * sizeof(HE*)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(&a[oldsize * sizeof(HE*)]),0,((newsize -oldsize) * sizeof(HE*)) * sizeof(char)));	 
                                                                                                                                                                                                                                                                         ^

"hv.c", line 1567: warning #4276-D: relational operator ">" always evaluates to 'false'
          (a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((newsize) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((newsize) * sizeof(HE*)))))) ? (size_t)(((newsize) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((newsize) * sizeof(HE*))),sizeof(char)))));
                                                                                                                                                                                                                                                             ^

"hv.c", line 1605: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(a = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((hv_max+1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((hv_max+1) * sizeof(HE*)))))) ? (size_t)(((hv_max+1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((hv_max+1) * sizeof(HE*)))*sizeof(char))))));
  	                                                                                                                                                                                                                                                      ^

"hv.c", line 2238: warning #4276-D: relational operator ">" always evaluates to 'false'
              (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))))) ? (size_t)(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)),sizeof(char)))));
                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"hv.c", line 2242: warning #4276-D: relational operator ">" always evaluates to 'false'
              (array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))))) ? (size_t)(((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux)) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysrealloc((void *)(array),(size_t)((((((XPVHV*) (hv)->sv_any)->xhv_max + 1) * sizeof(HE*)) + sizeof(struct xpvhv_aux))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"hv.c", line 3127: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(k = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2)))) ? (size_t)(((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((((size_t)((char *)&((struct shared_he *)0)->shared_he_hek . hek_key[0] - (char *)0)) + len + 2)*sizeof(char))))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"hv.c", line 3133: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((hek)->hek_key),(const char*)(str), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"hv.c", line 3276: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(array = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((max + 1) * sizeof(HE*))) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((max + 1) * sizeof(HE*)))))) ? (size_t)(((max + 1) * sizeof(HE*))) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((((max + 1) * sizeof(HE*))),sizeof(char)))));
  	                                                                                                                                                                                                                                                       ^

"hv.c", line 3401: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (q = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(keylen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(keylen)))) ? (size_t)(keylen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((keylen)*sizeof(char))))));
  	                                                                                                                                                                                              ^

"hv.c", line 3577: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (q = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(keylen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(keylen)))) ? (size_t)(keylen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((keylen)*sizeof(char))))));
  	                                                                                                                                                                                              ^

"hv.c", line 3613: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(value_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(value_len + 1)))) ? (size_t)(value_len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(he ->refcounted_he_data + 1),(const char*)(value_p), (value_len + 1) * sizeof(char)));
  	                                                                                                                                                                                                          ^

"pp_hot.c", line 3088: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"pp_hot.c", line 803: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(targ_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(targ_len)))) ? (size_t)(targ_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(targ_buf),(const char*)(targ_pv), (targ_len) * sizeof(char)));
                                                                                                                                                                                                             ^

"pp_hot.c", line 854: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(targ_pv),(const char*)(svpv_p->pv), (len) * sizeof(char)));
                                                                                                                                                                                          ^

"pp_hot.c", line 870: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(targ_pv),(const char*)(const_pv), (len) * sizeof(char)));
                                                                                                                                                                                              ^

"pp_hot.c", line 882: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(targ_pv),(const char*)(svpv_p->pv), (len) * sizeof(char)));
                                                                                                                                                                                              ^

"pp_hot.c", line 3297: warning #4276-D: relational operator ">" always evaluates to 'false'
  		do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                              ^

"pp_hot.c", line 3306: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (new_len)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_len)))) ? (size_t)(new_len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((new_len)))))); } while (0); } while (0);
  	                                                                                                                                                                                                                                                                                                                                                                                  ^

"pp_hot.c", line 4301: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(m),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4306: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(m),(const char*)(d), (i) * sizeof(char)));
  		                                                                                                                                                                          ^

"pp_hot.c", line 4316: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d - i),(const char*)(s), (i) * sizeof(char)));
                                                                                                                                                                                            ^

"pp_hot.c", line 4319: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4337: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(char)));
  			                                                                                                                                                                      ^

"pp_hot.c", line 4341: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(clen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(clen)))) ? (size_t)(clen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4352: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i+1)))) ? (size_t)(i+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i+1) * sizeof(char)));		 
  		                                                                                                                                                                            ^

"sv.c", line 16330: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"sv.c", line 16433: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"sv.c", line 16640: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"sv.c", line 472: warning #4275-D: constant out of range ([0 - 16]) for the operator
  	    if (((svtype)((sv)->sv_flags & 0xff)) != (svtype)0xff
  	                                          ^

"sv.c", line 1108: warning #4276-D: relational operator ">" always evaluates to 'false'
      (adesc->arena = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(good_arena_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(good_arena_size)))) ? (size_t)(good_arena_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((good_arena_size)*sizeof(char))))));
                                                                                                                                                                                                                                      ^

"sv.c", line 1343: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_type_details->body_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_type_details->body_size)))) ? (size_t)(new_type_details->body_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                    ^

"sv.c", line 1413: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(new_type_details->body_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(new_type_details->body_size)))) ? (size_t)(new_type_details->body_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                        ^

"sv.c", line 1434: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(length) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(length)))) ? (size_t)(length) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)((char *)new_body + offset),(const char*)((char *)old_body + offset), (length) * sizeof(char)));
  	                                                                                                                                                                                         ^

"sv.c", line 1519: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_cur+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_cur+1)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_cur+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (((XPV*) (sv)->sv_any)->xpv_cur+1) * sizeof(char)));
                                                                                                                                                                                                                                                                         ^

"sv.c", line 1602: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(((XPV*) (sv)->sv_any)->xpv_cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(((XPV*) (sv)->sv_any)->xpv_cur)))) ? (size_t)(((XPV*) (sv)->sv_any)->xpv_cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(s),(const char*)(((const char*)(0 + (sv)->sv_u . svu_pv))), (((XPV*) (sv)->sv_any)->xpv_cur) * sizeof(char)));
                                                                                                                                                                                                                                                                               ^

"sv.c", line 3039: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(buffer = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len)*sizeof(char))))));
  		                                                                                                                                                                                      ^

"sv.c", line 3097: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(s),(const char*)(ptr), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 4386: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(((dstr)->sv_u . svu_pv)),(const char*)(ptr), (len + 1) * sizeof(char)));
                                                                                                                                                                                                      ^

"sv.c", line 4641: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cur)))) ? (size_t)(cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((dstr)->sv_u . svu_pv)),(const char*)(((const char*)(0 + (sstr)->sv_u . svu_pv))), (cur) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 4905: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(dptr),(const char*)(ptr), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 4956: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 5161: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cur) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cur)))) ? (size_t)(cur) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (cur) * sizeof(char)));
                                                                                                                                                                                              ^

"sv.c", line 5345: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 5440: warning #4276-D: relational operator ">" always evaluates to 'false'
        ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(slen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(slen)))) ? (size_t)(slen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((dsv)->sv_u . svu_pv) + dlen),(const char*)(sstr), (slen) * sizeof(char)));
                                                                                                                                                                                       ^

"sv.c", line 5532: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)+tlen),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 6311: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(offset+len-curlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(offset+len-curlen)))) ? (size_t)(offset+len-curlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(((bigstr)->sv_u . svu_pv)+curlen),0,(offset+len-curlen) * sizeof(char)));
  	                                                                                                                                                                                                                      ^

"sv.c", line 6325: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(big+offset),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 6331: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((bigstr)->sv_u . svu_pv)+offset),(const char*)(little), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 6347: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6352: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(mid),(const char*)(midend), (i) * sizeof(char)));
  	                                                                                                                                                                          ^

"sv.c", line 6361: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(midend - i),(const char*)(big), (i) * sizeof(char)));
  	                                                                                                                                                                      ^

"sv.c", line 6364: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6369: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(littlelen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(littlelen)))) ? (size_t)(littlelen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(midend),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 8645: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(got) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(got)))) ? (size_t)(got) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bp),(const char*)(ptr), (got) * sizeof(unsigned char)));
                                                                                                                                                                                                                    ^

"sv.c", line 8651: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cnt) || sizeof(unsigned char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cnt)))) ? (size_t)(cnt) : ((size_t)-1)/sizeof(unsigned char)) > ((size_t)-1)/sizeof(unsigned char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(unsigned char)));
                                                                                                                                                                                                                ^

"sv.c", line 8658: warning #4276-D: relational operator ">" always evaluates to 'false'
  	        ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cnt) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cnt)))) ? (size_t)(cnt) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(char)));	      
  	                                                                                                                                                                                    ^

"sv.c", line 9708: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((old)->sv_flags & 0xff)) == (svtype)0xff) {
                                             ^

"sv.c", line 10042: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 10934: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(end),(const char*)(buf), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 11676: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(vn - 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(vn - 1)))) ? (size_t)(vn - 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(v0 + 1),(const char*)(v0), (vn - 1) * sizeof(char)));
                                                                                                                                                                                                               ^

"sv.c", line 11719: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(p),(const char*)(r), (n) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 11768: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nmove) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nmove)))) ? (size_t)(nmove) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(zerox + nzero),(const char*)(zerox), (nmove) * sizeof(char)));
                                                                                                                                                                                                ^

"sv.c", line 11773: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(buf + gap),(const char*)(buf), (elen) * sizeof(char)));
                                                                                                                                                                                             ^

"sv.c", line 13031: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(PL_efloatbuf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(PL_efloatsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(PL_efloatsize)))) ? (size_t)(PL_efloatsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((PL_efloatsize)*sizeof(char))))));
  		                                                                                                                                                                                                                          ^

"sv.c", line 13273: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 13294: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(elen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(elen)))) ? (size_t)(elen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 15962: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len + 1)))) ? (size_t)(len + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len + 1) * sizeof(char)));
  	                                                                                                                                                                                            ^

"pp.c", line 2177: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"pp.c", line 3903: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tculen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tculen)))) ? (size_t)(tculen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  	                                                                                                                                                                                     ^

"pp.c", line 3916: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(tculen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(tculen)))) ? (size_t)(tculen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  		                                                                                                                                                                                 ^

"pp.c", line 3933: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(slen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(slen)))) ? (size_t)(slen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d + 1),(const char*)(s + 1), (slen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4037: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(capital_iota_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(capital_iota_len)))) ? (size_t)(capital_iota_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)("\xCE\x99"), (capital_iota_len) * sizeof(U8)));
  		                                                                                                                                                                                                               ^

"pp.c", line 4071: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                             ^

"pp.c", line 4077: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(capital_iota_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(capital_iota_len)))) ? (size_t)(capital_iota_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)("\xCE\x99"), (capital_iota_len) * sizeof(U8)));
                                                                                                                                                                                                                             ^

"pp.c", line 4295: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4495: warning #4276-D: relational operator ">" always evaluates to 'false'
              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                         ^

"pp.c", line 4542: warning #4276-D: relational operator ">" always evaluates to 'false'
                      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(small_mu_len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(small_mu_len)))) ? (size_t)(small_mu_len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)("\xCE\xBC"), (small_mu_len) * sizeof(U8)));
                                                                                                                                                                                                                         ^

"pp.c", line 4559: warning #4276-D: relational operator ">" always evaluates to 'false'
                              ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                                         ^

"pp_ctl.c", line 290: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"pp_ctl.c", line 800: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(to_copy) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(to_copy)))) ? (size_t)(to_copy) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(t),(const char*)(source), (to_copy) * sizeof(char)));
  		                                                                                                                                                                                        ^

"pp_ctl.c", line 3479: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (((oldcurcop->cop_warnings) == 0L || (oldcurcop->cop_warnings) == (((STRLEN*)0)+1) || (oldcurcop->cop_warnings) == (((STRLEN*)0)+2)) ? (STRLEN*)(oldcurcop->cop_warnings) : (STRLEN*)((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings)))) ? (size_t)(sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), memcpy((char*)(malloc((sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings))),(const char*)(oldcurcop->cop_warnings), (sizeof(*oldcurcop->cop_warnings)+ *oldcurcop->cop_warnings) * sizeof(char))));
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^

"pp_sys.c", line 2997: warning #2186-D: pointless comparison of unsigned integer with zero
  	    neg = PL_statcache.st_ino < 0;
  	                              ^

"pp_sys.c", line 325: warning #4276-D: relational operator ">" always evaluates to 'false'
  		    do { const STRLEN _lEnGtH = ((XPV*) (sv)->sv_any)->xpv_cur + 1; do { do { ((void)0); ((void)0); ((void)0); (((XPV*) (sv)->sv_any)->xpv_len_u . xpvlenu_len = (_lEnGtH)); } while (0); do { ((void)0); ((void)0); ((void)0); (((sv))->sv_u . svu_pv = (((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(_lEnGtH) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(_lEnGtH)))) ? (size_t)(_lEnGtH) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)Perl_safesysrealloc((void *)((sv)->sv_u . svu_pv), (size_t)((_lEnGtH)))))); } while (0); } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"pp_sys.c", line 1237: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(fd_sets[i] = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(growsize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(growsize)))) ? (size_t)(growsize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((growsize)*sizeof(char))))));
  	                                                                                                                                                                                                         ^

"pp_sys.c", line 1825: warning #4276-D: relational operator ">" always evaluates to 'false'
      	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(offset-orig_size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(offset-orig_size)))) ? (size_t)(offset-orig_size) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), (void)memset((char*)(buffer+orig_size),0,(offset-orig_size) * sizeof(char)));
      	                                                                                                                                                                                                                   ^

"doop.c", line 71: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len*2+1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len*2+1)))) ? (size_t)(len*2+1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len*2+1)*sizeof(U8))))));
  	                                                                                                                                                                                             ^

"doop.c", line 87: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(ulen) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(ulen)))) ? (size_t)(ulen) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (ulen) * sizeof(U8)));
  		                                                                                                                                                                           ^

"doop.c", line 223: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len*2+1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len*2+1)))) ? (size_t)(len*2+1) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len*2+1)*sizeof(U8))))));
  	                                                                                                                                                                                             ^

"doop.c", line 249: warning #4276-D: relational operator ">" always evaluates to 'false'
                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                          ^

"doop.c", line 328: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len * 3 + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len * 3 + 13)))) ? (size_t)(len * 3 + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len * 3 + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 346: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  	                                                                                                                                                                      ^

"doop.c", line 363: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    (dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 491: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len * 3 + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len * 3 + 13)))) ? (size_t)(len * 3 + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysmalloc((size_t)((len * 3 + 13)*sizeof(U8))))));
  	                                                                                                                                                                                                        ^

"doop.c", line 510: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  		                                                                                                                                                                                                    ^

"doop.c", line 525: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  		                                                                                                                                                                  ^

"doop.c", line 544: warning #4276-D: relational operator ">" always evaluates to 'false'
  			((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len)))) ? (size_t)(len) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (len) * sizeof(U8)));
  			                                                                                                                                                                        ^

"doop.c", line 564: warning #4276-D: relational operator ">" always evaluates to 'false'
  		(dstart = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(nlen + 13) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(nlen + 13)))) ? (size_t)(nlen + 13) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (U8*)(Perl_safesysrealloc((void *)(dstart),(size_t)((nlen + 13)*sizeof(U8))))));
  		                                                                                                                                                                                                    ^

"doop.c", line 576: warning #4276-D: relational operator ">" always evaluates to 'false'
  		((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(i) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(i)))) ? (size_t)(i) : ((size_t)-1)/sizeof(U8)) > ((size_t)-1)/sizeof(U8))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(U8)));
  		                                                                                                                                                                  ^

"doop.c", line 1135: warning #4276-D: relational operator ">" always evaluates to 'false'
  	(dc = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(needlen + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(needlen + 1)))) ? (size_t)(needlen + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesyscalloc((needlen + 1),sizeof(char)))));
  	                                                                                                                                                                                                          ^

"doio.c", line 2299: warning #4276-D: relational operator ">" always evaluates to 'false'
      (buf = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(cmdlen) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(cmdlen)))) ? (size_t)(cmdlen) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((cmdlen)*sizeof(char))))));
                                                                                                                                                                                                  ^

"doio.c", line 3177: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(msize) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(msize)))) ? (size_t)(msize) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(mbuf),(const char*)(shm + mpos), (msize) * sizeof(char)));
  	                                                                                                                                                                                  ^

"doio.c", line 3189: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(n) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(n)))) ? (size_t)(n) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((void)0), ((void)0), (void)memcpy((char*)(shm + mpos),(const char*)(mbuf), (n) * sizeof(char)));
  	                                                                                                                                                                      ^

"regexec.c", line 505: warning #2111-D: statement is unreachable
      return (0);  
      ^

"regexec.c", line 2227: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              do { while (s < strend) { if ((((( (U8*) ((regnode_charclass*)(c))->bitmap) [ ( ( (UV) (*((U8*)s))) >> 3) ] ) & (1U << ((*((U8*)s)) & 7))) ? (_Bool)1 : (_Bool)0)) { if ( ( doevery || s != previous_occurrence_end) && (reginfo->intuit || S_regtry( reginfo,&s))) { goto got_it; } s += ((0) ? PL_utf8skip[*(const U8*)(s)] : 1); previous_occurrence_end = s; } else { s += ((0) ? PL_utf8skip[*(const U8*)(s)] : 1); } } } while (0);
                                                        ^

"regexec.c", line 2233: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          while (s < strend) { s = ((char *) S_find_next_masked((U8 *) s, (U8 *) strend, (U8) ((((struct regnode_1 *)c)->arg1)), ((c)->flags))); if (s >= strend) { break; } if ( ( doevery || s != previous_occurrence_end) && (reginfo->intuit || S_regtry( reginfo,&s))) { goto got_it; } s += (0) ? PL_utf8skip[*(const U8*)(s)] : 1; previous_occurrence_end = s; };
                                                                                                 ^

"regexec.c", line 2872: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              reg_ac_data *aho = (reg_ac_data*)progi->data->data[ ((((struct regnode_1 *)c)->arg1)) ];
                                                                     ^

"regexec.c", line 2910: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                      bitmap=(U8*)((regnode_charclass*)(c))->bitmap;
                                   ^

"regexec.c", line 4356: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      SV *sv_dat= ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                         ^

"regexec.c", line 5835: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 5841: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 5877: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
              if(!(nextchr < 0) && !(((( (U8*) ((regnode_charclass*)(scan))->bitmap) [ ( ( (UV) (nextchr)) >> 3) ] ) & (1U << ((nextchr) & 7))) ? (_Bool)1 : (_Bool)0)) {
                                                ^

"regexec.c", line 5883: warning #2111-D: statement is unreachable
                  ((void)0);  
                  ^

"regexec.c", line 5937: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          	    = (reg_trie_data*)rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ];
          	                                           ^

"regexec.c", line 5938: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		HV * widecharmap = ((HV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) + 1 ])));
  		                                                          ^

"regexec.c", line 6083: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 6113: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = ((reg_trie_data*)rexi->data->data[((((struct regnode_1 *)st->u . trie . me)->arg1))])->wordinfo;
  		                                           ^

"regexec.c", line 6137: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    = (reg_trie_data*)rexi->data->data[((((struct regnode_1 *)st->u . trie . me)->arg1))];
  		                                          ^

"regexec.c", line 6200: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 6702: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  		if (!(((scan)->flags) ? S_reginclass( rex,scan,(U8*)locinput,(U8*)locinput+1,utf8_target) : (((( (U8*) ((regnode_charclass*)(scan))->bitmap) [ ( ( (UV) (*((U8*)locinput))) >> 3) ] ) & (1U << ((*((U8*)locinput)) & 7))) ? (_Bool)1 : (_Bool)0)))
  		                                                                                                        ^

"regexec.c", line 6709: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if ((nextchr < 0) || (((int)*(const U8*)(locinput)) & ((scan)->flags)) != ((((struct regnode_1 *)scan)->arg1))) {
                                                                                           ^

"regexec.c", line 7041: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7108: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              arg= (U32)((((struct regnode_1 *)scan)->arg1));
                           ^

"regexec.c", line 7120: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              startpoint = scan + ((((struct regnode_2L *)scan)->arg2));
                                     ^

"regexec.c", line 7181: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		n = ((((struct regnode_1 *)scan)->arg1));
  		       ^

"regexec.c", line 7417: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                                      ((((struct regnode_2L *)scan)->arg2)),
                                         ^

"regexec.c", line 7484: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7567: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7602: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7624: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  sv_yes_mark = ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])));
                                                                       ^

"regexec.c", line 7625: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
              if (((((struct regnode_2L *)scan)->arg2))){
                     ^

"regexec.c", line 7632: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                          n = ((((struct regnode_1 *)cursor)->arg1));
                                 ^

"regexec.c", line 7638: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              if ( n == ((((struct regnode_1 *)scan)->arg1)) || ( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (n) + 1 ) ) ) )
                                           ^

"regexec.c", line 7648: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7658: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              n = ((((struct regnode_1 *)scan)->arg1));
                     ^

"regexec.c", line 7673: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next = scan + ((((struct regnode_1 *)scan)->arg1));
  		                 ^

"regexec.c", line 7775: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		next += ((((struct regnode_1 *)next)->arg1));
  		           ^

"regexec.c", line 7797: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7803: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7809: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7845: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7953: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7964: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7968: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

"regexec.c", line 7974: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7981: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 7991: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8016: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8047: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8053: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	    next = scan + ((((struct regnode_1 *)scan)->arg1));
  	                     ^

"regexec.c", line 8072: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8076: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  ? ((SV *)((void *) (rexi->data->data[ ((((struct regnode_1 *)scan)->arg1)) ])))
                                                           ^

"regexec.c", line 8079: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8087: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8091: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

"regexec.c", line 8156: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec