Show report
[2019-04-15 07:09:19+0200] ==> Skipping synctree
[2019-04-15 07:09:19+0200] ==> Starting runsmoke
[2019-04-15 07:09:19+0200] [tssmokeperl.pl] chdir(/pro/3gl/CPAN/perl-current)
[2019-04-15 07:09:19+0200] Setup alarm: Tue Apr 16 06:39:19 2019
[2019-04-15 07:09:19+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]
[2019-04-15 07:09:19+0200] Found: Test::Harness version 3.42.
[2019-04-15 07:09:19+0200] Reading build configurations from /pro/3gl/CPAN/smoke/p59.cfg
[2019-04-15 07:09:19+0200] Reading 'Policy.sh' from ../Policy.sh (v=1)
[2019-04-15 07:09:19+0200] Running test suite only with 'harness'
[2019-04-15 07:09:19+0200] make distclean ...
[2019-04-15 07:09:19+0200] Smoking patch 918fbd43ad287e3a4b8f309a55f91e409747c895 v5.29.9-126-g918fbd43ad
[2019-04-15 07:09:19+0200] Smoking branch blead
[2019-04-15 07:09:20+0200] Locally applied patches from '/pro/3gl/CPAN/perl-current/patchlevel.h'
[2019-04-15 07:09:20+0200] Patches: 'uncommitted-changes;SMOKE918fbd43ad287e3a4b8f309a55f91e409747c895'
[2019-04-15 07:09:20+0200] 
[2019-04-15 07:09:20+0200] Configuration: -Dusedevel
[2019-04-15 07:09:20+0200] ------------------------------------------------------------------------------
[2019-04-15 07:09:20+0200] make distclean ...
[2019-04-15 07:09:20+0200] 
[2019-04-15 07:09:20+0200] Copy Policy.sh ...
[2019-04-15 07:09:20+0200] 
[2019-04-15 07:09:20+0200] Configure ...
5.29.10 <=> 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.  
[2019-04-15 07:10:39+0200] 
[2019-04-15 07:10:39+0200] make ...
"op.c", line 12449: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

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

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

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

"op.c", line 3215: 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 12565: 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 12734: 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)));
  	                                                                                                                                                                                ^

"op.c", line 17191: 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*)(new_warnings),(const char*)(warnings), (size) * sizeof(char)));
                                                                                                                                                                                     ^

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

"perl.c", line 4606: 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 1032: 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 1058: 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 1078: 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 1081: 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 1176: 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 1254: 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 1806: 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 3406: 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 3747: 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 3843: 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 3894: 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 3915: 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 3984: 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 4065: 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 4120: 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 4864: 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 4943: 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 5063: 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 5922: 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 6172: 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 7215: 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 7807: 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 9196: 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 9377: 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 9411: 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 10073: 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 10199: 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 10255: 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 10347: 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 10434: 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 10719: 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 10888: 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 12318: 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 3597: 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 3615: 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 3727: 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 3752: 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 3757: 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 3762: 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 4382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              (((((struct regnode_1 *)scan)->arg1)) = ((*(((struct regnode_string *)scan)->string) & mask)));
                  ^

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

"regcomp.c", line 4532: 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 4539: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((((n)->type) == 70) && (noff = ((((struct regnode_1 *)n)->arg1)))))
  		                                             ^

"regcomp.c", line 4543: 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 5064: 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 5065: 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 5343: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      (((((struct regnode_1 *)next)->arg1)) = ((*(((struct regnode_string *)next)->string) & mask)));
                          ^

"regcomp.c", line 5501: 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) - (pRExC_state ->emit_start));
                                                         ^

"regcomp.c", line 5504: 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) - (pRExC_state ->emit_start)) + 2;
                                                          ^

"regcomp.c", line 5507: 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 5548: 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 5551: 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) - (pRExC_state ->emit_start));
                                                             ^

"regcomp.c", line 5554: 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) - (pRExC_state ->emit_start))
                                                              ^

"regcomp.c", line 5601: 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 5841: 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 5844: 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 6154: 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 6158: 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 6161: 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 6168: 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 6217: 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 6416: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

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

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

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

"regcomp.c", line 8325: 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) - (pRExC_state ->emit_start)))));
              ^

"regcomp.c", line 8325: 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) - (pRExC_state ->emit_start)))));
                                                                                    ^

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

"regcomp.c", line 11382: 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 *)((pRExC_state ->emit_start) + (ret)))->arg1))]=(void*)sv;
                                                     ^

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

"regcomp.c", line 14786: 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 14816: 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 14817: 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 19072: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
          do { ((regnode_charclass_posixl*) (((pRExC_state ->emit_start) + (ret))))->classflags = (posixl); } while (0);
                ^

"regcomp.c", line 19143: 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 19164: 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 19215: 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 19633: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      do { (((((struct regnode_1 *)((pRExC_state ->emit_start) + (ptr)))->arg1)) = ((arg))); do { do { ((((pRExC_state ->emit_start) + (ptr)))->type) = op; ((((pRExC_state ->emit_start) + (ptr)))->next_off) = 0; } while (0); (ptr)++; } while (0); (ptr) += regarglen[op]; } while (0);
               ^

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

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

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

"regcomp.c", line 19942: 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 19952: 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 21162: 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 4146: 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 4216: 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 4221: 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 4226: 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 5112: 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 5114: 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 6426: 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 6430: 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 6432: 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 6434: 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 6614: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 1)))) ? (size_t)(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 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 + S_variant_under_utf8_count(src, src + *plen_p) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                ^

"regcomp.c", line 6974: 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 7250: 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 7265: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(pat_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(pat_len)))) ? (size_t)(pat_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*)((pRExC_state ->precomp)), (pat_len) * sizeof(char)));
                                                                                                                                                                                              ^

"regcomp.c", line 7657: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (pRExC_state ->size)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (pRExC_state ->size))))) ? (size_t)(sizeof(regexp_internal) + (pRExC_state ->size)) : ((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) + (pRExC_state ->size))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                          ^

"regcomp.c", line 7661: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (pRExC_state ->size)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (pRExC_state ->size))))) ? (size_t)(sizeof(regexp_internal) + (pRExC_state ->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*)((pRExC_state ->rxi)),0,(sizeof(regexp_internal) + (pRExC_state ->size)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                   ^

"regcomp.c", line 7839: 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 ->total_par)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) : ((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 ->total_par))*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"regcomp.c", line 7851: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) : ((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 ->total_par)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                                                                                           ^

"regcomp.c", line 9098: 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 10281: 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 19539: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode))))) ? (size_t)(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * 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_safesysrealloc((void *)((pRExC_state ->rxi)),(size_t)((sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"regcomp.c", line 21187: 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 21188: 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 21197: 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 22591: warning #4276-D: relational operator ">" always evaluates to 'false'
      (lookup_name = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(name_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(name_len)))) ? (size_t)(name_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)((name_len)*sizeof(char))))));
                                                                                                                                                                                                                ^

"regcomp.c", line 22778: warning #4276-D: relational operator ">" always evaluates to 'false'
                          (this_string = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(total_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(total_len + 1)))) ? (size_t)(total_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((total_len + 1),sizeof(char)))));
                                                                                                                                                                                                                                                   ^

"regcomp.c", line 22779: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(j) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(j)))) ? (size_t)(j) : ((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*)(this_string),(const char*)(lookup_name), (j) * sizeof(char)));
                                                                                                                                                                                                ^

"regcomp.c", line 23425: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(strlen(cur_ptr) - excess_leading_zeros + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(strlen(cur_ptr) - excess_leading_zeros + 1)))) ? (size_t)(strlen(cur_ptr) - excess_leading_zeros + 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*)(cur_ptr),(const char*)(cur_ptr + excess_leading_zeros), (strlen(cur_ptr) - excess_leading_zeros + 1) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                   ^

"dump.c", line 1968: 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 2673: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

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

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

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

"dump.c", line 2711: 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 2029: 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 2031: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(19 - size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(19 - size)))) ? (size_t)(19 - 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,(19 - size) * sizeof(char)));
  	                                                                                                                                                                                              ^

"util.c", line 2132: 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 2163: 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 2163: 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 2189: 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 2189: 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 3825: 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 3852: 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 3868: 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 590: 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 890: 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 920: 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 967: 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 1016: 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 1073: 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 1872: 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 1911: 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 2785: 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 359: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((hv)->sv_flags & 0xff)) == (svtype)0xff)
                                            ^

"hv.c", line 590: 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 814: 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 1431: 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 1480: 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 1569: 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 1607: 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 2240: 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 2244: 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 3129: 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 3135: 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 3278: 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 3403: 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 3579: 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 3615: 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 1819: 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 2584: 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 2738: 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 3093: 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 3302: 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 3311: 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 4306: 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 4311: 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 4321: 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 4324: 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 4342: 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 4346: 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 4357: 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 1458: 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 16384: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

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

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

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

"sv.c", line 1107: 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 1342: 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 1412: 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 1433: 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 1518: 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 1601: 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 3086: 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 3149: 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 4442: 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 4697: 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 4961: 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 5012: 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 5217: 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 5400: 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 5495: 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 5587: 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 6366: 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 6380: 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 6386: 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 6402: 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 6407: 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 6416: 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 6419: 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 6424: 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 8701: 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 8707: 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 8714: 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 9768: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((old)->sv_flags & 0xff)) == (svtype)0xff) {
                                             ^

"sv.c", line 10101: 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 10998: 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 11734: 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 11777: 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 11826: 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 11831: 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 13090: 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 13332: 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 13353: 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 16016: 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 2180: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"pp.c", line 7007: 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 3991: 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 4004: 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 4021: 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 4162: 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 4514: 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 4728: 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 4915: 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 4915: 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 4940: 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 801: 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_sys.c", line 2945: 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 1824: 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 2337: 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 3215: 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 3227: 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 523: warning #2111-D: statement is unreachable
      return (0);  
      ^

"regexec.c", line 2157: 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 2164: 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 2171: 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_span_end_mask((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 += (utf8_target) ? PL_utf8skip[*(const U8*)(s)] : 1; previous_occurrence_end = s; };
                                                                                                   ^

"regexec.c", line 2832: 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 2870: 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 4122: 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 4406: warning #2111-D: statement is unreachable
                          ((void)0);  
                          ^

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

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

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

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

"regexec.c", line 5956: 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 5957: 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 6104: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 6134: 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 6158: 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 6224: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

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

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

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

"regexec.c", line 7113: 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 7183: 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 7195: 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 7256: 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 7496: 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 7564: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7651: 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
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7693: 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 7694: 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 7701: 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 7705: 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 7715: 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 7725: 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 7740: 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 7842: 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 7865: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

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

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

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

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

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

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

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

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

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

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

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

"regexec.c", line 8123: 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 8144: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8148: 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 8152: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

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

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

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

"regexec.c", line 8278: 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)] == 35) || PL_regkind[((st->u . curlym . B)->type)] == 60 ) || ( ((st->u . curlym . B)->type) == 56 || (((st->u . curlym . B)->type) == 57 && !( ( ( 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) == 77 || ((st->u . curlym . B)->type) == 74 || ((st->u . curlym . B)->type) == 72 || ((st->u . curlym . B)->type) == 50 || ((st->u . curlym . B)->type) == 78 || ((st->u . curlym . B)->type) == 98 || (PL_regkind[((st->u . curlym . B)->type)] == 51 && ((((struct regnode_2 *)st->u . curlym . B)->arg1)) > 0) )) {
  		                                                                                                                                                                                                                                                                                                                    ^

"regexec.c", line 8281: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8281: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8355: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8441: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (! ( (PL_regkind[((next)->type)] == 35) || PL_regkind[((next)->type)] == 60 ) && ! ( ((next)->type) == 56 || (((next)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)next)->arg1))) + 1 ) ) ) ) || ((next)->type) == 77 || ((next)->type) == 74 || ((next)->type) == 72 || ((next)->type) == 50 || ((next)->type) == 78 || ((next)->type) == 98 || (PL_regkind[((next)->type)] == 51 && ((((struct regnode_2 *)next)->arg1)) > 0) )) {
                                                                                                                                                                                                                                                                              ^

"regexec.c", line 8448: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8448: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8529: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

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

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

"regexec.c", line 8814: 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 8828: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8863: 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 8873: 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 8884: 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 8887: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

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

"regexec.c", line 8897: 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 8907: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8913: 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 8918: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

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

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

"regexec.c", line 8957: 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 8990: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

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

"regexec.c", line 9548: 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 *) this_eol, (U8) ((((struct regnode_1 *)p)->arg1)), ((p)->flags));
                                                                                     ^

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

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

"regexec.c", line 9862: 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 9875: 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 9879: 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 9917: 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 9949: 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 10012: 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) ('i')) >> 3) ] ) & (1U << (('i') & 7))) ? (_Bool)1 : (_Bool)0)) {
  		                ^

"regexec.c", line 10017: 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) ('I')) >> 3) ] ) & (1U << (('I') & 7))) ? (_Bool)1 : (_Bool)0)) {
  		                ^

"regexec.c", line 3160: 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 4227: 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 4228: 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 7978: 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 7981: 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 7985: 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 3305: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

"utf8.c", line 1101: 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 2593: 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 2630: 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 2668: warning #4276-D: relational operator ">" always evaluates to 'false'
      (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((*lenp) + S_variant_under_utf8_count(s, send) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((*lenp) + S_variant_under_utf8_count(s, send) + 1)))) ? (size_t)((*lenp) + S_variant_under_utf8_count(s, send) + 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) + S_variant_under_utf8_count(s, send) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                             ^

"utf8.c", line 3060: 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 3538: 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 3669: 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 4196: 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 4228: 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 4237: 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 4568: 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 2074: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      ((PerlIOBuf *)(*(f)))->posn = old;
       ^

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

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

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

"perlio.c", line 3959: 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 4021: 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 4093: 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 4105: 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 4164: 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 4215: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	    PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                    ^

"perlio.c", line 4225: 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 4256: 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
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4281: 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 4290: 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 4301: 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 4320: 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 4329: 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 4419: 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 4577: 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 4586: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                ^

"perlio.c", line 4632: 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 4636: 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 4704: 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 4705: 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 4762: 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 4809: 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 1150: 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 2098: 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 4067: 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 4148: 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 4190: 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 4307: 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 1619: 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 151: 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 313: 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 2383: 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 2387: 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 2391: 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 4006: 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 4138: 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 4159: 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 4182: 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 4316: 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 4341: 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 4593: 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 4597: 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 4620: 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 4623: 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 5048: 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 5053: 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 2019: 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 2020: 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 2223: 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 2416: 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 2490: 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 2565: 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 2900: 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 2933: 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 2948: 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 2953: 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 3121: 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.  

lib/unicore/mktables: WARNING: \b{} algorithms (regen/mk_invlist.pl) need to
    be checked and possibly updated to Unicode 12.1.0.  Failing tests will be
    marked TODO; at lib/unicore/mktables line 20426, <DATA> line 393.
"op.c", line 12449: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

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

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

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

"op.c", line 3215: 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 12565: 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 12734: 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)));
  	                                                                                                                                                                                ^

"op.c", line 17191: 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*)(new_warnings),(const char*)(warnings), (size) * sizeof(char)));
                                                                                                                                                                                     ^

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

"perl.c", line 4606: 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 1310: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

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

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

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

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

"B.xs", line 2037: 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 913: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    New(0, iname, namelen+28, char);
  	    ^

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

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

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

"Dumper.xs", line 1261: 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 3206: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"RealPPPort.c", line 4756: 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 533: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

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

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

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

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

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

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

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

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

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

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

"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 2017: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

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

"POSIX.c", line 5043: 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 2913: 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 7973: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"Storable.xs", line 4032: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

"Storable.xs", line 4032: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"Storable.xs", line 4202: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

"Storable.xs", line 4202: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

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

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

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

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

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

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

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

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

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

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

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

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

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

"Storable.xs", line 4588: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE( (unsigned char*) header, length);
      ^

"Storable.xs", line 4847: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(10003, classname, len+1, char);
          ^

"Storable.xs", line 5050: warning #4276-D: relational operator ">" always evaluates to 'false'
              New(10003, classname, len+1, char);
              ^

"Storable.xs", line 5941: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(10003, s, len+1, char);
      ^

"Storable.xs", line 6501: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);	/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 6635: warning #4276-D: relational operator ">" always evaluates to 'false'
              KBUFCHK((STRLEN)size);/* Grow hash key read pool if needed */
              ^

"Storable.xs", line 7006: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);			/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 7381: 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 2761 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 6437: warning #3215-D: function "Perl_to_utf8_lower" (declared at line 3787 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_lower(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6527: warning #3215-D: function "Perl_to_utf8_fold" (declared at line 3780 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_fold(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6617: warning #3215-D: function "Perl_to_utf8_upper" (declared at line 3801 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_upper(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6700: warning #3215-D: function "Perl_to_utf8_title" (declared at line 3794 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_title(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6145: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s, (U8 *) copy + offset, len, U8);
          ^

"APItest.xs", line 6160: 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 523: warning #2111-D: statement is unreachable
      return FALSE; /* Things like CNTRL are always below 256 */
      ^

"re_exec.c", line 2157: 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 2164: 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 2171: 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(utf8_target,
          ^

"re_exec.c", line 2832: 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 2870: 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 4122: 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 4406: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"re_exec.c", line 5847: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5853: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5895: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                  && ! ANYOF_BITMAP_TEST(scan, nextchr))
                       ^

"re_exec.c", line 5902: warning #2111-D: statement is unreachable
                  NOT_REACHED; /* NOTREACHED */
                  ^

"re_exec.c", line 5956: 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 5957: 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 6104: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 6134: 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 6158: 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 6224: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 6227: 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 6755: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                  if (! ANYOF_BITMAP_TEST(scan, * (U8 *) (locinput))) {
                        ^

"re_exec.c", line 6772: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  || (UCHARAT(locinput) & FLAGS(scan)) != ARG(scan)
                                                          ^

"re_exec.c", line 6782: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  || (UCHARAT(locinput) & FLAGS(scan)) == ARG(scan)
                                                          ^

"re_exec.c", line 7113: 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 7183: 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 7195: 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 7256: 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 7496: 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 7564: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7651: 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 7673: 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 7693: 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 7694: 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 7701: 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 7705: 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 7715: 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 7725: 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 7740: 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 7842: 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 7865: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7871: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7877: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7914: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 8022: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 8034: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 8038: warning #2111-D: statement is unreachable
  	NOT_REACHED; /* NOTREACHED */
  	^

"re_exec.c", line 8044: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8051: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8061: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8086: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8117: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8123: 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 8144: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8148: 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 8152: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8160: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8164: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8230: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8278: 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 8281: 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 8281: 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 8355: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8441: 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 8448: 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 8448: 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 8529: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8656: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8684: warning #2111-D: statement is unreachable
  		    NOT_REACHED; /* NOTREACHED */
  		    ^

"re_exec.c", line 8814: 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 8828: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8863: 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 8873: 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 8884: 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 8887: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8893: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8897: 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 8907: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8913: 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 8918: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8923: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8943: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8957: 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 8990: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 9534: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	    while (scan < this_eol && ANYOF_BITMAP_TEST(p, *((U8*)scan)))
  	                              ^

"re_exec.c", line 9548: 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 *) this_eol, (U8) ARG(p), FLAGS(p));
                                                                                ^

"re_exec.c", line 9555: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		   &&  (*scan & FLAGS(p)) != ARG(p))
  		                             ^

"re_exec.c", line 9562: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              scan = (char *) find_next_masked((U8 *) scan, (U8 *) this_eol, (U8) ARG(p), FLAGS(p));
                                                                                  ^

"re_exec.c", line 9862: 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 9875: 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 9879: 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 9917: 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 9949: 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 10012: 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, 'i')) {
  		    ^

"re_exec.c", line 10017: 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, 'I')) {
  		    ^

"re_exec.c", line 3160: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(strbeg + min, prog->subbeg, sublen, char);
              ^

"re_exec.c", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c1_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 4228: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c2_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 7978: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    Renew(aux->poscache, size, char);
  			    ^

"re_exec.c", line 7981: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Zero(aux->poscache, size, char);
  			^

"re_exec.c", line 7985: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Newxz(aux->poscache, size, char);
  			^

"re_comp.c", line 3597: 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 3615: 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 3615: 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 3727: 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 3752: 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 3757: 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 3762: 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 4382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              ARG_SET(scan, *STRING(scan) & mask);
              ^

"re_comp.c", line 4451: 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 4532: 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 4539: 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 4543: 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 5064: 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 5065: 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 5343: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      ARG_SET(next, *STRING(next) & mask);
                      ^

"re_comp.c", line 5501: 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)] = REGNODE_OFFSET(oscan);
                                           ^

"re_comp.c", line 5504: 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)] = REGNODE_OFFSET(nxt) + 2;
                                            ^

"re_comp.c", line 5507: 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 5548: 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 5551: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_open_parens[ARG(nxt1)] = REGNODE_OFFSET(oscan);
                                               ^

"re_comp.c", line 5554: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_close_parens[ARG(nxt1)] = REGNODE_OFFSET(nxt2)
                                                ^

"re_comp.c", line 5601: 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 5842: 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 5845: 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 6154: 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 6158: 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 6161: 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 6168: 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 6217: 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 6416: warning #2111-D: statement is unreachable
      NOT_REACHED; /* NOTREACHED */
      ^

"re_comp.c", line 7910: warning #2187-D: use of "=" where "==" may have been intended
  	while ((OP(first) == OPEN && (sawopen = 1)) ||
  	                             ^

"re_comp.c", line 7914: warning #2187-D: use of "=" where "==" may have been intended
  	    (OP(first) == IFMATCH && !first->flags && (sawlookahead = 1)) ||
  	                                              ^

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

"re_comp.c", line 8325: 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)] - REGNODE_OFFSET(scan));
          ^

"re_comp.c", line 8325: 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)] - REGNODE_OFFSET(scan));
          ^

"re_comp.c", line 11380: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  ARG(REGNODE_p(ret)) = add_data( pRExC_state,
                  ^

"re_comp.c", line 11382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  RExC_rxi->data->data[ARG(REGNODE_p(ret))]=(void*)sv;
                                       ^

"re_comp.c", line 11388: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  ARG2L_SET(REGNODE_p(ret), internal_argval);
                  ^

"re_comp.c", line 11686: 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 11686: 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 14786: 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 14786: 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 14816: 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 14817: 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 19072: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
          ANYOF_POSIXL_SET_TO_BITMAP(REGNODE_p(ret), posixl);
          ^

"re_comp.c", line 19143: 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 19164: 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 19633: 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 19650: 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 19650: 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 19809: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          ARG_SET(REGNODE_p(scan), val - scan);
          ^

"re_comp.c", line 19921: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(REGNODE_p(scan), val - scan);
  	^

"re_comp.c", line 19942: 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 19952: 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 20229: 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 20253: 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 20281: 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 20281: 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 20309: 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 20331: 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 20331: 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 20332: 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 20334: 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 20370: 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 20401: 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 20556: 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 20558: 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 21691: 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 21696: 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 21928: 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 4146: warning #4276-D: relational operator ">" always evaluates to 'false'
              Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
              ^

"re_comp.c", line 4216: 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 4221: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 4226: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 5112: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Zero(RExC_study_chunk_recursed, RExC_study_chunk_recursed_bytes, U8);
                          ^

"re_comp.c", line 5114: 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 6426: warning #4276-D: relational operator ">" always evaluates to 'false'
      Renewc(RExC_rxi->data,
      ^

"re_comp.c", line 6430: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Renew(RExC_rxi->data->what, count + n, U8);
  	^

"re_comp.c", line 6432: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(RExC_rxi->data->what, n, U8);
  	^

"re_comp.c", line 6434: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(s, RExC_rxi->data->what + count, n, U8);
      ^

"re_comp.c", line 6614: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newx(dst, *plen_p + variant_under_utf8_count(src, src + *plen_p) + 1, U8);
      ^

"re_comp.c", line 6974: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(newpat, newlen, char);
  	^

"re_comp.c", line 7250: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(name, p, len, char);
          ^

"re_comp.c", line 7265: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(RExC_precomp, p, pat_len, char);
      ^

"re_comp.c", line 7657: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newxc(RExC_rxi, sizeof(regexp_internal) + RExC_size, char, regexp_internal);
      ^

"re_comp.c", line 7661: warning #4276-D: relational operator ">" always evaluates to 'false'
      Zero(RExC_rxi, sizeof(regexp_internal) + RExC_size, char);
      ^

"re_comp.c", line 7839: warning #4276-D: relational operator ">" always evaluates to 'false'
          Newx(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 7851: warning #4276-D: relational operator ">" always evaluates to 'false'
          Zero(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 19539: warning #4276-D: relational operator ">" always evaluates to 'false'
      Renewc(RExC_rxi,
      ^

"re_comp.c", line 21187: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat1, buf, l1 , char);
      ^

"re_comp.c", line 21188: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat2, buf + l1, l2 , char);
      ^

"re_comp.c", line 21197: 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;
  	^

[2019-04-15 07:21:29+0200] Skip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2019-04-15 07:21:29+0200] 
[2019-04-15 07:21:29+0200]  Tests start here:
[2019-04-15 07:21:29+0200] TSTENV = stdio	
No saved state, selection will be empty
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--15675 line 2.
Redefining sub Data::ok at -e line 1.
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
# Will use Digest::MD5
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
[2019-04-15 07:36:18+0200] 
[2019-04-15 07:36:18+0200] All tests successful.
[2019-04-15 07:36:18+0200] ../cpan/Module-Metadata/t/extract-version.t.................PASSED
[2019-04-15 07:36:18+0200]     7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47
[2019-04-15 07:36:18+0200]     51, 55, 59, 63, 67, 71, 75, 79, 83, 87
[2019-04-15 07:36:18+0200]     91, 95, 99, 106, 110, 114, 118, 122, 126
[2019-04-15 07:36:18+0200]     130, 134, 138, 142, 149, 153, 157, 161
[2019-04-15 07:36:18+0200]     165, 169, 173, 177, 181, 185, 195, 199
[2019-04-15 07:36:18+0200]     203
[2019-04-15 07:36:18+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2019-04-15 07:36:18+0200]     9, 18
[2019-04-15 07:36:18+0200] Archived results...
[2019-04-15 07:36:18+0200] TSTENV = perlio	
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

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.  
# Will use Digest::MD5
# 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.
Cannot figure out an encoding to use at t/use-Encode-Alias.t line 5.
[2019-04-15 07:49:00+0200] 
[2019-04-15 07:49:00+0200] All tests successful.
[2019-04-15 07:49:00+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2019-04-15 07:49:00+0200]     9, 18
[2019-04-15 07:49:00+0200] ../cpan/Module-Metadata/t/extract-version.t.................PASSED
[2019-04-15 07:49:00+0200]     7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47
[2019-04-15 07:49:00+0200]     51, 55, 59, 63, 67, 71, 75, 79, 83, 87
[2019-04-15 07:49:00+0200]     91, 95, 99, 106, 110, 114, 118, 122, 126
[2019-04-15 07:49:00+0200]     130, 134, 138, 142, 149, 153, 157, 161
[2019-04-15 07:49:00+0200]     165, 169, 173, 177, 181, 185, 195, 199
[2019-04-15 07:49:00+0200]     203
[2019-04-15 07:49:00+0200] Archived results...
[2019-04-15 07:49:00+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;
  	^

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.
# Will use Digest::MD5
# Connected to 127.0.0.1
syswrite() isn't allowed on :utf8 handles at t/Socket.t line 47.
# Looks like your test exited with 255 just after 2.
make: *** [test_harness] Error 1

error while running harness target 'test_harness': 2 at /pro/3gl/CPAN/smoke/lib/Test/Smoke/App/RunSmoke.pm line 118.
[2019-04-15 08:01:44+0200] 
[2019-04-15 08:01:44+0200] ../lib/B/Deparse.t..........................................PASSED
[2019-04-15 08:01:44+0200]     2
[2019-04-15 08:01:44+0200] ../cpan/Module-Metadata/t/extract-version.t.................PASSED
[2019-04-15 08:01:44+0200]     7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47
[2019-04-15 08:01:44+0200]     51, 55, 59, 63, 67, 71, 75, 79, 83, 87
[2019-04-15 08:01:44+0200]     91, 95, 99, 106, 110, 114, 118, 122, 126
[2019-04-15 08:01:44+0200]     130, 134, 138, 142, 149, 153, 157, 161
[2019-04-15 08:01:44+0200]     165, 169, 173, 177, 181, 185, 195, 199
[2019-04-15 08:01:44+0200]     203
[2019-04-15 08:01:44+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2019-04-15 08:01:44+0200]     9, 18
[2019-04-15 08:01:44+0200] ../cpan/Socket/t/Socket.t...................................FAILED
[2019-04-15 08:01:44+0200]     Non-zero exit status: 255
[2019-04-15 08:01:44+0200] ../cpan/Socket/t/Socket.t...................................FAILED
[2019-04-15 08:01:44+0200]     Bad plan.  You planned 6 tests but ran 2.
[2019-04-15 08:01:44+0200] Archived results...
[2019-04-15 08:01:44+0200] Unskip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2019-04-15 08:01:44+0200] 
[2019-04-15 08:01:44+0200] Configuration: -Dusedevel -DDEBUGGING
[2019-04-15 08:01:44+0200] ------------------------------------------------------------------------------
[2019-04-15 08:01:44+0200] make distclean ...
[2019-04-15 08:02:23+0200] 
[2019-04-15 08:02:23+0200] Copy Policy.sh ...
[2019-04-15 08:02:23+0200] 
[2019-04-15 08:02:23+0200] Configure ...
5.29.10 <=> 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.  
[2019-04-15 08:03:44+0200] 
[2019-04-15 08:03:44+0200] make ...
"op.c", line 12449: warning #2111-D: statement is unreachable
          ((0) ? (void)0 : __assert("0", "op.c", 12449));  
          ^

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

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

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

"op.c", line 3215: 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", 3215)), ((((void*)(argp->p)) != 0) ? (void)0 : __assert("((void*)(argp->p)) != 0", "op.c", 3215)), (void)memcpy((char*)(p),(const char*)(argp->p), (l) * sizeof(char)));
                                                                                                                                                                                        ^

"op.c", line 12565: 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", 12565)), ((((void*)(s+2)) != 0) ? (void)0 : __assert("((void*)(s+2)) != 0", "op.c", 12565)), (void)memmove((char*)(s+1),(const char*)(s+2), (end - s - 1) * sizeof(char)));
  		                                                                                                                                                                                                        ^

"op.c", line 12734: 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", 12734)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "op.c", 12734)), (void)memcpy((char*)(tmpbuf+1),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"op.c", line 17191: 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*)(new_warnings)) != 0) ? (void)0 : __assert("((void*)(new_warnings)) != 0", "op.c", 17191)), ((((void*)(warnings)) != 0) ? (void)0 : __assert("((void*)(warnings)) != 0", "op.c", 17191)), (void)memcpy((char*)(new_warnings),(const char*)(warnings), (size) * sizeof(char)));
                                                                                                                                                                                     ^

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

"perl.c", line 4606: 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 1032: 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", 1032)), ((((void*)(bufptr)) != 0) ? (void)0 : __assert("((void*)(bufptr)) != 0", "toke.c", 1032)), (void)memmove((char*)(bufptr+len+highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1058: 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", 1058)), ((((void*)(bufptr)) != 0) ? (void)0 : __assert("((void*)(bufptr)) != 0", "toke.c", 1058)), (void)memmove((char*)(bufptr+len-highhalf),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1078: 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", 1078)), ((((void*)(bufptr)) != 0) ? (void)0 : __assert("((void*)(bufptr)) != 0", "toke.c", 1078)), (void)memmove((char*)(bufptr+len),(const char*)(bufptr), (PL_parser->bufend+1-bufptr) * sizeof(char)));
  	                                                                                                                                                                                                                                                     ^

"toke.c", line 1081: 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", 1081)), ((((void*)(pv)) != 0) ? (void)0 : __assert("((void*)(pv)) != 0", "toke.c", 1081)), (void)memcpy((char*)(bufptr),(const char*)(pv), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 1176: 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", 1176)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "toke.c", 1176)), (void)memmove((char*)(buf),(const char*)(ptr), (bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                             ^

"toke.c", line 1254: 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", 1254)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "toke.c", 1254)), (void)memmove((char*)(buf),(const char*)(ptr), (PL_parser->bufend+1-ptr) * sizeof(char)));
                                                                                                                                                                                                                                              ^

"toke.c", line 1806: 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 3406: 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", 3406)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 3406)), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                                  ^

"toke.c", line 3747: 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", 3747)), ((((void*)(orig_s)) != 0) ? (void)0 : __assert("((void*)(orig_s)) != 0", "toke.c", 3747)), (void)memcpy((char*)(d),(const char*)(orig_s), (e - orig_s + 1) * sizeof(char)));
                                                                                                                                                                                                                                       ^

"toke.c", line 3843: 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", 3843)), ((((void*)(initial_text)) != 0) ? (void)0 : __assert("((void*)(initial_text)) != 0", "toke.c", 3843)), (void)memcpy((char*)(d),(const char*)(initial_text), (initial_len) * sizeof(char)));
                                                                                                                                                                                                                                      ^

"toke.c", line 3894: 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", 3894)), ((((void*)(hex_string)) != 0) ? (void)0 : __assert("((void*)(hex_string)) != 0", "toke.c", 3894)), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                            ^

"toke.c", line 3915: 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", 3915)), ((((void*)(hex_string)) != 0) ? (void)0 : __assert("((void*)(hex_string)) != 0", "toke.c", 3915)), (void)memcpy((char*)(d),(const char*)(hex_string), (output_length) * sizeof(char)));
                                                                                                                                                                                                                                                ^

"toke.c", line 3984: 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", 3984)), ((((void*)(str)) != 0) ? (void)0 : __assert("((void*)(str)) != 0", "toke.c", 3984)), (void)memcpy((char*)(d),(const char*)(str), (len) * sizeof(char)));
  			                                                                                                                                                                            ^

"toke.c", line 4065: 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", 4065)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 4065)), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(U8)));
                                                                                                                                                                                      ^

"toke.c", line 4120: 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", 4120)); ((!((((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", 4120)); ((!(((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", 4120)); (((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", 4120)); ((!(((((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", 4120)); ((!(((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", 4120)); (((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 4864: 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 4943: 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 5063: 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", 5063)); ((!((((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", 5063)); ((!(((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", 5063)); (((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", 5063)); ((!(((((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", 5063)); ((!(((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", 5063)); (((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 5922: 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 6172: 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 7215: 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", 7215)), ((((void*)((PL_parser->tokenbuf))) != 0) ? (void)0 : __assert("((void*)((PL_parser->tokenbuf))) != 0", "toke.c", 7215)), (void)memcpy((char*)(tmpbuf+1),(const char*)((PL_parser->tokenbuf)), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"toke.c", line 7807: 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", 7807)), ((((void*)((PL_parser->bufptr))) != 0) ? (void)0 : __assert("((void*)((PL_parser->bufptr))) != 0", "toke.c", 7807)), (void)memcpy((char*)((PL_parser->tokenbuf)),(const char*)((PL_parser->bufptr)), (olen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"toke.c", line 9196: 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", 9196)), ((((void*)(w)) != 0) ? (void)0 : __assert("((void*)(w)) != 0", "toke.c", 9196)), (void)memcpy((char*)(tmpbuf+1),(const char*)(w), (s - w) * sizeof(char)));
  		                                                                                                                                                                                  ^

"toke.c", line 9377: 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", 9377)), ((((void*)(*s)) != 0) ? (void)0 : __assert("((void*)(*s)) != 0", "toke.c", 9377)), (void)memcpy((char*)(*d),(const char*)(*s), (t - *s) * sizeof(char)));
                                                                                                                                                                                                   ^

"toke.c", line 9411: 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 10073: 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", 10073)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 10073)), (void)memcpy((char*)(d),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"toke.c", line 10199: 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 10255: 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", 10255)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 10255)), (void)memmove((char*)(d),(const char*)(s), (bufend-s + 1) * sizeof(char)));
  	                                                                                                                                                                                                       ^

"toke.c", line 10347: 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 10434: 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", 10434)); ((!((((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", 10434)); ((!(((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", 10434)); (((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", 10434)); ((!(((((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", 10434)); ((!(((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", 10434)); (((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 10719: 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", 10719)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "toke.c", 10719)), (void)memcpy((char*)(termstr),(const char*)(s), (termlen) * sizeof(U8)));
  	                                                                                                                                                                                    ^

"toke.c", line 10888: 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", 10888)); ((!((((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", 10888)); ((!(((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", 10888)); (((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", 10888)); ((!(((((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", 10888)); ((!(((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", 10888)); (((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 12318: 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 3597: 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 3615: 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", 3615)), ((((void*)(trie ->bitmap)) != 0) ? (void)0 : __assert("((void*)(trie->bitmap)) != 0", "regcomp.c", 3615)), (void)memcpy((char*)(((struct regnode_charclass *)convert)->bitmap),(const char*)(trie ->bitmap), (((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                    ^

"regcomp.c", line 3615: 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", 3615)), ((((void*)(trie ->bitmap)) != 0) ? (void)0 : __assert("((void*)(trie->bitmap)) != 0", "regcomp.c", 3615)), (void)memcpy((char*)(((struct regnode_charclass *)convert)->bitmap),(const char*)(trie ->bitmap), (((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ^

"regcomp.c", line 3727: 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 3752: 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 3757: 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 3762: 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 4382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              (((((struct regnode_1 *)scan)->arg1)) = ((*(((struct regnode_string *)scan)->string) & mask)));
                  ^

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

"regcomp.c", line 4532: 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 4539: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((((n)->type) == 70) && (noff = ((((struct regnode_1 *)n)->arg1)))))
  		                                             ^

"regcomp.c", line 4543: 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 5064: 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 5065: 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 5343: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      (((((struct regnode_1 *)next)->arg1)) = ((*(((struct regnode_string *)next)->string) & mask)));
                          ^

"regcomp.c", line 5501: 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) - (pRExC_state ->emit_start));
                                                         ^

"regcomp.c", line 5504: 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) - (pRExC_state ->emit_start)) + 2;
                                                          ^

"regcomp.c", line 5507: 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 5548: 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 5551: 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) - (pRExC_state ->emit_start));
                                                             ^

"regcomp.c", line 5554: 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) - (pRExC_state ->emit_start))
                                                              ^

"regcomp.c", line 5601: 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 5841: 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 5844: 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 6154: 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 6158: 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 6161: 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 6168: 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 6217: 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 6416: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "regcomp.c", 6416));  
      ^

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

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

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

"regcomp.c", line 8325: 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) - (pRExC_state ->emit_start)))));
              ^

"regcomp.c", line 8325: 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) - (pRExC_state ->emit_start)))));
                                                                                    ^

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

"regcomp.c", line 11382: 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 *)((pRExC_state ->emit_start) + (ret)))->arg1))]=(void*)sv;
                                                     ^

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

"regcomp.c", line 11686: 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 (__builtin_expect(((PL_debug & 0x00100000) ? (_Bool)1 : (_Bool)0),(0)) || ((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 *)((pRExC_state ->emit_start) + (ret)))->arg1)), (IV)((((struct regnode_2L *)((pRExC_state ->emit_start) + (ret)))->arg2)));} while (0); } while (0);
                                                                                                                                                                                                                                                                                                                                                               ^

"regcomp.c", line 11686: 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 (__builtin_expect(((PL_debug & 0x00100000) ? (_Bool)1 : (_Bool)0),(0)) || ((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 *)((pRExC_state ->emit_start) + (ret)))->arg1)), (IV)((((struct regnode_2L *)((pRExC_state ->emit_start) + (ret)))->arg2)));} while (0); } while (0);
                                                                                                                                                                                                                                                                                                                                                                                                                                         ^

"regcomp.c", line 14786: 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", 14786)), (void)memset((char*)(((regnode_charclass*)(node))->bitmap),0,(((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                        ^

"regcomp.c", line 14786: 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", 14786)), (void)memset((char*)(((regnode_charclass*)(node))->bitmap),0,(((1 << 8) / 8)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ^

"regcomp.c", line 14816: 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 14817: 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 19072: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
          do { ((regnode_charclass_posixl*) (((pRExC_state ->emit_start) + (ret))))->classflags = (posixl); } while (0);
                ^

"regcomp.c", line 19143: 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 19164: 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 19215: 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 19633: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      do { (((((struct regnode_1 *)((pRExC_state ->emit_start) + (ptr)))->arg1)) = ((arg))); do { do { ((((pRExC_state ->emit_start) + (ptr)))->type) = op; ((((pRExC_state ->emit_start) + (ptr)))->next_off) = 0; } while (0); (ptr)++; } while (0); (ptr) += regarglen[op]; } while (0);
               ^

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

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

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

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

"regcomp.c", line 19942: 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 19952: 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 20229: 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 20253: 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)==82 || (op)==84)) ? ((regnode_charclass*)(o))->bitmap : (((reg_trie_data *)(trie))->bitmap)),0L,0L,0L,(0));
                                                                                     ^

"regcomp.c", line 20281: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
          U32 parno= ((o)->type) == 91 ? (U32)((((struct regnode_2L *)o)->arg2)) : ((((struct regnode_1 *)o)->arg1));
                                                 ^

"regcomp.c", line 20281: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          U32 parno= ((o)->type) == 91 ? (U32)((((struct regnode_2L *)o)->arg2)) : ((((struct regnode_1 *)o)->arg1));
                                                                                      ^

"regcomp.c", line 20309: 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 20331: 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 20331: 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 20332: 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 20334: 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 20370: 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 20411: 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 20556: 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 20558: 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 21162: 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 21691: 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 21696: 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 21928: 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 4146: 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", 4146)), ((((void*)((((struct regnode_string *)n)->string))) != 0) ? (void)0 : __assert("((void*)((((struct regnode_string *)n)->string))) != 0", "regcomp.c", 4146)), (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 4216: 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 4221: 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", 4221)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "regcomp.c", 4221)), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 4226: 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", 4226)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "regcomp.c", 4226)), (void)memcpy((char*)(d),(const char*)(s), (s_len) * sizeof(U8)));
                                                                                                                                                                                                        ^

"regcomp.c", line 5112: 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", 5112)), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                       ^

"regcomp.c", line 5114: 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", 5116)), ((((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", 5116)), (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 6426: 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 6430: 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 6432: 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 6434: 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", 6434)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "regcomp.c", 6434)), (void)memcpy((char*)((pRExC_state ->rxi)->data->what + count),(const char*)(s), (n) * sizeof(U8)));
                                                                                                                                                                        ^

"regcomp.c", line 6614: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 1)))) ? (size_t)(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 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 + S_variant_under_utf8_count(src, src + *plen_p) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                ^

"regcomp.c", line 6974: 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 7250: 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", 7250)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "regcomp.c", 7250)), (void)memcpy((char*)(p),(const char*)(name), (len) * sizeof(char)));
                                                                                                                                                                                      ^

"regcomp.c", line 7265: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(pat_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(pat_len)))) ? (size_t)(pat_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", 7265)), ((((void*)((pRExC_state ->precomp))) != 0) ? (void)0 : __assert("((void*)((pRExC_state->precomp))) != 0", "regcomp.c", 7265)), (void)memcpy((char*)(p),(const char*)((pRExC_state ->precomp)), (pat_len) * sizeof(char)));
                                                                                                                                                                                              ^

"regcomp.c", line 7657: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (pRExC_state ->size)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (pRExC_state ->size))))) ? (size_t)(sizeof(regexp_internal) + (pRExC_state ->size)) : ((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) + (pRExC_state ->size))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                          ^

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

"regcomp.c", line 7839: 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 ->total_par)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) : ((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 ->total_par))*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"regcomp.c", line 7851: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) : ((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", 7852)), (void)memset((char*)((pRExC_state ->study_chunk_recursed)),0,((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                                                                                           ^

"regcomp.c", line 9098: 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", 9098)); ((!((((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", 9098)); ((!(((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", 9098)); (((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", 9098)); ((!(((((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", 9098)); ((!(((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", 9098)); (((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 10281: 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", 10281)), ((((void*)(((invlist)->sv_u . svu_pv))) != 0) ? (void)0 : __assert("((void*)(((invlist)->sv_u.svu_pv))) != 0", "regcomp.c", 10281)), (void)memcpy((char*)(((new_invlist)->sv_u . svu_pv)),(const char*)(((invlist)->sv_u . svu_pv)), (physical_length) * sizeof(char)));
                                                                                                                                                                                                                      ^

"regcomp.c", line 19539: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode))))) ? (size_t)(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * 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_safesysrealloc((void *)((pRExC_state ->rxi)),(size_t)((sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"regcomp.c", line 21187: 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", 21187)), ((((void*)(pat1)) != 0) ? (void)0 : __assert("((void*)(pat1)) != 0", "regcomp.c", 21187)), (void)memcpy((char*)(buf),(const char*)(pat1), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 21188: 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", 21188)), ((((void*)(pat2)) != 0) ? (void)0 : __assert("((void*)(pat2)) != 0", "regcomp.c", 21188)), (void)memcpy((char*)(buf + l1),(const char*)(pat2), (l2) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 21197: 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", 21197)), ((((void*)(message)) != 0) ? (void)0 : __assert("((void*)(message)) != 0", "regcomp.c", 21197)), (void)memcpy((char*)(buf),(const char*)(message), (l1) * sizeof(char)));
                                                                                                                                                                               ^

"regcomp.c", line 22591: warning #4276-D: relational operator ">" always evaluates to 'false'
      (lookup_name = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(name_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(name_len)))) ? (size_t)(name_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)((name_len)*sizeof(char))))));
                                                                                                                                                                                                                ^

"regcomp.c", line 22778: warning #4276-D: relational operator ">" always evaluates to 'false'
                          (this_string = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(total_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(total_len + 1)))) ? (size_t)(total_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((total_len + 1),sizeof(char)))));
                                                                                                                                                                                                                                                   ^

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

"regcomp.c", line 23425: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(strlen(cur_ptr) - excess_leading_zeros + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(strlen(cur_ptr) - excess_leading_zeros + 1)))) ? (size_t)(strlen(cur_ptr) - excess_leading_zeros + 1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), ((((void*)(cur_ptr)) != 0) ? (void)0 : __assert("((void*)(cur_ptr)) != 0", "regcomp.c", 23429)), ((((void*)(cur_ptr + excess_leading_zeros)) != 0) ? (void)0 : __assert("((void*)(cur_ptr + excess_leading_zeros)) != 0", "regcomp.c", 23429)), (void)memmove((char*)(cur_ptr),(const char*)(cur_ptr + excess_leading_zeros), (strlen(cur_ptr) - excess_leading_zeros + 1) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                   ^

"dump.c", line 1968: 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 2673: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "dump.c", 2673));  
              ^

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

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

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

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

"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 2029: 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", 2029)), ((((void*)(bits)) != 0) ? (void)0 : __assert("((void*)(bits)) != 0", "util.c", 2029)), (void)memcpy((char*)((buffer + 1)),(const char*)(bits), (size) * sizeof(char)));
                                                                                                                                                                                     ^

"util.c", line 2031: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(19 - size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(19 - size)))) ? (size_t)(19 - 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", 2031)), (void)memset((char*)((char *)(buffer + 1) + size),0,(19 - size) * sizeof(char)));
  	                                                                                                                                                                                              ^

"util.c", line 2132: 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", 2132)), ((((void*)(environ[j])) != 0) ? (void)0 : __assert("((void*)(environ[j])) != 0", "util.c", 2132)), (void)memcpy((char*)(tmpenv[j]),(const char*)(environ[j]), (len+1) * sizeof(char)));
                                                                                                                                                                                                    ^

"util.c", line 2163: 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", 2163)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2163)), (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", 2163)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2163)), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                         ^

"util.c", line 2163: 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", 2163)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2163)), (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", 2163)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2163)), (void)memcpy((char*)(environ[i]+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(environ[i]+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ^

"util.c", line 2189: 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", 2189)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2189)), (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", 2189)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2189)), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                             ^

"util.c", line 2189: 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", 2189)), ((((void*)(nam)) != 0) ? (void)0 : __assert("((void*)(nam)) != 0", "util.c", 2189)), (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", 2189)), ((((void*)(val)) != 0) ? (void)0 : __assert("((void*)(val)) != 0", "util.c", 2189)), (void)memcpy((char*)(new_env+(nlen+1)),(const char*)(val), (vlen) * sizeof(char))); *(new_env+(nlen+1+vlen)) = '\0';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ^

"util.c", line 3825: 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 3852: 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 3868: 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 590: 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 890: 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 920: 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 967: 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 1016: 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 1073: 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 1872: 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 1911: 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 2785: 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 3867: 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 3868: 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 359: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((hv)->sv_flags & 0xff)) == (svtype)0xff)
                                            ^

"hv.c", line 590: 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 814: 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 1431: 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 1480: 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", 1480)), (void)memset((char*)(&a[oldsize * sizeof(HE*)]),0,((newsize -oldsize) * sizeof(HE*)) * sizeof(char)));	 
                                                                                                                                                                                                                                                                         ^

"hv.c", line 1569: 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 1607: 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 2240: 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 2244: 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 3129: 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 3135: 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", 3135)), ((((void*)(str)) != 0) ? (void)0 : __assert("((void*)(str)) != 0", "hv.c", 3135)), (void)memcpy((char*)((hek)->hek_key),(const char*)(str), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"hv.c", line 3278: 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 3403: 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 3579: 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 3615: 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", 3615)), ((((void*)(value_p)) != 0) ? (void)0 : __assert("((void*)(value_p)) != 0", "hv.c", 3615)), (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 1819: 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 2584: 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 2738: 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 3093: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "pp_hot.c", 3093));  
      ^

"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 3302: 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", 3302)); ((!((((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", 3302)); ((!(((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", 3302)); (((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", 3302)); ((!(((((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", 3302)); ((!(((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", 3302)); (((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 3311: 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", 3311)); ((!((((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", 3311)); ((!(((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", 3311)); (((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", 3311)); ((!(((((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", 3311)); ((!(((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", 3311)); (((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 4306: 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", 4306)), ((((void*)(c)) != 0) ? (void)0 : __assert("((void*)(c)) != 0", "pp_hot.c", 4306)), (void)memcpy((char*)(m),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4311: 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", 4311)), ((((void*)(d)) != 0) ? (void)0 : __assert("((void*)(d)) != 0", "pp_hot.c", 4311)), (void)memmove((char*)(m),(const char*)(d), (i) * sizeof(char)));
  		                                                                                                                                                                          ^

"pp_hot.c", line 4321: 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", 4321)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "pp_hot.c", 4321)), (void)memmove((char*)(d - i),(const char*)(s), (i) * sizeof(char)));
                                                                                                                                                                                            ^

"pp_hot.c", line 4324: 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", 4324)), ((((void*)(c)) != 0) ? (void)0 : __assert("((void*)(c)) != 0", "pp_hot.c", 4324)), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4342: 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", 4342)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "pp_hot.c", 4342)), (void)memmove((char*)(d),(const char*)(s), (i) * sizeof(char)));
  			                                                                                                                                                                      ^

"pp_hot.c", line 4346: 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", 4346)), ((((void*)(c)) != 0) ? (void)0 : __assert("((void*)(c)) != 0", "pp_hot.c", 4346)), (void)memcpy((char*)(d),(const char*)(c), (clen) * sizeof(char)));
  		                                                                                                                                                                                   ^

"pp_hot.c", line 4357: 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", 4357)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "pp_hot.c", 4357)), (void)memmove((char*)(d),(const char*)(s), (i+1) * sizeof(char)));		 
  		                                                                                                                                                                            ^

"sv.c", line 1458: 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", 1458)); (((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 16384: warning #2111-D: statement is unreachable
  	((0) ? (void)0 : __assert("0", "sv.c", 16384));  
  	^

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

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

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

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

"sv.c", line 1107: 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 1342: 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", 1342)), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                    ^

"sv.c", line 1412: 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", 1412)), (void)memset((char*)(new_body),0,(new_type_details->body_size) * sizeof(char)));
  	                                                                                                                                                                                                                                                        ^

"sv.c", line 1433: 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", 1434)), ((((void*)((char *)old_body + offset)) != 0) ? (void)0 : __assert("((void*)((char *)old_body + offset)) != 0", "sv.c", 1434)), (void)memcpy((char*)((char *)new_body + offset),(const char*)((char *)old_body + offset), (length) * sizeof(char)));
  	                                                                                                                                                                                         ^

"sv.c", line 1518: 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", 1518)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 1518)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (((XPV*) (sv)->sv_any)->xpv_cur+1) * sizeof(char)));
                                                                                                                                                                                                                                                                         ^

"sv.c", line 1601: 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", 1601)), ((((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", 1601)), (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 3086: 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 3149: 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", 3149)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 3149)), (void)memmove((char*)(s),(const char*)(ptr), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 4442: 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", 4442)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 4442)), (void)memcpy((char*)(((dstr)->sv_u . svu_pv)),(const char*)(ptr), (len + 1) * sizeof(char)));
                                                                                                                                                                                                      ^

"sv.c", line 4697: 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", 4697)), ((((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", 4697)), (void)memmove((char*)(((dstr)->sv_u . svu_pv)),(const char*)(((const char*)(0 + (sstr)->sv_u . svu_pv))), (cur) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 4961: 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", 4961)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 4961)), (void)memmove((char*)(dptr),(const char*)(ptr), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 5012: 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", 5012)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 5012)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 5143: 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", 5143)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 5143)), (void)memcpy((char*)(new_ptr),(const char*)(ptr), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 5144: 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 5217: 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", 5217)), ((((void*)(pvx)) != 0) ? (void)0 : __assert("((void*)(pvx)) != 0", "sv.c", 5217)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (cur) * sizeof(char)));
                                                                                                                                                                                              ^

"sv.c", line 5400: 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", 5400)), ((((void*)(pvx)) != 0) ? (void)0 : __assert("((void*)(pvx)) != 0", "sv.c", 5400)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(pvx), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 5495: 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", 5495)), ((((void*)(sstr)) != 0) ? (void)0 : __assert("((void*)(sstr)) != 0", "sv.c", 5495)), (void)memmove((char*)(((dsv)->sv_u . svu_pv) + dlen),(const char*)(sstr), (slen) * sizeof(char)));
                                                                                                                                                                                       ^

"sv.c", line 5587: 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", 5587)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 5587)), (void)memmove((char*)(((sv)->sv_u . svu_pv)+tlen),(const char*)(ptr), (len+1) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 6366: 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", 6366)), (void)memset((char*)(((bigstr)->sv_u . svu_pv)+curlen),0,(offset+len-curlen) * sizeof(char)));
  	                                                                                                                                                                                                                      ^

"sv.c", line 6380: 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", 6380)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6380)), (void)memmove((char*)(big+offset),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 6386: 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", 6386)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6386)), (void)memmove((char*)(((bigstr)->sv_u . svu_pv)+offset),(const char*)(little), (len) * sizeof(char)));
  	                                                                                                                                                                            ^

"sv.c", line 6402: 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", 6402)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6402)), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6407: 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", 6407)), ((((void*)(midend)) != 0) ? (void)0 : __assert("((void*)(midend)) != 0", "sv.c", 6407)), (void)memmove((char*)(mid),(const char*)(midend), (i) * sizeof(char)));
  	                                                                                                                                                                          ^

"sv.c", line 6416: 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", 6416)), ((((void*)(big)) != 0) ? (void)0 : __assert("((void*)(big)) != 0", "sv.c", 6416)), (void)memmove((char*)(midend - i),(const char*)(big), (i) * sizeof(char)));
  	                                                                                                                                                                      ^

"sv.c", line 6419: 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", 6419)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6419)), (void)memmove((char*)(mid),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"sv.c", line 6424: 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", 6424)), ((((void*)(little)) != 0) ? (void)0 : __assert("((void*)(little)) != 0", "sv.c", 6424)), (void)memmove((char*)(midend),(const char*)(little), (littlelen) * sizeof(char)));
  	                                                                                                                                                                                              ^

"sv.c", line 6567: 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", 6567));
  	                                    ^

"sv.c", line 8701: 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", 8701)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 8701)), (void)memcpy((char*)(bp),(const char*)(ptr), (got) * sizeof(unsigned char)));
                                                                                                                                                                                                                    ^

"sv.c", line 8707: 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", 8707)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 8707)), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(unsigned char)));
                                                                                                                                                                                                                ^

"sv.c", line 8714: 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", 8714)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "sv.c", 8714)), (void)memcpy((char*)(bp),(const char*)(ptr), (cnt) * sizeof(char)));	      
  	                                                                                                                                                                                    ^

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

"sv.c", line 10101: 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", 10101)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 10101)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"sv.c", line 10998: 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", 10998)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "sv.c", 10998)), (void)memcpy((char*)(end),(const char*)(buf), (len) * sizeof(char)));
                                                                                                                                                                                  ^

"sv.c", line 11734: 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", 11734)), ((((void*)(v0)) != 0) ? (void)0 : __assert("((void*)(v0)) != 0", "sv.c", 11734)), (void)memmove((char*)(v0 + 1),(const char*)(v0), (vn - 1) * sizeof(char)));
                                                                                                                                                                                                               ^

"sv.c", line 11777: 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", 11777)), ((((void*)(r)) != 0) ? (void)0 : __assert("((void*)(r)) != 0", "sv.c", 11777)), (void)memcpy((char*)(p),(const char*)(r), (n) * sizeof(char)));
                                                                                                                                                                                        ^

"sv.c", line 11826: 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", 11826)), ((((void*)(zerox)) != 0) ? (void)0 : __assert("((void*)(zerox)) != 0", "sv.c", 11826)), (void)memmove((char*)(zerox + nzero),(const char*)(zerox), (nmove) * sizeof(char)));
                                                                                                                                                                                                ^

"sv.c", line 11831: 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", 11832)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "sv.c", 11832)), (void)memmove((char*)(buf + gap),(const char*)(buf), (elen) * sizeof(char)));
                                                                                                                                                                                             ^

"sv.c", line 13090: 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 13332: 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", 13332)), ((((void*)(eptr)) != 0) ? (void)0 : __assert("((void*)(eptr)) != 0", "sv.c", 13332)), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 13353: 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", 13353)), ((((void*)(eptr)) != 0) ? (void)0 : __assert("((void*)(eptr)) != 0", "sv.c", 13353)), (void)memcpy((char*)(s),(const char*)(eptr), (elen) * sizeof(char)));
                                                                                                                                                                                                 ^

"sv.c", line 16016: 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", 16016)), ((((void*)(s)) != 0) ? (void)0 : __assert("((void*)(s)) != 0", "sv.c", 16016)), (void)memmove((char*)(((sv)->sv_u . svu_pv)),(const char*)(s), (len + 1) * sizeof(char)));
  	                                                                                                                                                                                            ^

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

"pp.c", line 7007: 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 3991: 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", 3991)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 3991)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  	                                                                                                                                                                                     ^

"pp.c", line 4004: 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", 4004)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4004)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (tculen) * sizeof(U8)));
  		                                                                                                                                                                                 ^

"pp.c", line 4021: 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", 4021)), ((((void*)(s + 1)) != 0) ? (void)0 : __assert("((void*)(s + 1)) != 0", "pp.c", 4021)), (void)memcpy((char*)(d + 1),(const char*)(s + 1), (slen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4162: 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", 4162)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4162)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
                                                                                                                                                                                             ^

"pp.c", line 4514: 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", 4514)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4514)), (void)memcpy((char*)(d),(const char*)(tmpbuf), (ulen) * sizeof(U8)));
  	                                                                                                                                                                               ^

"pp.c", line 4728: 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", 4728)), ((((void*)(tmpbuf)) != 0) ? (void)0 : __assert("((void*)(tmpbuf)) != 0", "pp.c", 4728)), (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 4915: 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 4915: 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 4940: 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 801: 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", 801)), ((((void*)(source)) != 0) ? (void)0 : __assert("((void*)(source)) != 0", "pp_ctl.c", 801)), (void)memcpy((char*)(t),(const char*)(source), (to_copy) * sizeof(char)));
  		                                                                                                                                                                                        ^

"pp_sys.c", line 2945: 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 1824: 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", 1824)), (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 2337: 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 3215: 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", 3215)), ((((void*)(shm + mpos)) != 0) ? (void)0 : __assert("((void*)(shm + mpos)) != 0", "doio.c", 3215)), (void)memcpy((char*)(mbuf),(const char*)(shm + mpos), (msize) * sizeof(char)));
  	                                                                                                                                                                                  ^

"doio.c", line 3227: 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", 3227)), ((((void*)(mbuf)) != 0) ? (void)0 : __assert("((void*)(mbuf)) != 0", "doio.c", 3227)), (void)memcpy((char*)(shm + mpos),(const char*)(mbuf), (n) * sizeof(char)));
  	                                                                                                                                                                      ^

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

"regexec.c", line 2157: 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 2164: 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 2171: 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_span_end_mask((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 += (utf8_target) ? PL_utf8skip[*(const U8*)(s)] : 1; previous_occurrence_end = s; };
                                                                                                   ^

"regexec.c", line 2832: 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 2870: 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 4122: 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 4406: warning #2111-D: statement is unreachable
                          ((0) ? (void)0 : __assert("0", "regexec.c", 4406));  
                          ^

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

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

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

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

"regexec.c", line 5956: 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 5957: 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 6104: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 6104));  
  	    ^

"regexec.c", line 6134: 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 6158: 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 6224: warning #2111-D: statement is unreachable
  		((0) ? (void)0 : __assert("0", "regexec.c", 6224));  
  		^

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

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

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

"regexec.c", line 7113: 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 7183: 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 7195: 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 7256: 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 7496: 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 7564: warning #2111-D: statement is unreachable
  		((0) ? (void)0 : __assert("0", "regexec.c", 7564));  
  		^

"regexec.c", line 7651: 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
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7693: 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 7694: 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 7701: 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 7705: 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 7715: 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 7725: 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 7740: 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 7842: 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 7865: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 7865));  
  	    ^

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

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

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

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

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

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

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

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

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

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

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

"regexec.c", line 8123: 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 8144: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8144));  
  	    ^

"regexec.c", line 8148: 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 8152: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8152));  
              ^

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

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

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

"regexec.c", line 8278: 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)] == 35) || PL_regkind[((st->u . curlym . B)->type)] == 60 ) || ( ((st->u . curlym . B)->type) == 56 || (((st->u . curlym . B)->type) == 57 && !( ( ( 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) == 77 || ((st->u . curlym . B)->type) == 74 || ((st->u . curlym . B)->type) == 72 || ((st->u . curlym . B)->type) == 50 || ((st->u . curlym . B)->type) == 78 || ((st->u . curlym . B)->type) == 98 || (PL_regkind[((st->u . curlym . B)->type)] == 51 && ((((struct regnode_2 *)st->u . curlym . B)->arg1)) > 0) )) {
  		                                                                                                                                                                                                                                                                                                                    ^

"regexec.c", line 8281: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8281: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8355: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8355));  
  	    ^

"regexec.c", line 8441: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (! ( (PL_regkind[((next)->type)] == 35) || PL_regkind[((next)->type)] == 60 ) && ! ( ((next)->type) == 56 || (((next)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)next)->arg1))) + 1 ) ) ) ) || ((next)->type) == 77 || ((next)->type) == 74 || ((next)->type) == 72 || ((next)->type) == 50 || ((next)->type) == 78 || ((next)->type) == 98 || (PL_regkind[((next)->type)] == 51 && ((((struct regnode_2 *)next)->arg1)) > 0) )) {
                                                                                                                                                                                                                                                                              ^

"regexec.c", line 8448: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8448: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8529: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8529));  
  	    ^

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

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

"regexec.c", line 8814: 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 8828: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8828));  
  	    ^

"regexec.c", line 8863: 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 8873: 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 8884: 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 8887: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8887));  
  	    ^

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

"regexec.c", line 8897: 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 8907: warning #2111-D: statement is unreachable
  	    ((0) ? (void)0 : __assert("0", "regexec.c", 8907));  
  	    ^

"regexec.c", line 8913: 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 8918: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8918));  
              ^

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

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

"regexec.c", line 8957: 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 8990: warning #2111-D: statement is unreachable
              ((0) ? (void)0 : __assert("0", "regexec.c", 8990));  
              ^

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

"regexec.c", line 9548: 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 *) this_eol, (U8) ((((struct regnode_1 *)p)->arg1)), ((p)->flags));
                                                                                     ^

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

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

"regexec.c", line 9862: 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 9875: 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 9879: 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 9917: 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 9949: 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 10012: 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) ('i')) >> 3) ] ) & (1U << (('i') & 7))) ? (_Bool)1 : (_Bool)0)) {
  		                ^

"regexec.c", line 10017: 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) ('I')) >> 3) ] ) & (1U << (('I') & 7))) ? (_Bool)1 : (_Bool)0)) {
  		                ^

"regexec.c", line 3160: 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", 3160)), ((((void*)(strbeg + min)) != 0) ? (void)0 : __assert("((void*)(strbeg + min)) != 0", "regexec.c", 3160)), (void)memcpy((char*)(prog->subbeg),(const char*)(strbeg + min), (sublen) * sizeof(char)));
                                                                                                                                                                                                   ^

"regexec.c", line 4227: 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", 4227)), ((((void*)(pat)) != 0) ? (void)0 : __assert("((void*)(pat)) != 0", "regexec.c", 4227)), (void)memcpy((char*)(c1_utf8),(const char*)(pat), (PL_utf8skip[*(const U8*)(pat)]) * sizeof(U8)));
                                                                                                                                                                                                                                                                       ^

"regexec.c", line 4228: 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", 4228)), ((((void*)(pat)) != 0) ? (void)0 : __assert("((void*)(pat)) != 0", "regexec.c", 4228)), (void)memcpy((char*)(c2_utf8),(const char*)(pat), (PL_utf8skip[*(const U8*)(pat)]) * sizeof(U8)));
                                                                                                                                                                                                                                                                       ^

"regexec.c", line 7978: 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 7981: 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", 7981)), (void)memset((char*)(aux->poscache),0,(size) * sizeof(char)));
  			                                                                                                                                                                               ^

"regexec.c", line 7985: 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 3305: warning #2111-D: statement is unreachable
      ((0) ? (void)0 : __assert("0", "utf8.c", 3305));  
      ^

"utf8.c", line 1101: 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 2593: 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 2630: 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 2668: warning #4276-D: relational operator ">" always evaluates to 'false'
      (d = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((*lenp) + S_variant_under_utf8_count(s, send) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((*lenp) + S_variant_under_utf8_count(s, send) + 1)))) ? (size_t)((*lenp) + S_variant_under_utf8_count(s, send) + 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) + S_variant_under_utf8_count(s, send) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                             ^

"utf8.c", line 3060: 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", 3061)), ((((void*)("\xC5\xBF" "\xC5\xBF")) != 0) ? (void)0 : __assert("((void*)(\"\\xC5\\xBF\" \"\\xC5\\xBF\")) != 0", "utf8.c", 3061)), (void)memcpy((char*)(p),(const char*)("\xC5\xBF" "\xC5\xBF"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                            ^

"utf8.c", line 3538: 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", 3538)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "utf8.c", 3538)), (void)memcpy((char*)(ustrp),(const char*)(p), (len) * sizeof(U8)));
                                                                                                                                                                                      ^

"utf8.c", line 3669: 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", 3669)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "utf8.c", 3669)), (void)memcpy((char*)(ustrp),(const char*)(p), (*lenp) * sizeof(char)));
                                                                                                                                                                                        ^

"utf8.c", line 4196: 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", 4196)), ((((void*)(p)) != 0) ? (void)0 : __assert("((void*)(p)) != 0", "utf8.c", 4196)), (void)memcpy((char*)(ustrp),(const char*)(p), (*lenp) * sizeof(char)));
  		                                                                                                                                                                                      ^

"utf8.c", line 4228: 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", 4229)), ((((void*)("\xC5\xBF" "\xC5\xBF")) != 0) ? (void)0 : __assert("((void*)(\"\\xC5\\xBF\" \"\\xC5\\xBF\")) != 0", "utf8.c", 4229)), (void)memcpy((char*)(ustrp),(const char*)("\xC5\xBF" "\xC5\xBF"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                    ^

"utf8.c", line 4237: 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", 4237)), ((((void*)("\xEF\xAC\x86")) != 0) ? (void)0 : __assert("((void*)(\"\\xEF\\xAC\\x86\")) != 0", "utf8.c", 4237)), (void)memcpy((char*)(ustrp),(const char*)("\xEF\xAC\x86"), (*lenp) * sizeof(U8)));
                                                                                                                                                                                    ^

"utf8.c", line 4568: 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", 4568)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "utf8.c", 4568)), (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 2074: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
      ((PerlIOBuf *)(*(f)))->posn = old;
       ^

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

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

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

"perlio.c", line 3959: 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 4021: 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 4093: 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 4105: 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 4164: 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 4215: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	    PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                    ^

"perlio.c", line 4225: 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 4256: 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
      PerlIOBuf * const b = ((PerlIOBuf *)(*(f)));
                             ^

"perlio.c", line 4281: 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 4290: 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 4301: 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 4320: 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 4329: 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 4419: 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 4577: 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 4586: warning #4232-D: conversion from "PerlIO" to a more strictly aligned type "PerlIOBuf *" may cause misaligned access
  	PerlIOBuf *b = ((PerlIOBuf *)(*(f)));
  	                ^

"perlio.c", line 4632: 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 4636: 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 4704: 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 4705: 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 4762: 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 4809: 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 1150: 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 2098: 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", 2098)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "perlio.c", 2098)), (void)memcpy((char*)(buf),(const char*)(ptr), (take) * sizeof(unsigned char)));
  		                                                                                                                                                                                                 ^

"perlio.c", line 4067: 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", 4067)), ((((void*)(ptr)) != 0) ? (void)0 : __assert("((void*)(ptr)) != 0", "perlio.c", 4067)), (void)memcpy((char*)(b->buf),(const char*)(ptr), (avail) * sizeof(unsigned char)));
  	                                                                                                                                                                                                        ^

"perlio.c", line 4148: 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", 4148)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "perlio.c", 4148)), (void)memcpy((char*)(b->ptr),(const char*)(buf), (avail) * sizeof(unsigned char)));
  		                                                                                                                                                                                                    ^

"perlio.c", line 4190: 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", 4190)), ((((void*)(buf)) != 0) ? (void)0 : __assert("((void*)(buf)) != 0", "perlio.c", 4190)), (void)memcpy((char*)(b->ptr),(const char*)(buf), (avail) * sizeof(unsigned char)));
  	                                                                                                                                                                                                        ^

"perlio.c", line 4307: 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 1619: 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 151: 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", 151)), ((((void*)(s + 1)) != 0) ? (void)0 : __assert("((void*)(s + 1)) != 0", "locale.c", 151)), (void)memmove((char*)(locs),(const char*)(s + 1), (len) * sizeof(char)));
  		                                                                                                                                                                            ^

"locale.c", line 313: 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 2383: 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 2387: 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 2391: 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", 2391)), ((((void*)(string)) != 0) ? (void)0 : __assert("((void*)(string)) != 0", "locale.c", 2391)), (void)memcpy((char*)(*buf + offset),(const char*)(string), (string_size - offset) * sizeof(char)));
                                                                                                                                                                                                                                     ^

"locale.c", line 4006: 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 4138: 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 4159: 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 4182: 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 4316: 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 4341: 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 4593: 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 4597: 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", 4597)), ((((void*)(save_input_locale)) != 0) ? (void)0 : __assert("((void*)(save_input_locale)) != 0", "locale.c", 4597)), (void)memcpy((char*)(delimited + 1),(const char*)(save_input_locale), (input_name_len) * sizeof(char)));
                                                                                                                                                                                                                   ^

"locale.c", line 4620: 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", 4622)), ((((void*)(utf8ness_cache)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache)) != 0", "locale.c", 4622)), (void)memmove((char*)(utf8ness_cache + input_name_len_with_overhead),(const char*)(utf8ness_cache), (name_pos - utf8ness_cache) * sizeof(char)));
                                                                                                                                                                                                                                                            ^

"locale.c", line 4623: 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", 4625)), ((((void*)(delimited)) != 0) ? (void)0 : __assert("((void*)(delimited)) != 0", "locale.c", 4625)), (void)memcpy((char*)(utf8ness_cache),(const char*)(delimited), (input_name_len_with_overhead - 1) * sizeof(char)));
                                                                                                                                                                                                                                                                                 ^

"locale.c", line 5048: 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", 5050)), ((((void*)(utf8ness_cache)) != 0) ? (void)0 : __assert("((void*)(utf8ness_cache)) != 0", "locale.c", 5050)), (void)memmove((char*)(utf8ness_cache + input_name_len_with_overhead),(const char*)(utf8ness_cache), (utf8ness_cache_len + 1) * sizeof(char)));
                                                                                                                                                                                                                                               ^

"locale.c", line 5053: 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", 5053)), ((((void*)(delimited)) != 0) ? (void)0 : __assert("((void*)(delimited)) != 0", "locale.c", 5053)), (void)memcpy((char*)(utf8ness_cache),(const char*)(delimited), (input_name_len_with_overhead - 1) * sizeof(char)));
                                                                                                                                                                                                                                                                             ^

"pp_pack.c", line 2019: 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 2020: 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", 2020)), ((((void*)(from_start)) != 0) ? (void)0 : __assert("((void*)(from_start)) != 0", "pp_pack.c", 2020)), (void)memcpy((char*)(to_start),(const char*)(from_start), (from_ptr-from_start) * sizeof(char)));
                                                                                                                                                                                                                                  ^

"pp_pack.c", line 2223: 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", 2223)), (void)memset((char*)(cur),0,(len) * sizeof(char)));
  			                                                                                                                                                                            ^

"pp_pack.c", line 2416: 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", 2416)), ((((void*)(aptr)) != 0) ? (void)0 : __assert("((void*)(aptr)) != 0", "pp_pack.c", 2416)), (void)memcpy((char*)(cur),(const char*)(aptr), (fromlen) * sizeof(char)));
  		                                                                                                                                                                                        ^

"pp_pack.c", line 2490: 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", 2490)), (void)memset((char*)(cur),0,(field_len) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"pp_pack.c", line 2565: 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", 2565)), (void)memset((char*)(cur),0,(field_len) * sizeof(char)));
  	                                                                                                                                                                                                  ^

"pp_pack.c", line 2900: 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", 2901)); ((!(((((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", 2901)); ((!(((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", 2901)); (((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", 2901)), ((((void*)(in)) != 0) ? (void)0 : __assert("((void*)(in)) != 0", "pp_pack.c", 2901)), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ^

"pp_pack.c", line 2933: 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", 2934)); ((!(((((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", 2934)); ((!(((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", 2934)); (((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", 2934)), ((((void*)(in)) != 0) ? (void)0 : __assert("((void*)(in)) != 0", "pp_pack.c", 2934)), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ^

"pp_pack.c", line 2948: 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 2953: 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", 2954)); ((!(((((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", 2954)); ((!(((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", 2954)); (((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", 2954)), ((((void*)(in)) != 0) ? (void)0 : __assert("((void*)(in)) != 0", "pp_pack.c", 2954)), (void)memcpy((char*)(cur),(const char*)(in), (glen) * sizeof(char))); (cur) += (glen); } } while (0); } while (0);
  		                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"pp_pack.c", line 3121: 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", 3121)), ((((void*)(hunk)) != 0) ? (void)0 : __assert("((void*)(hunk)) != 0", "pp_pack.c", 3121)), (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.  

lib/unicore/mktables: WARNING: \b{} algorithms (regen/mk_invlist.pl) need to
    be checked and possibly updated to Unicode 12.1.0.  Failing tests will be
    marked TODO; at lib/unicore/mktables line 20426, <DATA> line 393.
"op.c", line 12449: warning #2111-D: statement is unreachable
          ((0) ? (void)0 : __assert("0", "op.c", 12449));  
          ^

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

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

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

"op.c", line 3215: 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", 3215)), ((((void*)(argp->p)) != 0) ? (void)0 : __assert("((void*)(argp->p)) != 0", "op.c", 3215)), (void)memcpy((char*)(p),(const char*)(argp->p), (l) * sizeof(char)));
                                                                                                                                                                                        ^

"op.c", line 12565: 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", 12565)), ((((void*)(s+2)) != 0) ? (void)0 : __assert("((void*)(s+2)) != 0", "op.c", 12565)), (void)memmove((char*)(s+1),(const char*)(s+2), (end - s - 1) * sizeof(char)));
  		                                                                                                                                                                                                        ^

"op.c", line 12734: 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", 12734)), ((((void*)(name)) != 0) ? (void)0 : __assert("((void*)(name)) != 0", "op.c", 12734)), (void)memcpy((char*)(tmpbuf+1),(const char*)(name), (len) * sizeof(char)));
  	                                                                                                                                                                                ^

"op.c", line 17191: 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*)(new_warnings)) != 0) ? (void)0 : __assert("((void*)(new_warnings)) != 0", "op.c", 17191)), ((((void*)(warnings)) != 0) ? (void)0 : __assert("((void*)(warnings)) != 0", "op.c", 17191)), (void)memcpy((char*)(new_warnings),(const char*)(warnings), (size) * sizeof(char)));
                                                                                                                                                                                     ^

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

"perl.c", line 4606: 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 1310: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

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

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

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

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

"B.xs", line 2036: 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 2037: 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 913: warning #4276-D: relational operator ">" always evaluates to 'false'
  	    New(0, iname, namelen+28, char);
  	    ^

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

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

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

"Dumper.xs", line 1261: 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 3206: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"RealPPPort.c", line 4756: 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 533: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

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

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

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

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

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

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

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

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

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

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

"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 2017: warning #2128-D: loop is not reachable
      XSRETURN(1);
      ^

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

"POSIX.c", line 5043: 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 2843: 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 2913: 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 7973: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"Storable.xs", line 4032: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

"Storable.xs", line 4032: warning #4276-D: relational operator ">" always evaluates to 'false'
          WLEN(wlen2);			/* Must write an I32 for 64-bit machines */
          ^

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"Storable.xs", line 4202: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

"Storable.xs", line 4202: warning #4276-D: relational operator ">" always evaluates to 'false'
              WLEN(len);	/* Don't BER-encode, this should be rare */
              ^

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

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

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

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

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

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

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

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

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

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

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

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

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

"Storable.xs", line 4588: warning #4276-D: relational operator ">" always evaluates to 'false'
      WRITE( (unsigned char*) header, length);
      ^

"Storable.xs", line 4847: warning #4276-D: relational operator ">" always evaluates to 'false'
          New(10003, classname, len+1, char);
          ^

"Storable.xs", line 5050: warning #4276-D: relational operator ">" always evaluates to 'false'
              New(10003, classname, len+1, char);
              ^

"Storable.xs", line 5941: warning #4276-D: relational operator ">" always evaluates to 'false'
      New(10003, s, len+1, char);
      ^

"Storable.xs", line 6501: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);	/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 6635: warning #4276-D: relational operator ">" always evaluates to 'false'
              KBUFCHK((STRLEN)size);/* Grow hash key read pool if needed */
              ^

"Storable.xs", line 7006: warning #4276-D: relational operator ">" always evaluates to 'false'
          KBUFCHK((STRLEN)size);			/* Grow hash key read pool if needed */
          ^

"Storable.xs", line 7381: 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 2761 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 6437: warning #3215-D: function "Perl_to_utf8_lower" (declared at line 3787 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_lower(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6527: warning #3215-D: function "Perl_to_utf8_fold" (declared at line 3780 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_fold(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6617: warning #3215-D: function "Perl_to_utf8_upper" (declared at line 3801 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_upper(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6700: warning #3215-D: function "Perl_to_utf8_title" (declared at line 3794 of "../../proto.h") was declared deprecated
              resultant_cp = Perl_to_utf8_title(aTHX_ input, s, &len);
                             ^

"APItest.xs", line 6145: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(s, (U8 *) copy + offset, len, U8);
          ^

"APItest.xs", line 6160: 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 523: warning #2111-D: statement is unreachable
      return FALSE; /* Things like CNTRL are always below 256 */
      ^

"re_exec.c", line 2157: 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 2164: 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 2171: 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(utf8_target,
          ^

"re_exec.c", line 2832: 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 2870: 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 4122: 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 4406: warning #2111-D: statement is unreachable
                          NOT_REACHED; /* NOTREACHED */
                          ^

"re_exec.c", line 5847: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5853: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 5895: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                  && ! ANYOF_BITMAP_TEST(scan, nextchr))
                       ^

"re_exec.c", line 5902: warning #2111-D: statement is unreachable
                  NOT_REACHED; /* NOTREACHED */
                  ^

"re_exec.c", line 5956: 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 5957: 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 6104: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 6134: 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 6158: 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 6224: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 6227: 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 6755: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
                  if (! ANYOF_BITMAP_TEST(scan, * (U8 *) (locinput))) {
                        ^

"re_exec.c", line 6772: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  || (UCHARAT(locinput) & FLAGS(scan)) != ARG(scan)
                                                          ^

"re_exec.c", line 6782: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  || (UCHARAT(locinput) & FLAGS(scan)) == ARG(scan)
                                                          ^

"re_exec.c", line 7113: 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 7183: 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 7195: 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 7256: 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 7496: 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 7564: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 7651: 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 7673: 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 7693: 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 7694: 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 7701: 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 7705: 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 7715: 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 7725: 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 7740: 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 7842: 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 7865: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7871: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7877: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 7914: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 8022: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 8034: warning #2111-D: statement is unreachable
  		NOT_REACHED; /* NOTREACHED */
  		^

"re_exec.c", line 8038: warning #2111-D: statement is unreachable
  	NOT_REACHED; /* NOTREACHED */
  	^

"re_exec.c", line 8044: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8051: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8061: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8086: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8117: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8123: 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 8144: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8148: 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 8152: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8160: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8164: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8230: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8278: 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 8281: 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 8281: 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 8355: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8441: 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 8448: 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 8448: 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 8529: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8656: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8684: warning #2111-D: statement is unreachable
  		    NOT_REACHED; /* NOTREACHED */
  		    ^

"re_exec.c", line 8814: 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 8828: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8863: 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 8873: 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 8884: 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 8887: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8893: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8897: 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 8907: warning #2111-D: statement is unreachable
  	    NOT_REACHED; /* NOTREACHED */
  	    ^

"re_exec.c", line 8913: 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 8918: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8923: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8943: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 8957: 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 8990: warning #2111-D: statement is unreachable
              NOT_REACHED; /* NOTREACHED */
              ^

"re_exec.c", line 9534: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "regnode_charclass *" may cause misaligned access
  	    while (scan < this_eol && ANYOF_BITMAP_TEST(p, *((U8*)scan)))
  	                              ^

"re_exec.c", line 9548: 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 *) this_eol, (U8) ARG(p), FLAGS(p));
                                                                                ^

"re_exec.c", line 9555: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		   &&  (*scan & FLAGS(p)) != ARG(p))
  		                             ^

"re_exec.c", line 9562: warning #4232-D: conversion from "const regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              scan = (char *) find_next_masked((U8 *) scan, (U8 *) this_eol, (U8) ARG(p), FLAGS(p));
                                                                                  ^

"re_exec.c", line 9862: 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 9875: 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 9879: 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 9917: 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 9949: 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 10012: 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, 'i')) {
  		    ^

"re_exec.c", line 10017: 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, 'I')) {
  		    ^

"re_exec.c", line 3160: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(strbeg + min, prog->subbeg, sublen, char);
              ^

"re_exec.c", line 4227: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c1_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 4228: warning #4276-D: relational operator ">" always evaluates to 'false'
              Copy(pat, c2_utf8, UTF8SKIP(pat), U8);
              ^

"re_exec.c", line 7978: warning #4276-D: relational operator ">" always evaluates to 'false'
  			    Renew(aux->poscache, size, char);
  			    ^

"re_exec.c", line 7981: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Zero(aux->poscache, size, char);
  			^

"re_exec.c", line 7985: warning #4276-D: relational operator ">" always evaluates to 'false'
  			Newxz(aux->poscache, size, char);
  			^

"re_comp.c", line 3597: 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 3615: 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 3615: 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 3727: 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 3752: 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 3757: 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 3762: 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 4382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              ARG_SET(scan, *STRING(scan) & mask);
              ^

"re_comp.c", line 4451: 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 4532: 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 4539: 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 4543: 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 5064: 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 5065: 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 5343: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      ARG_SET(next, *STRING(next) & mask);
                      ^

"re_comp.c", line 5501: 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)] = REGNODE_OFFSET(oscan);
                                           ^

"re_comp.c", line 5504: 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)] = REGNODE_OFFSET(nxt) + 2;
                                            ^

"re_comp.c", line 5507: 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 5548: 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 5551: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_open_parens[ARG(nxt1)] = REGNODE_OFFSET(oscan);
                                               ^

"re_comp.c", line 5554: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                              RExC_close_parens[ARG(nxt1)] = REGNODE_OFFSET(nxt2)
                                                ^

"re_comp.c", line 5601: 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 5842: 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 5845: 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 6154: 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 6158: 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 6161: 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 6168: 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 6217: 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 6416: warning #2111-D: statement is unreachable
      NOT_REACHED; /* NOTREACHED */
      ^

"re_comp.c", line 7910: warning #2187-D: use of "=" where "==" may have been intended
  	while ((OP(first) == OPEN && (sawopen = 1)) ||
  	                             ^

"re_comp.c", line 7914: warning #2187-D: use of "=" where "==" may have been intended
  	    (OP(first) == IFMATCH && !first->flags && (sawlookahead = 1)) ||
  	                                              ^

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

"re_comp.c", line 8325: 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)] - REGNODE_OFFSET(scan));
          ^

"re_comp.c", line 8325: 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)] - REGNODE_OFFSET(scan));
          ^

"re_comp.c", line 11380: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  ARG(REGNODE_p(ret)) = add_data( pRExC_state,
                  ^

"re_comp.c", line 11382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                  RExC_rxi->data->data[ARG(REGNODE_p(ret))]=(void*)sv;
                                       ^

"re_comp.c", line 11388: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_2L *" may cause misaligned access
                  ARG2L_SET(REGNODE_p(ret), internal_argval);
                  ^

"re_comp.c", line 11686: 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 11686: 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 14786: 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 14786: 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 14816: 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 14817: 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 19072: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
          ANYOF_POSIXL_SET_TO_BITMAP(REGNODE_p(ret), posixl);
          ^

"re_comp.c", line 19143: 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 19164: 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 19633: 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 19650: 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 19650: 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 19809: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
          ARG_SET(REGNODE_p(scan), val - scan);
          ^

"re_comp.c", line 19921: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  	ARG_SET(REGNODE_p(scan), val - scan);
  	^

"re_comp.c", line 19942: 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 19952: 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 20229: 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 20253: 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 20281: 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 20281: 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 20309: 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 20331: 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 20331: 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 20332: 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 20334: 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 20370: 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 20401: 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 20556: 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 20558: 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 21691: 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 21696: 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 21928: 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 4146: warning #4276-D: relational operator ">" always evaluates to 'false'
              Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
              ^

"re_comp.c", line 4216: 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 4221: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 4226: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Copy(s, d, s_len, U8);
                          ^

"re_comp.c", line 5112: warning #4276-D: relational operator ">" always evaluates to 'false'
                          Zero(RExC_study_chunk_recursed, RExC_study_chunk_recursed_bytes, U8);
                          ^

"re_comp.c", line 5114: 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 6426: warning #4276-D: relational operator ">" always evaluates to 'false'
      Renewc(RExC_rxi->data,
      ^

"re_comp.c", line 6430: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Renew(RExC_rxi->data->what, count + n, U8);
  	^

"re_comp.c", line 6432: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(RExC_rxi->data->what, n, U8);
  	^

"re_comp.c", line 6434: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(s, RExC_rxi->data->what + count, n, U8);
      ^

"re_comp.c", line 6614: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newx(dst, *plen_p + variant_under_utf8_count(src, src + *plen_p) + 1, U8);
      ^

"re_comp.c", line 6974: warning #4276-D: relational operator ">" always evaluates to 'false'
  	Newx(newpat, newlen, char);
  	^

"re_comp.c", line 7250: warning #4276-D: relational operator ">" always evaluates to 'false'
          Copy(name, p, len, char);
          ^

"re_comp.c", line 7265: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(RExC_precomp, p, pat_len, char);
      ^

"re_comp.c", line 7657: warning #4276-D: relational operator ">" always evaluates to 'false'
      Newxc(RExC_rxi, sizeof(regexp_internal) + RExC_size, char, regexp_internal);
      ^

"re_comp.c", line 7661: warning #4276-D: relational operator ">" always evaluates to 'false'
      Zero(RExC_rxi, sizeof(regexp_internal) + RExC_size, char);
      ^

"re_comp.c", line 7839: warning #4276-D: relational operator ">" always evaluates to 'false'
          Newx(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 7851: warning #4276-D: relational operator ">" always evaluates to 'false'
          Zero(RExC_study_chunk_recursed,
          ^

"re_comp.c", line 19539: warning #4276-D: relational operator ">" always evaluates to 'false'
      Renewc(RExC_rxi,
      ^

"re_comp.c", line 21187: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat1, buf, l1 , char);
      ^

"re_comp.c", line 21188: warning #4276-D: relational operator ">" always evaluates to 'false'
      Copy(pat2, buf + l1, l2 , char);
      ^

"re_comp.c", line 21197: 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;
  	^

[2019-04-15 08:16:18+0200] Skip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2019-04-15 08:16:18+0200] 
[2019-04-15 08:16:18+0200]  Tests start here:
[2019-04-15 08:16:18+0200] TSTENV = stdio	
No saved state, selection will be empty
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--18613 line 2.
Redefining sub Data::ok at -e line 1.
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

c++: error: +Z: No such file or directory
c++: error: +O2: No such file or directory
c++: error: +Onolimit: No such file or directory
# Will use Digest::MD5
cc: warning 983: The -lc library specified on the command line is also added automatically by the compiler driver.  
[2019-04-15 08:33:07+0200] 
[2019-04-15 08:33:07+0200] All tests successful.
[2019-04-15 08:33:07+0200] ../cpan/Module-Metadata/t/extract-version.t.................PASSED
[2019-04-15 08:33:07+0200]     7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47
[2019-04-15 08:33:07+0200]     51, 55, 59, 63, 67, 71, 75, 79, 83, 87
[2019-04-15 08:33:07+0200]     91, 95, 99, 106, 110, 114, 118, 122, 126
[2019-04-15 08:33:07+0200]     130, 134, 138, 142, 149, 153, 157, 161
[2019-04-15 08:33:07+0200]     165, 169, 173, 177, 181, 185, 195, 199
[2019-04-15 08:33:07+0200]     203
[2019-04-15 08:33:07+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2019-04-15 08:33:07+0200]     9, 18
[2019-04-15 08:33:07+0200] Archived results...
[2019-04-15 08:33:07+0200] TSTENV = perlio	
# parser guessed wrong encoding expected 'CP1252' got 'UTF-8'
"XSTest.c", line 248: warning #2111-D: statement is unreachable
  	PUTBACK;
  	^

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.  
# Will use Digest::MD5
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
Cannot figure out an encoding to use at t/use-Encode-Alias.t line 5.
[2019-04-15 08:47:21+0200] 
[2019-04-15 08:47:21+0200] All tests successful.
[2019-04-15 08:47:21+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2019-04-15 08:47:21+0200]     9, 18
[2019-04-15 08:47:21+0200] ../cpan/Module-Metadata/t/extract-version.t.................PASSED
[2019-04-15 08:47:21+0200]     7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47
[2019-04-15 08:47:21+0200]     51, 55, 59, 63, 67, 71, 75, 79, 83, 87
[2019-04-15 08:47:21+0200]     91, 95, 99, 106, 110, 114, 118, 122, 126
[2019-04-15 08:47:21+0200]     130, 134, 138, 142, 149, 153, 157, 161
[2019-04-15 08:47:21+0200]     165, 169, 173, 177, 181, 185, 195, 199
[2019-04-15 08:47:21+0200]     203
[2019-04-15 08:47:21+0200] Archived results...
[2019-04-15 08:47:21+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;
  	^

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.  
# Connected to 127.0.0.1
syswrite() isn't allowed on :utf8 handles at t/Socket.t line 47.
# Looks like your test exited with 255 just after 2.
Integer overflow in hexadecimal number at t/broken_univ_can.t line 7.
# Will use Digest::MD5
make: *** [test_harness] Error 1

error while running harness target 'test_harness': 2 at /pro/3gl/CPAN/smoke/lib/Test/Smoke/App/RunSmoke.pm line 118.
[2019-04-15 09:01:39+0200] 
[2019-04-15 09:01:39+0200] ../lib/B/Deparse.t..........................................PASSED
[2019-04-15 09:01:39+0200]     2
[2019-04-15 09:01:39+0200] ../dist/Net-Ping/t/450_service.t............................PASSED
[2019-04-15 09:01:39+0200]     9, 18
[2019-04-15 09:01:39+0200] ../cpan/Module-Metadata/t/extract-version.t.................PASSED
[2019-04-15 09:01:39+0200]     7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47
[2019-04-15 09:01:39+0200]     51, 55, 59, 63, 67, 71, 75, 79, 83, 87
[2019-04-15 09:01:39+0200]     91, 95, 99, 106, 110, 114, 118, 122, 126
[2019-04-15 09:01:39+0200]     130, 134, 138, 142, 149, 153, 157, 161
[2019-04-15 09:01:39+0200]     165, 169, 173, 177, 181, 185, 195, 199
[2019-04-15 09:01:39+0200]     203
[2019-04-15 09:01:39+0200] ../cpan/Socket/t/Socket.t...................................FAILED
[2019-04-15 09:01:39+0200]     Non-zero exit status: 255
[2019-04-15 09:01:39+0200] ../cpan/Socket/t/Socket.t...................................FAILED
[2019-04-15 09:01:39+0200]     Bad plan.  You planned 6 tests but ran 2.
[2019-04-15 09:01:39+0200] Archived results...
[2019-04-15 09:01:39+0200] Unskip tests from '/pro/3gl/CPAN/smoke/p59.skip'
[2019-04-15 09:01:39+0200] 
[2019-04-15 09:01:39+0200] Configuration: -Dusedevel -Duse64bitall
[2019-04-15 09:01:39+0200] ------------------------------------------------------------------------------
[2019-04-15 09:01:39+0200] make distclean ...
[2019-04-15 09:02:22+0200] 
[2019-04-15 09:02:22+0200] Copy Policy.sh ...
[2019-04-15 09:02:22+0200] 
[2019-04-15 09:02:22+0200] Configure ...
5.29.10 <=> 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.  
[2019-04-15 09:03:40+0200] 
[2019-04-15 09:03:40+0200] make ...
"op.c", line 12449: warning #2111-D: statement is unreachable
          ((void)0);  
          ^

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

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

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

"op.c", line 3215: 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 12565: 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 12734: 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)));
  	                                                                                                                                                                                ^

"op.c", line 17191: 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*)(new_warnings),(const char*)(warnings), (size) * sizeof(char)));
                                                                                                                                                                                     ^

"perl.c", line 3524: 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 1032: 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 1058: 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 1078: 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 1081: 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 1176: 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 1254: 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 1806: 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 3406: 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 3747: 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 3843: 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 3894: 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 3915: 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 3984: 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 4065: 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 4120: 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 4864: 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 4943: 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 5063: 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 5922: 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 6172: 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 7215: 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 7807: 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 9196: 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 9377: 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 9411: 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 10073: 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 10199: 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 10255: 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 10347: 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 10434: 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 10719: 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 10888: 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 12318: 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 1727: 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 1745: 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 1860: 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 1866: 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 1910: 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 3597: 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 3615: 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 3727: 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 3752: 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 3757: 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 3762: 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 4382: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              (((((struct regnode_1 *)scan)->arg1)) = ((*(((struct regnode_string *)scan)->string) & mask)));
                  ^

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

"regcomp.c", line 4532: 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 4539: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		       || ((((n)->type) == 70) && (noff = ((((struct regnode_1 *)n)->arg1)))))
  		                                             ^

"regcomp.c", line 4543: 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 5064: 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 5065: 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 5343: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
                      (((((struct regnode_1 *)next)->arg1)) = ((*(((struct regnode_string *)next)->string) & mask)));
                          ^

"regcomp.c", line 5501: 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) - (pRExC_state ->emit_start));
                                                         ^

"regcomp.c", line 5504: 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) - (pRExC_state ->emit_start)) + 2;
                                                          ^

"regcomp.c", line 5507: 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 5548: 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 5551: 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) - (pRExC_state ->emit_start));
                                                             ^

"regcomp.c", line 5554: 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) - (pRExC_state ->emit_start))
                                                              ^

"regcomp.c", line 5601: 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 5841: 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 5844: 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 6154: 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 6158: 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 6161: 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 6168: 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 6217: 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 6416: warning #2111-D: statement is unreachable
      ((void)0);  
      ^

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

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

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

"regcomp.c", line 8325: 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) - (pRExC_state ->emit_start)))));
              ^

"regcomp.c", line 8325: 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) - (pRExC_state ->emit_start)))));
                                                                                    ^

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

"regcomp.c", line 11382: 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 *)((pRExC_state ->emit_start) + (ret)))->arg1))]=(void*)sv;
                                                     ^

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

"regcomp.c", line 14786: 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 14816: 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 14817: 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 19072: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "regnode_charclass_posixl *" may cause misaligned access
          do { ((regnode_charclass_posixl*) (((pRExC_state ->emit_start) + (ret))))->classflags = (posixl); } while (0);
                ^

"regcomp.c", line 19143: 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 19164: 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 19215: 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 19633: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
      do { (((((struct regnode_1 *)((pRExC_state ->emit_start) + (ptr)))->arg1)) = ((arg))); do { do { ((((pRExC_state ->emit_start) + (ptr)))->type) = op; ((((pRExC_state ->emit_start) + (ptr)))->next_off) = 0; } while (0); (ptr)++; } while (0); (ptr) += regarglen[op]; } while (0);
               ^

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

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

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

"regcomp.c", line 19942: 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 19952: 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 21162: 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 4146: 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 4216: 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 4221: 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 4226: 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 5112: 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 5114: 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 6426: 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 6430: 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 6432: 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 6434: 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 6614: warning #4276-D: relational operator ">" always evaluates to 'false'
      (dst = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 1) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 1)))) ? (size_t)(*plen_p + S_variant_under_utf8_count(src, src + *plen_p) + 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 + S_variant_under_utf8_count(src, src + *plen_p) + 1)*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                ^

"regcomp.c", line 6974: 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 7250: 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 7265: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(pat_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(pat_len)))) ? (size_t)(pat_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*)((pRExC_state ->precomp)), (pat_len) * sizeof(char)));
                                                                                                                                                                                              ^

"regcomp.c", line 7657: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (pRExC_state ->size)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (pRExC_state ->size))))) ? (size_t)(sizeof(regexp_internal) + (pRExC_state ->size)) : ((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) + (pRExC_state ->size))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                          ^

"regcomp.c", line 7661: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + (pRExC_state ->size)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + (pRExC_state ->size))))) ? (size_t)(sizeof(regexp_internal) + (pRExC_state ->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*)((pRExC_state ->rxi)),0,(sizeof(regexp_internal) + (pRExC_state ->size)) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                   ^

"regcomp.c", line 7839: 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 ->total_par)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) : ((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 ->total_par))*sizeof(U8))))));
                                                                                                                                                                                                                                                                                                                                                                                                                                   ^

"regcomp.c", line 7851: warning #4276-D: relational operator ">" always evaluates to 'false'
          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) || sizeof(U8) > ((size_t)1 << 8*(sizeof(size_t) - sizeof((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par))))) ? (size_t)((pRExC_state ->study_chunk_recursed_bytes) * (pRExC_state ->total_par)) : ((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 ->total_par)) * sizeof(U8)));
                                                                                                                                                                                                                                                                                                                                                                                           ^

"regcomp.c", line 9098: 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 10281: 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 19539: warning #4276-D: relational operator ">" always evaluates to 'false'
      ((pRExC_state ->rxi) = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode)) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode))))) ? (size_t)(sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * 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_safesysrealloc((void *)((pRExC_state ->rxi)),(size_t)((sizeof(regexp_internal) + ((pRExC_state ->size) + 1) * sizeof(regnode))*sizeof(char))))));
                                                                                                                                                                                                                                                                                                                                                                                                                  ^

"regcomp.c", line 21187: 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 21188: 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 21197: 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 22591: warning #4276-D: relational operator ">" always evaluates to 'false'
      (lookup_name = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(name_len) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(name_len)))) ? (size_t)(name_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)((name_len)*sizeof(char))))));
                                                                                                                                                                                                                ^

"regcomp.c", line 22778: warning #4276-D: relational operator ">" always evaluates to 'false'
                          (this_string = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(total_len + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(total_len + 1)))) ? (size_t)(total_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((total_len + 1),sizeof(char)))));
                                                                                                                                                                                                                                                   ^

"regcomp.c", line 22779: warning #4276-D: relational operator ">" always evaluates to 'false'
                          ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(j) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(j)))) ? (size_t)(j) : ((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*)(this_string),(const char*)(lookup_name), (j) * sizeof(char)));
                                                                                                                                                                                                ^

"regcomp.c", line 23425: warning #4276-D: relational operator ">" always evaluates to 'false'
                                  ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(strlen(cur_ptr) - excess_leading_zeros + 1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(strlen(cur_ptr) - excess_leading_zeros + 1)))) ? (size_t)(strlen(cur_ptr) - excess_leading_zeros + 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*)(cur_ptr),(const char*)(cur_ptr + excess_leading_zeros), (strlen(cur_ptr) - excess_leading_zeros + 1) * sizeof(char)));
                                                                                                                                                                                                                                                                                                                                   ^

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

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

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

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

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

"util.c", line 4503: 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 2029: 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 2031: warning #4276-D: relational operator ">" always evaluates to 'false'
  	((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(19 - size) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(19 - size)))) ? (size_t)(19 - 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,(19 - size) * sizeof(char)));
  	                                                                                                                                                                                              ^

"util.c", line 2132: 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 2163: 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 2163: 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 2189: 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 2189: 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 3825: 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 3852: 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 3868: 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 359: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((hv)->sv_flags & 0xff)) == (svtype)0xff)
                                            ^

"hv.c", line 590: 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 814: 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 1431: 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 1480: 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 1569: 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 1607: 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 2240: 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 2244: 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 3129: 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 3135: 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 3278: 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 3403: 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 3579: 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 3615: 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 3093: 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 3302: 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 3311: 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 4306: 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 4311: 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 4321: 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 4324: 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 4342: 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 4346: 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 4357: 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 16384: warning #2111-D: statement is unreachable
  	((void)0);  
  	^

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

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

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

"sv.c", line 1107: 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 1342: 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 1412: 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 1433: 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 1518: 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 1601: 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 3086: 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 3149: 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 4442: 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 4697: 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 4961: 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 5012: 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 5217: 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 5400: 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 5495: 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 5587: 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 6366: 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 6380: 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 6386: 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 6402: 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 6407: 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 6416: 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 6419: 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 6424: 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 8701: 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 8707: 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 8714: 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 9768: warning #4275-D: constant out of range ([0 - 16]) for the operator
      if (((svtype)((old)->sv_flags & 0xff)) == (svtype)0xff) {
                                             ^

"sv.c", line 10101: 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 10998: 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 11734: 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 11777: 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 11826: 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 11831: 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 13090: 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 13332: 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 13353: 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 16016: 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 2180: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"pp.c", line 3991: 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 4004: 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 4021: 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 4162: 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 4514: 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 4728: 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 801: 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_sys.c", line 2945: 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 1824: 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 2337: 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 3215: 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 3227: 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 523: warning #2111-D: statement is unreachable
      return (0);  
      ^

"regexec.c", line 2157: 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 2164: 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 2171: 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_span_end_mask((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 += (utf8_target) ? PL_utf8skip[*(const U8*)(s)] : 1; previous_occurrence_end = s; };
                                                                                                   ^

"regexec.c", line 2832: 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 2870: 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 4122: 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 4406: warning #2111-D: statement is unreachable
                          ((void)0);  
                          ^

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

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

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

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

"regexec.c", line 5956: 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 5957: 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 6104: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 6134: 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 6158: 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 6224: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

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

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

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

"regexec.c", line 7113: 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 7183: 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 7195: 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 7256: 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 7496: 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 7564: warning #2111-D: statement is unreachable
  		((void)0);  
  		^

"regexec.c", line 7651: 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
  	    n = ((((struct regnode_1 *)scan)->arg1));   
  	           ^

"regexec.c", line 7693: 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 7694: 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 7701: 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 7705: 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 7715: 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 7725: 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 7740: 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 7842: 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 7865: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

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

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

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

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

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

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

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

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

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

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

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

"regexec.c", line 8123: 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 8144: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8148: 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 8152: warning #2111-D: statement is unreachable
              ((void)0);  
              ^

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

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

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

"regexec.c", line 8278: 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)] == 35) || PL_regkind[((st->u . curlym . B)->type)] == 60 ) || ( ((st->u . curlym . B)->type) == 56 || (((st->u . curlym . B)->type) == 57 && !( ( ( 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) == 77 || ((st->u . curlym . B)->type) == 74 || ((st->u . curlym . B)->type) == 72 || ((st->u . curlym . B)->type) == 50 || ((st->u . curlym . B)->type) == 78 || ((st->u . curlym . B)->type) == 98 || (PL_regkind[((st->u . curlym . B)->type)] == 51 && ((((struct regnode_2 *)st->u . curlym . B)->arg1)) > 0) )) {
  		                                                                                                                                                                                                                                                                                                                    ^

"regexec.c", line 8281: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8281: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  			do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8355: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

"regexec.c", line 8441: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
              if (! ( (PL_regkind[((next)->type)] == 35) || PL_regkind[((next)->type)] == 60 ) && ! ( ((next)->type) == 56 || (((next)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)next)->arg1))) + 1 ) ) ) ) || ((next)->type) == 77 || ((next)->type) == 74 || ((next)->type) == 72 || ((next)->type) == 50 || ((next)->type) == 78 || ((next)->type) == 98 || (PL_regkind[((next)->type)] == 51 && ((((struct regnode_2 *)next)->arg1)) > 0) )) {
                                                                                                                                                                                                                                                                              ^

"regexec.c", line 8448: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8448: warning #4232-D: conversion from "regnode *" to a more strictly aligned type "struct regnode_1 *" may cause misaligned access
  		    do { while (( ((text_node)->type) == 56 || (((text_node)->type) == 57 && !( ( ( cur_eval ) ) && ( ( cur_eval )->u . eval . close_paren ) && ( ( ( cur_eval )->u . eval . close_paren ) == ( (((((struct regnode_1 *)text_node)->arg1))) + 1 ) ) ) ) || ((text_node)->type) == 77 || ((text_node)->type) == 74 || ((text_node)->type) == 72 || ((text_node)->type) == 50 || ((text_node)->type) == 78 || ((text_node)->type) == 98 || (PL_regkind[((text_node)->type)] == 51 && ((((struct regnode_2 *)text_node)->arg1)) > 0) )) { const U16 type = ((text_node)->type); if (type == 74 || PL_regkind[type] == 51) text_node = ((((text_node) + 1)) + 1); else if (type == 50) text_node = ((text_node) + 1); else if (type == 72) 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 8529: warning #2111-D: statement is unreachable
  	    ((void)0);  
  	    ^

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

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

"regexec.c", line 8814: warning #4232-D: conversion from "regnode *" to a more