unsigned char ss_hammingAnd3pMismatchCheck(const char *s1, const char *s2,
                                           const int len, const int min_dist) {
  int hamming_distance = 0;
  int hamming_distance_rev = 0;
  int mismatch_distance = 0;
  int mismatch_distance_revA = 0;
  int mismatch_distance_revB = 0;
  char *s1_ptr = (char *)s1;
  char *s2_ptr = (char *)s2;
  const char *s1_ptr_lim = s1_ptr + len;
  const char *s1_ptr_lim_3p = s1_ptr_lim - 3;
  const char *s1_ptr_lim_5p = s1_ptr + 3;
  while (s1_ptr < s1_ptr_lim) {
    if (*s1_ptr++ != *s2_ptr++) {
      hamming_distance++;
    }
  }
  while (s1_ptr > s1_ptr_lim_3p) {
    if (*--s1_ptr != *--s2_ptr) {
      mismatch_distance++;
    }
  }
  s1_ptr = (char *)s1;
  s2_ptr = ((char *)s2) + len;
  while (s1_ptr < s1_ptr_lim) {
    if (*s1_ptr++ != *--s2_ptr) {
      hamming_distance_rev++;
    }
  }
  while (s1_ptr > s1_ptr_lim_3p) {
    if (*--s1_ptr != *s2_ptr++) {
      mismatch_distance_revA++;
    }
  }
  s1_ptr = (char *)s1;
  s2_ptr = ((char *)s2) + len;
  while (s1_ptr < s1_ptr_lim_5p) {
    if (*s1_ptr++ != *--s2_ptr) {
      mismatch_distance_revB++;
    }
  }
  if ((hamming_distance > min_dist) && (mismatch_distance) &&
      (hamming_distance_rev > min_dist) && (mismatch_distance_revA) &&
      (mismatch_distance_revB)) {
    return 1;
  } else {
    return 0;
  }
}


x86 assembly (clang, -O0):
<ss_hammingAnd3pMismatchCheck>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
add    $0xfffffffffffffffd,%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    11b4 <ss_hammingAnd3pMismatchCheck+0xb4>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl (%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     11af <ss_hammingAnd3pMismatchCheck+0xaf>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    116c <ss_hammingAnd3pMismatchCheck+0x6c>
jmp    11b9 <ss_hammingAnd3pMismatchCheck+0xb9>
mov    -0x40(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    1203 <ss_hammingAnd3pMismatchCheck+0x103>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x40(%rbp)
movsbl -0x1(%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x48(%rbp)
movsbl -0x1(%rcx),%ecx
cmp    %ecx,%eax
je     11fe <ss_hammingAnd3pMismatchCheck+0xfe>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b9 <ss_hammingAnd3pMismatchCheck+0xb9>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1263 <ss_hammingAnd3pMismatchCheck+0x163>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl (%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x48(%rbp)
movsbl -0x1(%rcx),%ecx
cmp    %ecx,%eax
je     125e <ss_hammingAnd3pMismatchCheck+0x15e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    121a <ss_hammingAnd3pMismatchCheck+0x11a>
jmp    1268 <ss_hammingAnd3pMismatchCheck+0x168>
mov    -0x40(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    12b1 <ss_hammingAnd3pMismatchCheck+0x1b1>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x40(%rbp)
movsbl -0x1(%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     12ac <ss_hammingAnd3pMismatchCheck+0x1ac>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1268 <ss_hammingAnd3pMismatchCheck+0x168>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1311 <ss_hammingAnd3pMismatchCheck+0x211>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl (%rax),%eax
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x48(%rbp)
movsbl -0x1(%rcx),%ecx
cmp    %ecx,%eax
je     130c <ss_hammingAnd3pMismatchCheck+0x20c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c8 <ss_hammingAnd3pMismatchCheck+0x1c8>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1350 <ss_hammingAnd3pMismatchCheck+0x250>
cmpl   $0x0,-0x2c(%rbp)
je     1350 <ss_hammingAnd3pMismatchCheck+0x250>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1350 <ss_hammingAnd3pMismatchCheck+0x250>
cmpl   $0x0,-0x30(%rbp)
je     1350 <ss_hammingAnd3pMismatchCheck+0x250>
cmpl   $0x0,-0x34(%rbp)
je     1350 <ss_hammingAnd3pMismatchCheck+0x250>
movb   $0x1,-0x1(%rbp)
jmp    1354 <ss_hammingAnd3pMismatchCheck+0x254>
movb   $0x0,-0x1(%rbp)
movzbl -0x1(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<ss_hammingAnd3pMismatchCheck>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movslq %edx,%r10
lea    (%rdi,%r10,1),%r9
lea    (%rdi,%r10,1),%r8
add    $0xfffffffffffffffd,%r8
xor    %r14d,%r14d
mov    %rdi,%rbp
mov    %rsi,%r13
mov    $0x0,%r15d
test   %r10d,%r10d
jle    12ce <ss_hammingAnd3pMismatchCheck+0x1ce>
lea    0x1(%rdi),%rax
cmp    %rax,%r9
cmova  %r9,%rax
sub    %rdi,%rax
xor    %r15d,%r15d
mov    %rsi,%r13
mov    %rdi,%rbp
cmp    $0x8,%rax
jb     12ab <ss_hammingAnd3pMismatchCheck+0x1ab>
mov    %rax,%r11
and    $0xfffffffffffffff8,%r11
lea    -0x8(%r11),%rbx
mov    %rbx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rbx,%rbx
je     1684 <ss_hammingAnd3pMismatchCheck+0x584>
mov    %rdx,%rbp
and    $0xfffffffffffffffe,%rbp
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pcmpeqd %xmm2,%xmm2
movdqa 0xe76(%rip),%xmm3
pxor   %xmm1,%xmm1
xchg   %ax,%ax
movd   (%rdi,%rbx,1),%xmm4
movd   0x4(%rdi,%rbx,1),%xmm6
movd   (%rsi,%rbx,1),%xmm5
pcmpeqb %xmm4,%xmm5
movd   0x4(%rsi,%rbx,1),%xmm4
pcmpeqb %xmm6,%xmm4
pxor   %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm0,%xmm5
pxor   %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdi,%rbx,1),%xmm1
movd   0xc(%rdi,%rbx,1),%xmm6
movd   0x8(%rsi,%rbx,1),%xmm0
pcmpeqb %xmm1,%xmm0
movd   0xc(%rsi,%rbx,1),%xmm1
pcmpeqb %xmm6,%xmm1
pxor   %xmm2,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm5,%xmm0
pxor   %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1190 <ss_hammingAnd3pMismatchCheck+0x90>
test   $0x1,%dl
je     1283 <ss_hammingAnd3pMismatchCheck+0x183>
movd   (%rdi,%rbx,1),%xmm2
movd   0x4(%rdi,%rbx,1),%xmm3
movd   (%rsi,%rbx,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x4(%rsi,%rbx,1),%xmm2
pcmpeqb %xmm3,%xmm2
pcmpeqd %xmm3,%xmm3
pxor   %xmm3,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
movdqa 0xd99(%rip),%xmm5
pand   %xmm5,%xmm4
paddd  %xmm4,%xmm0
pxor   %xmm3,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm5,%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
lea    (%rsi,%r11,1),%r13
lea    (%rdi,%r11,1),%rbp
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r15d
cmp    %r11,%rax
je     12ce <ss_hammingAnd3pMismatchCheck+0x1ce>
mov    %r13,%rax
xchg   %ax,%ax
movzbl 0x0(%rbp),%ebx
add    $0x1,%rbp
xor    %edx,%edx
cmp    (%rax),%bl
lea    0x1(%rax),%r13
setne  %dl
add    %edx,%r15d
mov    %r13,%rax
cmp    %r9,%rbp
jb     12b0 <ss_hammingAnd3pMismatchCheck+0x1b0>
cmp    %r8,%rbp
jbe    13dc <ss_hammingAnd3pMismatchCheck+0x2dc>
mov    %rbp,%r11
sub    %r9,%r11
add    $0x3,%r11
xor    %r14d,%r14d
cmp    $0x8,%r11
jae    12f5 <ss_hammingAnd3pMismatchCheck+0x1f5>
mov    %r13,%rax
mov    %rbp,%rdx
jmp    13ad <ss_hammingAnd3pMismatchCheck+0x2ad>
mov    %r11,%r12
and    $0xfffffffffffffff8,%r12
mov    %r12,%r14
neg    %r14
mov    %r13,%rax
sub    %r12,%rax
mov    %rbp,%rdx
sub    %r12,%rdx
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pcmpeqd %xmm2,%xmm2
movdqa 0xce0(%rip),%xmm3
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   -0x4(%rbp,%rbx,1),%xmm4
movd   -0x8(%rbp,%rbx,1),%xmm5
movd   -0x4(%r13,%rbx,1),%xmm6
pcmpeqb %xmm4,%xmm6
movd   -0x8(%r13,%rbx,1),%xmm4
pcmpeqb %xmm5,%xmm4
pxor   %xmm2,%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
pshufd $0x1b,%xmm6,%xmm5
pxor   %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pshufd $0x1b,%xmm4,%xmm4
pand   %xmm3,%xmm5
paddd  %xmm5,%xmm0
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0xfffffffffffffff8,%rbx
cmp    %rbx,%r14
jne    1330 <ss_hammingAnd3pMismatchCheck+0x230>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%r14d
cmp    %r12,%r11
je     13dc <ss_hammingAnd3pMismatchCheck+0x2dc>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rdx),%ebx
add    $0xffffffffffffffff,%rdx
xor    %ebp,%ebp
cmp    (%rax),%bl
setne  %bpl
add    %ebp,%r14d
add    $0xffffffffffffffff,%rax
cmp    %r8,%rdx
ja     13c0 <ss_hammingAnd3pMismatchCheck+0x2c0>
lea    (%rsi,%r10,1),%r11
xor    %r12d,%r12d
mov    %rdi,%rdx
mov    %r11,%r13
mov    $0x0,%ebp
test   %r10d,%r10d
jle    151e <ss_hammingAnd3pMismatchCheck+0x41e>
lea    0x1(%rdi),%rax
cmp    %rax,%r9
cmova  %r9,%rax
sub    %rdi,%rax
xor    %ebp,%ebp
mov    %r11,%r13
mov    %rdi,%rdx
cmp    $0x8,%rax
jb     14f5 <ss_hammingAnd3pMismatchCheck+0x3f5>
mov    %ecx,-0xc(%rsp)
mov    %rax,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %rbx,%rbp
neg    %rbp
mov    %r11,-0x8(%rsp)
mov    %r11,%r13
sub    %rbx,%r13
lea    (%rdi,%rbx,1),%rdx
lea    0x4(%rdi),%r11
add    %r10,%rsi
add    $0xfffffffffffffffc,%rsi
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pcmpeqd %xmm2,%xmm2
movdqa 0xbac(%rip),%xmm3
pxor   %xmm4,%xmm4
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movd   -0x4(%r11),%xmm5
movd   (%r11),%xmm6
movd   (%rsi,%rcx,1),%xmm7
punpcklbw %xmm0,%xmm7
pshuflw $0x1b,%xmm7,%xmm7
packuswb %xmm7,%xmm7
pcmpeqb %xmm5,%xmm7
movd   -0x4(%rsi,%rcx,1),%xmm5
punpcklbw %xmm0,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
packuswb %xmm5,%xmm5
pcmpeqb %xmm6,%xmm5
pxor   %xmm2,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm3,%xmm7
paddd  %xmm7,%xmm4
pxor   %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm5,%xmm1
add    $0x8,%r11
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%rbp
jne    1460 <ss_hammingAnd3pMismatchCheck+0x360>
paddd  %xmm4,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebp
cmp    %rbx,%rax
mov    -0xc(%rsp),%ecx
mov    -0x8(%rsp),%r11
je     151e <ss_hammingAnd3pMismatchCheck+0x41e>
mov    %r13,%rax
nopl   0x0(%rax,%rax,1)
movzbl (%rdx),%ebx
add    $0x1,%rdx
xor    %esi,%esi
cmp    -0x1(%rax),%bl
lea    -0x1(%rax),%r13
setne  %sil
add    %esi,%ebp
mov    %r13,%rax
cmp    %r9,%rdx
jb     1500 <ss_hammingAnd3pMismatchCheck+0x400>
cmp    %r8,%rdx
jbe    162b <ss_hammingAnd3pMismatchCheck+0x52b>
mov    %rdx,%r10
sub    %r9,%r10
add    $0x3,%r10
xor    %r12d,%r12d
cmp    $0x8,%r10
jae    1545 <ss_hammingAnd3pMismatchCheck+0x445>
mov    %r13,%rax
mov    %rdx,%rsi
jmp    1610 <ss_hammingAnd3pMismatchCheck+0x510>
mov    %r10,%r9
and    $0xfffffffffffffff8,%r9
lea    (%r9,%r13,1),%rax
mov    %rdx,%rsi
sub    %r9,%rsi
add    $0xfffffffffffffffc,%rdx
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pcmpeqd %xmm2,%xmm2
movdqa 0xa94(%rip),%xmm3
pxor   %xmm4,%xmm4
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   (%rdx),%xmm5
punpcklbw %xmm0,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
packuswb %xmm5,%xmm5
movd   -0x4(%rdx),%xmm6
punpcklbw %xmm0,%xmm6
pshuflw $0x1b,%xmm6,%xmm6
packuswb %xmm6,%xmm6
movd   0x0(%r13,%rbx,1),%xmm7
pcmpeqb %xmm5,%xmm7
movd   0x4(%r13,%rbx,1),%xmm5
pcmpeqb %xmm6,%xmm5
pxor   %xmm2,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
pand   %xmm3,%xmm7
paddd  %xmm7,%xmm4
pxor   %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm5,%xmm1
add    $0x8,%rbx
add    $0xfffffffffffffff8,%rdx
cmp    %rbx,%r9
jne    1580 <ss_hammingAnd3pMismatchCheck+0x480>
paddd  %xmm4,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%r12d
cmp    %r9,%r10
je     162b <ss_hammingAnd3pMismatchCheck+0x52b>
xchg   %ax,%ax
movzbl -0x1(%rsi),%ebx
add    $0xffffffffffffffff,%rsi
xor    %edx,%edx
cmp    (%rax),%bl
lea    0x1(%rax),%rax
setne  %dl
add    %edx,%r12d
cmp    %r8,%rsi
ja     1610 <ss_hammingAnd3pMismatchCheck+0x510>
cmp    %ecx,%r15d
jle    1677 <ss_hammingAnd3pMismatchCheck+0x577>
test   %r14d,%r14d
je     1677 <ss_hammingAnd3pMismatchCheck+0x577>
mov    (%rdi),%bl
mov    0x1(%rdi),%dl
xor    %eax,%eax
cmp    -0x1(%r11),%bl
setne  %r9b
xor    %esi,%esi
cmp    -0x2(%r11),%dl
setne  %r8b
mov    0x2(%rdi),%bl
xor    %edx,%edx
cmp    -0x3(%r11),%bl
setne  %dil
cmp    %ecx,%ebp
jle    1677 <ss_hammingAnd3pMismatchCheck+0x577>
test   %r12d,%r12d
je     1677 <ss_hammingAnd3pMismatchCheck+0x577>
mov    %r9b,%al
mov    %r8b,%sil
add    %eax,%esi
mov    %dil,%dl
neg    %edx
mov    $0x1,%al
cmp    %edx,%esi
jne    1679 <ss_hammingAnd3pMismatchCheck+0x579>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    1231 <ss_hammingAnd3pMismatchCheck+0x131>
jmp    1283 <ss_hammingAnd3pMismatchCheck+0x183>

LLVM IR (-O0):
define zeroext i8 @ss_hammingAnd3pMismatchCheck(i8* %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i8
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
store i8* %0, i8** %6
store i8* %1, i8** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %13
store i32 0, i32* %14
%20 = load i8*, i8** %6
store i8* %20, i8** %15
%21 = load i8*, i8** %7
store i8* %21, i8** %16
%22 = load i8*, i8** %15
%23 = load i32, i32* %8
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
store i8* %25, i8** %17
%26 = load i8*, i8** %17
%27 = getelementptr inbounds i8, i8* %26, i64 -3
store i8* %27, i8** %18
%28 = load i8*, i8** %15
%29 = getelementptr inbounds i8, i8* %28, i64 3
store i8* %29, i8** %19
br label %30
30: ; preds = %47, %4
%31 = load i8*, i8** %15
%32 = load i8*, i8** %17
%33 = icmp ult i8* %31, %32
br i1 %33, label %34, label %48
34: ; preds = %30
%35 = load i8*, i8** %15
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %15
%37 = load i8, i8* %35
%38 = sext i8 %37 to i32
%39 = load i8*, i8** %16
%40 = getelementptr inbounds i8, i8* %39, i32 1
store i8* %40, i8** %16
%41 = load i8, i8* %39
%42 = sext i8 %41 to i32
%43 = icmp ne i32 %38, %42
br i1 %43, label %44, label %47
44: ; preds = %34
%45 = load i32, i32* %10
%46 = add nsw i32 %45, 1
store i32 %46, i32* %10
br label %47
47: ; preds = %44, %34
br label %30
48: ; preds = %30
br label %49
49: ; preds = %66, %48
%50 = load i8*, i8** %15
%51 = load i8*, i8** %18
%52 = icmp ugt i8* %50, %51
br i1 %52, label %53, label %67
53: ; preds = %49
%54 = load i8*, i8** %15
%55 = getelementptr inbounds i8, i8* %54, i32 -1
store i8* %55, i8** %15
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = load i8*, i8** %16
%59 = getelementptr inbounds i8, i8* %58, i32 -1
store i8* %59, i8** %16
%60 = load i8, i8* %59
%61 = sext i8 %60 to i32
%62 = icmp ne i32 %57, %61
br i1 %62, label %63, label %66
63: ; preds = %53
%64 = load i32, i32* %12
%65 = add nsw i32 %64, 1
store i32 %65, i32* %12
br label %66
66: ; preds = %63, %53
br label %49
67: ; preds = %49
%68 = load i8*, i8** %6
store i8* %68, i8** %15
%69 = load i8*, i8** %7
%70 = load i32, i32* %8
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
store i8* %72, i8** %16
br label %73
73: ; preds = %90, %67
%74 = load i8*, i8** %15
%75 = load i8*, i8** %17
%76 = icmp ult i8* %74, %75
br i1 %76, label %77, label %91
77: ; preds = %73
%78 = load i8*, i8** %15
%79 = getelementptr inbounds i8, i8* %78, i32 1
store i8* %79, i8** %15
%80 = load i8, i8* %78
%81 = sext i8 %80 to i32
%82 = load i8*, i8** %16
%83 = getelementptr inbounds i8, i8* %82, i32 -1
store i8* %83, i8** %16
%84 = load i8, i8* %83
%85 = sext i8 %84 to i32
%86 = icmp ne i32 %81, %85
br i1 %86, label %87, label %90
87: ; preds = %77
%88 = load i32, i32* %11
%89 = add nsw i32 %88, 1
store i32 %89, i32* %11
br label %90
90: ; preds = %87, %77
br label %73
91: ; preds = %73
br label %92
92: ; preds = %109, %91
%93 = load i8*, i8** %15
%94 = load i8*, i8** %18
%95 = icmp ugt i8* %93, %94
br i1 %95, label %96, label %110
96: ; preds = %92
%97 = load i8*, i8** %15
%98 = getelementptr inbounds i8, i8* %97, i32 -1
store i8* %98, i8** %15
%99 = load i8, i8* %98
%100 = sext i8 %99 to i32
%101 = load i8*, i8** %16
%102 = getelementptr inbounds i8, i8* %101, i32 1
store i8* %102, i8** %16
%103 = load i8, i8* %101
%104 = sext i8 %103 to i32
%105 = icmp ne i32 %100, %104
br i1 %105, label %106, label %109
106: ; preds = %96
%107 = load i32, i32* %13
%108 = add nsw i32 %107, 1
store i32 %108, i32* %13
br label %109
109: ; preds = %106, %96
br label %92
110: ; preds = %92
%111 = load i8*, i8** %6
store i8* %111, i8** %15
%112 = load i8*, i8** %7
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %112, i64 %114
store i8* %115, i8** %16
br label %116
116: ; preds = %133, %110
%117 = load i8*, i8** %15
%118 = load i8*, i8** %19
%119 = icmp ult i8* %117, %118
br i1 %119, label %120, label %134
120: ; preds = %116
%121 = load i8*, i8** %15
%122 = getelementptr inbounds i8, i8* %121, i32 1
store i8* %122, i8** %15
%123 = load i8, i8* %121
%124 = sext i8 %123 to i32
%125 = load i8*, i8** %16
%126 = getelementptr inbounds i8, i8* %125, i32 -1
store i8* %126, i8** %16
%127 = load i8, i8* %126
%128 = sext i8 %127 to i32
%129 = icmp ne i32 %124, %128
br i1 %129, label %130, label %133
130: ; preds = %120
%131 = load i32, i32* %14
%132 = add nsw i32 %131, 1
store i32 %132, i32* %14
br label %133
133: ; preds = %130, %120
br label %116
134: ; preds = %116
%135 = load i32, i32* %10
%136 = load i32, i32* %9
%137 = icmp sgt i32 %135, %136
br i1 %137, label %138, label %152
138: ; preds = %134
%139 = load i32, i32* %12
%140 = icmp ne i32 %139, 0
br i1 %140, label %141, label %152
141: ; preds = %138
%142 = load i32, i32* %11
%143 = load i32, i32* %9
%144 = icmp sgt i32 %142, %143
br i1 %144, label %145, label %152
145: ; preds = %141
%146 = load i32, i32* %13
%147 = icmp ne i32 %146, 0
br i1 %147, label %148, label %152
148: ; preds = %145
%149 = load i32, i32* %14
%150 = icmp ne i32 %149, 0
br i1 %150, label %151, label %152
151: ; preds = %148
store i8 1, i8* %5
br label %153
152: ; preds = %148, %145, %141, %138, %134
store i8 0, i8* %5
br label %153
153: ; preds = %152, %151
%154 = load i8, i8* %5
ret i8 %154
}

LLVM IR (-O2):
define zeroext i8 @ss_hammingAnd3pMismatchCheck(i8* %0, i8* nocapture %1, i32 %2, i32 %3) {
%5 = ptrtoint i8* %0 to i64
%6 = sext i32 %2 to i64
%7 = getelementptr inbounds i8, i8* %0, i64 %6
%8 = getelementptr inbounds i8, i8* %7, i64 -3
%9 = icmp sgt i32 %2, 0
br i1 %9, label %10, label %108
10: ; preds = %4
%11 = add i64 %5, %6
%12 = add i64 %5, 1
%13 = call i64 @llvm.umax.i64(i64 %11, i64 %12)
%14 = sub i64 %13, %5
%15 = icmp ult i64 %14, 8
br i1 %15, label %104, label %16
16: ; preds = %10
%17 = and i64 %14, -8
%18 = getelementptr i8, i8* %1, i64 %17
%19 = getelementptr i8, i8* %0, i64 %17
%20 = add i64 %17, -8
%21 = lshr exact i64 %20, 3
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %22, 1
%24 = icmp eq i64 %20, 0
br i1 %24, label %72, label %25
25: ; preds = %16
%26 = and i64 %22, 4611686018427387902
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %69, %27 ]
%29 = phi <4 x i32> [ zeroinitializer, %25 ], [ %67, %27 ]
%30 = phi <4 x i32> [ zeroinitializer, %25 ], [ %68, %27 ]
%31 = phi i64 [ 0, %25 ], [ %70, %27 ]
%32 = getelementptr i8, i8* %1, i64 %28
%33 = getelementptr i8, i8* %0, i64 %28
%34 = bitcast i8* %33 to <4 x i8>*
%35 = load <4 x i8>, <4 x i8>* %34
%36 = getelementptr i8, i8* %33, i64 4
%37 = bitcast i8* %36 to <4 x i8>*
%38 = load <4 x i8>, <4 x i8>* %37
%39 = bitcast i8* %32 to <4 x i8>*
%40 = load <4 x i8>, <4 x i8>* %39
%41 = getelementptr i8, i8* %32, i64 4
%42 = bitcast i8* %41 to <4 x i8>*
%43 = load <4 x i8>, <4 x i8>* %42
%44 = icmp ne <4 x i8> %35, %40
%45 = icmp ne <4 x i8> %38, %43
%46 = zext <4 x i1> %44 to <4 x i32>
%47 = zext <4 x i1> %45 to <4 x i32>
%48 = add <4 x i32> %29, %46
%49 = add <4 x i32> %30, %47
%50 = or i64 %28, 8
%51 = getelementptr i8, i8* %1, i64 %50
%52 = getelementptr i8, i8* %0, i64 %50
%53 = bitcast i8* %52 to <4 x i8>*
%54 = load <4 x i8>, <4 x i8>* %53
%55 = getelementptr i8, i8* %52, i64 4
%56 = bitcast i8* %55 to <4 x i8>*
%57 = load <4 x i8>, <4 x i8>* %56
%58 = bitcast i8* %51 to <4 x i8>*
%59 = load <4 x i8>, <4 x i8>* %58
%60 = getelementptr i8, i8* %51, i64 4
%61 = bitcast i8* %60 to <4 x i8>*
%62 = load <4 x i8>, <4 x i8>* %61
%63 = icmp ne <4 x i8> %54, %59
%64 = icmp ne <4 x i8> %57, %62
%65 = zext <4 x i1> %63 to <4 x i32>
%66 = zext <4 x i1> %64 to <4 x i32>
%67 = add <4 x i32> %48, %65
%68 = add <4 x i32> %49, %66
%69 = add nuw i64 %28, 16
%70 = add i64 %31, 2
%71 = icmp eq i64 %70, %26
br i1 %71, label %72, label %27
72: ; preds = %27, %16
%73 = phi <4 x i32> [ undef, %16 ], [ %67, %27 ]
%74 = phi <4 x i32> [ undef, %16 ], [ %68, %27 ]
%75 = phi i64 [ 0, %16 ], [ %69, %27 ]
%76 = phi <4 x i32> [ zeroinitializer, %16 ], [ %67, %27 ]
%77 = phi <4 x i32> [ zeroinitializer, %16 ], [ %68, %27 ]
%78 = icmp eq i64 %23, 0
br i1 %78, label %98, label %79
79: ; preds = %72
%80 = getelementptr i8, i8* %1, i64 %75
%81 = getelementptr i8, i8* %0, i64 %75
%82 = bitcast i8* %81 to <4 x i8>*
%83 = load <4 x i8>, <4 x i8>* %82
%84 = getelementptr i8, i8* %81, i64 4
%85 = bitcast i8* %84 to <4 x i8>*
%86 = load <4 x i8>, <4 x i8>* %85
%87 = bitcast i8* %80 to <4 x i8>*
%88 = load <4 x i8>, <4 x i8>* %87
%89 = getelementptr i8, i8* %80, i64 4
%90 = bitcast i8* %89 to <4 x i8>*
%91 = load <4 x i8>, <4 x i8>* %90
%92 = icmp ne <4 x i8> %83, %88
%93 = icmp ne <4 x i8> %86, %91
%94 = zext <4 x i1> %92 to <4 x i32>
%95 = zext <4 x i1> %93 to <4 x i32>
%96 = add <4 x i32> %76, %94
%97 = add <4 x i32> %77, %95
br label %98
98: ; preds = %72, %79
%99 = phi <4 x i32> [ %73, %72 ], [ %96, %79 ]
%100 = phi <4 x i32> [ %74, %72 ], [ %97, %79 ]
%101 = add <4 x i32> %100, %99
%102 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %101)
%103 = icmp eq i64 %14, %17
br i1 %103, label %108, label %104
104: ; preds = %10, %98
%105 = phi i32 [ 0, %10 ], [ %102, %98 ]
%106 = phi i8* [ %1, %10 ], [ %18, %98 ]
%107 = phi i8* [ %0, %10 ], [ %19, %98 ]
br label %167
108: ; preds = %167, %98, %4
%109 = phi i8* [ %0, %4 ], [ %19, %98 ], [ %171, %167 ]
%110 = phi i8* [ %1, %4 ], [ %18, %98 ], [ %173, %167 ]
%111 = phi i32 [ 0, %4 ], [ %102, %98 ], [ %177, %167 ]
%112 = icmp ugt i8* %109, %8
br i1 %112, label %113, label %191
113: ; preds = %108
%114 = ptrtoint i8* %109 to i64
%115 = add i64 %114, 3
%116 = add i64 %5, %6
%117 = sub i64 %115, %116
%118 = icmp ult i64 %117, 8
br i1 %118, label %163, label %119
119: ; preds = %113
%120 = and i64 %117, -8
%121 = sub i64 0, %120
%122 = getelementptr i8, i8* %110, i64 %121
%123 = sub i64 0, %120
%124 = getelementptr i8, i8* %109, i64 %123
%125 = getelementptr i8, i8* %110, i64 -1
%126 = getelementptr i8, i8* %109, i64 -1
br label %127
127: ; preds = %127, %119
%128 = phi i64 [ 0, %119 ], [ %157, %127 ]
%129 = phi <4 x i32> [ zeroinitializer, %119 ], [ %155, %127 ]
%130 = phi <4 x i32> [ zeroinitializer, %119 ], [ %156, %127 ]
%131 = sub i64 0, %128
%132 = sub i64 0, %128
%133 = getelementptr inbounds i8, i8* %126, i64 %132
%134 = getelementptr inbounds i8, i8* %133, i64 -3
%135 = bitcast i8* %134 to <4 x i8>*
%136 = load <4 x i8>, <4 x i8>* %135
%137 = getelementptr inbounds i8, i8* %133, i64 -4
%138 = getelementptr inbounds i8, i8* %137, i64 -3
%139 = bitcast i8* %138 to <4 x i8>*
%140 = load <4 x i8>, <4 x i8>* %139
%141 = getelementptr inbounds i8, i8* %125, i64 %131
%142 = getelementptr inbounds i8, i8* %141, i64 -3
%143 = bitcast i8* %142 to <4 x i8>*
%144 = load <4 x i8>, <4 x i8>* %143
%145 = getelementptr inbounds i8, i8* %141, i64 -4
%146 = getelementptr inbounds i8, i8* %145, i64 -3
%147 = bitcast i8* %146 to <4 x i8>*
%148 = load <4 x i8>, <4 x i8>* %147
%149 = icmp ne <4 x i8> %136, %144
%150 = shufflevector <4 x i1> %149, <4 x i1> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%151 = icmp ne <4 x i8> %140, %148
%152 = shufflevector <4 x i1> %151, <4 x i1> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%153 = zext <4 x i1> %150 to <4 x i32>
%154 = zext <4 x i1> %152 to <4 x i32>
%155 = add <4 x i32> %129, %153
%156 = add <4 x i32> %130, %154
%157 = add nuw i64 %128, 8
%158 = icmp eq i64 %157, %120
br i1 %158, label %159, label %127
159: ; preds = %127
%160 = add <4 x i32> %156, %155
%161 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %160)
%162 = icmp eq i64 %117, %120
br i1 %162, label %191, label %163
163: ; preds = %113, %159
%164 = phi i8* [ %110, %113 ], [ %122, %159 ]
%165 = phi i8* [ %109, %113 ], [ %124, %159 ]
%166 = phi i32 [ 0, %113 ], [ %161, %159 ]
br label %179
167: ; preds = %104, %167
%168 = phi i32 [ %177, %167 ], [ %105, %104 ]
%169 = phi i8* [ %173, %167 ], [ %106, %104 ]
%170 = phi i8* [ %171, %167 ], [ %107, %104 ]
%171 = getelementptr inbounds i8, i8* %170, i64 1
%172 = load i8, i8* %170
%173 = getelementptr inbounds i8, i8* %169, i64 1
%174 = load i8, i8* %169
%175 = icmp ne i8 %172, %174
%176 = zext i1 %175 to i32
%177 = add nuw nsw i32 %168, %176
%178 = icmp ult i8* %171, %7
br i1 %178, label %167, label %108
179: ; preds = %163, %179
%180 = phi i8* [ %185, %179 ], [ %164, %163 ]
%181 = phi i8* [ %183, %179 ], [ %165, %163 ]
%182 = phi i32 [ %189, %179 ], [ %166, %163 ]
%183 = getelementptr inbounds i8, i8* %181, i64 -1
%184 = load i8, i8* %183
%185 = getelementptr inbounds i8, i8* %180, i64 -1
%186 = load i8, i8* %185
%187 = icmp ne i8 %184, %186
%188 = zext i1 %187 to i32
%189 = add nuw nsw i32 %182, %188
%190 = icmp ugt i8* %183, %8
br i1 %190, label %179, label %191
191: ; preds = %179, %159, %108
%192 = phi i32 [ 0, %108 ], [ %161, %159 ], [ %189, %179 ]
%193 = getelementptr inbounds i8, i8* %1, i64 %6
br i1 %9, label %194, label %243
194: ; preds = %191
%195 = add i64 %5, %6
%196 = add i64 %5, 1
%197 = call i64 @llvm.umax.i64(i64 %195, i64 %196)
%198 = sub i64 %197, %5
%199 = icmp ult i64 %198, 8
br i1 %199, label %239, label %200
200: ; preds = %194
%201 = and i64 %198, -8
%202 = sub i64 0, %201
%203 = getelementptr i8, i8* %193, i64 %202
%204 = getelementptr i8, i8* %0, i64 %201
%205 = getelementptr i8, i8* %193, i64 -1
br label %206
206: ; preds = %206, %200
%207 = phi i64 [ 0, %200 ], [ %233, %206 ]
%208 = phi <4 x i32> [ zeroinitializer, %200 ], [ %231, %206 ]
%209 = phi <4 x i32> [ zeroinitializer, %200 ], [ %232, %206 ]
%210 = sub i64 0, %207
%211 = getelementptr i8, i8* %0, i64 %207
%212 = bitcast i8* %211 to <4 x i8>*
%213 = load <4 x i8>, <4 x i8>* %212
%214 = getelementptr i8, i8* %211, i64 4
%215 = bitcast i8* %214 to <4 x i8>*
%216 = load <4 x i8>, <4 x i8>* %215
%217 = getelementptr inbounds i8, i8* %205, i64 %210
%218 = getelementptr inbounds i8, i8* %217, i64 -3
%219 = bitcast i8* %218 to <4 x i8>*
%220 = load <4 x i8>, <4 x i8>* %219
%221 = shufflevector <4 x i8> %220, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%222 = getelementptr inbounds i8, i8* %217, i64 -4
%223 = getelementptr inbounds i8, i8* %222, i64 -3
%224 = bitcast i8* %223 to <4 x i8>*
%225 = load <4 x i8>, <4 x i8>* %224
%226 = shufflevector <4 x i8> %225, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%227 = icmp ne <4 x i8> %213, %221
%228 = icmp ne <4 x i8> %216, %226
%229 = zext <4 x i1> %227 to <4 x i32>
%230 = zext <4 x i1> %228 to <4 x i32>
%231 = add <4 x i32> %208, %229
%232 = add <4 x i32> %209, %230
%233 = add nuw i64 %207, 8
%234 = icmp eq i64 %233, %201
br i1 %234, label %235, label %206
235: ; preds = %206
%236 = add <4 x i32> %232, %231
%237 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %236)
%238 = icmp eq i64 %198, %201
br i1 %238, label %243, label %239
239: ; preds = %194, %235
%240 = phi i32 [ 0, %194 ], [ %237, %235 ]
%241 = phi i8* [ %193, %194 ], [ %203, %235 ]
%242 = phi i8* [ %0, %194 ], [ %204, %235 ]
br label %297
243: ; preds = %297, %235, %191
%244 = phi i8* [ %0, %191 ], [ %204, %235 ], [ %301, %297 ]
%245 = phi i8* [ %193, %191 ], [ %203, %235 ], [ %303, %297 ]
%246 = phi i32 [ 0, %191 ], [ %237, %235 ], [ %307, %297 ]
%247 = icmp ugt i8* %244, %8
br i1 %247, label %248, label %309
248: ; preds = %243
%249 = ptrtoint i8* %244 to i64
%250 = add i64 %249, 3
%251 = add i64 %5, %6
%252 = sub i64 %250, %251
%253 = icmp ult i64 %252, 8
br i1 %253, label %293, label %254
254: ; preds = %248
%255 = and i64 %252, -8
%256 = getelementptr i8, i8* %245, i64 %255
%257 = sub i64 0, %255
%258 = getelementptr i8, i8* %244, i64 %257
%259 = getelementptr i8, i8* %244, i64 -1
br label %260
260: ; preds = %260, %254
%261 = phi i64 [ 0, %254 ], [ %287, %260 ]
%262 = phi <4 x i32> [ zeroinitializer, %254 ], [ %285, %260 ]
%263 = phi <4 x i32> [ zeroinitializer, %254 ], [ %286, %260 ]
%264 = getelementptr i8, i8* %245, i64 %261
%265 = sub i64 0, %261
%266 = getelementptr inbounds i8, i8* %259, i64 %265
%267 = getelementptr inbounds i8, i8* %266, i64 -3
%268 = bitcast i8* %267 to <4 x i8>*
%269 = load <4 x i8>, <4 x i8>* %268
%270 = shufflevector <4 x i8> %269, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%271 = getelementptr inbounds i8, i8* %266, i64 -4
%272 = getelementptr inbounds i8, i8* %271, i64 -3
%273 = bitcast i8* %272 to <4 x i8>*
%274 = load <4 x i8>, <4 x i8>* %273
%275 = shufflevector <4 x i8> %274, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%276 = bitcast i8* %264 to <4 x i8>*
%277 = load <4 x i8>, <4 x i8>* %276
%278 = getelementptr i8, i8* %264, i64 4
%279 = bitcast i8* %278 to <4 x i8>*
%280 = load <4 x i8>, <4 x i8>* %279
%281 = icmp ne <4 x i8> %270, %277
%282 = icmp ne <4 x i8> %275, %280
%283 = zext <4 x i1> %281 to <4 x i32>
%284 = zext <4 x i1> %282 to <4 x i32>
%285 = add <4 x i32> %262, %283
%286 = add <4 x i32> %263, %284
%287 = add nuw i64 %261, 8
%288 = icmp eq i64 %287, %255
br i1 %288, label %289, label %260
289: ; preds = %260
%290 = add <4 x i32> %286, %285
%291 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %290)
%292 = icmp eq i64 %252, %255
br i1 %292, label %309, label %293
293: ; preds = %248, %289
%294 = phi i8* [ %245, %248 ], [ %256, %289 ]
%295 = phi i8* [ %244, %248 ], [ %258, %289 ]
%296 = phi i32 [ 0, %248 ], [ %291, %289 ]
br label %316
297: ; preds = %239, %297
%298 = phi i32 [ %307, %297 ], [ %240, %239 ]
%299 = phi i8* [ %303, %297 ], [ %241, %239 ]
%300 = phi i8* [ %301, %297 ], [ %242, %239 ]
%301 = getelementptr inbounds i8, i8* %300, i64 1
%302 = load i8, i8* %300
%303 = getelementptr inbounds i8, i8* %299, i64 -1
%304 = load i8, i8* %303
%305 = icmp ne i8 %302, %304
%306 = zext i1 %305 to i32
%307 = add nuw nsw i32 %298, %306
%308 = icmp ult i8* %301, %7
br i1 %308, label %297, label %243
309: ; preds = %316, %289, %243
%310 = phi i32 [ 0, %243 ], [ %291, %289 ], [ %326, %316 ]
%311 = getelementptr inbounds i8, i8* %193, i64 -1
%312 = getelementptr inbounds i8, i8* %311, i64 -1
%313 = icmp sgt i32 %111, %3
%314 = icmp ne i32 %192, 0
%315 = select i1 %313, i1 %314, i1 false
br i1 %315, label %328, label %350
316: ; preds = %293, %316
%317 = phi i8* [ %322, %316 ], [ %294, %293 ]
%318 = phi i8* [ %320, %316 ], [ %295, %293 ]
%319 = phi i32 [ %326, %316 ], [ %296, %293 ]
%320 = getelementptr inbounds i8, i8* %318, i64 -1
%321 = load i8, i8* %320
%322 = getelementptr inbounds i8, i8* %317, i64 1
%323 = load i8, i8* %317
%324 = icmp ne i8 %321, %323
%325 = zext i1 %324 to i32
%326 = add nuw nsw i32 %319, %325
%327 = icmp ugt i8* %320, %8
br i1 %327, label %316, label %309
328: ; preds = %309
%329 = load i8, i8* %0
%330 = load i8, i8* %311
%331 = icmp ne i8 %329, %330
%332 = zext i1 %331 to i32
%333 = getelementptr inbounds i8, i8* %0, i64 1
%334 = load i8, i8* %333
%335 = load i8, i8* %312
%336 = icmp ne i8 %334, %335
%337 = zext i1 %336 to i32
%338 = add nuw nsw i32 %332, %337
%339 = getelementptr inbounds i8, i8* %0, i64 2
%340 = load i8, i8* %339
%341 = getelementptr inbounds i8, i8* %312, i64 -1
%342 = load i8, i8* %341
%343 = icmp ne i8 %340, %342
%344 = sext i1 %343 to i32
%345 = icmp sgt i32 %246, %3
%346 = icmp ne i32 %310, 0
%347 = select i1 %345, i1 %346, i1 false
%348 = icmp ne i32 %338, %344
%349 = select i1 %347, i1 %348, i1 false
br i1 %349, label %351, label %350
350: ; preds = %328, %309
br label %351
351: ; preds = %328, %350
%352 = phi i8 [ 0, %350 ], [ 1, %328 ]
ret i8 %352
}