int CompareElements(char *Asn1, char *Asn2, char *Asn3, int Length,
                    char SecStrType, int *Better, int *Worse) {
  register int i, j, Count1, Count2;
  int TotalNumber = 0, Beg;
  *Better = 0;
  *Worse = 0;
  Beg = -1;
  for (i = 0; i < Length; i++) {
    if ((Asn1[i] == SecStrType || Asn2[i] == SecStrType ||
         Asn3[i] == SecStrType) &&
        (i == 0 || (Asn1[i - 1] != SecStrType && Asn2[i - 1] != SecStrType &&
                    Asn3[i - 1] != SecStrType))) {
      TotalNumber++;
      Beg = i;
    } else if (Beg != -1 && (i == Length - 1 ||
                             (Asn1[i] != SecStrType && Asn2[i] != SecStrType &&
                              Asn3[i] != SecStrType))) {
      Count1 = Count2 = 0;
      for (j = Beg; j <= i; j++) {
        if ((Asn1[j] == SecStrType || Asn2[j] == SecStrType) &&
            Asn1[j] != Asn2[j])
          Count1++;
        if ((Asn3[j] == SecStrType || Asn2[j] == SecStrType) &&
            Asn3[j] != Asn2[j])
          Count2++;
      }
      if (Count1 > Count2)
        (*Worse)++;
      else if (Count2 > Count1)
        (*Better)++;
      Beg = -1;
    }
  }
  return (TotalNumber);
}


x86 assembly (clang, -O0):
<CompareElements>:
push   %rbp
mov    %rsp,%rbp
mov    %r8b,%al
mov    0x10(%rbp),%r8
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %al,-0x1d(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
movl   $0xffffffff,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13b2 <CompareElements+0x2b2>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     119e <CompareElements+0x9e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     119e <CompareElements+0x9e>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
jne    1213 <CompareElements+0x113>
cmpl   $0x0,-0x2c(%rbp)
je     11ff <CompareElements+0xff>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     1213 <CompareElements+0x113>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     1213 <CompareElements+0x113>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     1213 <CompareElements+0x113>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    139f <CompareElements+0x29f>
cmpl   $0xffffffff,-0x40(%rbp)
je     139a <CompareElements+0x29a>
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1276 <CompareElements+0x176>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     139a <CompareElements+0x29a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     139a <CompareElements+0x29a>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     139a <CompareElements+0x29a>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     135b <CompareElements+0x25b>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     12c6 <CompareElements+0x1c6>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
jne    12ef <CompareElements+0x1ef>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     12ef <CompareElements+0x1ef>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
je     131f <CompareElements+0x21f>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
jne    1348 <CompareElements+0x248>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1348 <CompareElements+0x248>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    134d <CompareElements+0x24d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    128a <CompareElements+0x18a>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1377 <CompareElements+0x277>
mov    0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1393 <CompareElements+0x293>
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    138e <CompareElements+0x28e>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1393 <CompareElements+0x293>
movl   $0xffffffff,-0x40(%rbp)
jmp    139f <CompareElements+0x29f>
jmp    13a4 <CompareElements+0x2a4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114a <CompareElements+0x4a>
mov    -0x3c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<CompareElements>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x38(%rsp),%rax
mov    %r9,-0x28(%rsp)
movl   $0x0,(%r9)
movl   $0x0,(%rax)
test   %ecx,%ecx
jle    14de <CompareElements+0x3de>
lea    -0x1(%rcx),%r9d
mov    %ecx,%ebp
movzbl %r8b,%eax
movd   %eax,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm11
lea    0x4(%rdi),%rax
mov    %rax,-0x10(%rsp)
lea    0x4(%rsi),%rax
mov    %rax,-0x18(%rsp)
lea    0x4(%rdx),%rax
mov    %rax,-0x20(%rsp)
xor    %r12d,%r12d
mov    $0xffffffff,%ecx
xor    %eax,%eax
mov    %r9,-0x30(%rsp)
mov    %rbp,-0x38(%rsp)
jmp    1196 <CompareElements+0x96>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%eax
mov    %r12d,%r10d
add    $0x1,%r12
mov    %r10d,%ecx
cmp    %rbp,%r12
je     14e0 <CompareElements+0x3e0>
mov    (%rdi,%r12,1),%bl
cmp    %r8b,%bl
je     11b0 <CompareElements+0xb0>
cmp    %r8b,(%rsi,%r12,1)
je     11b0 <CompareElements+0xb0>
cmp    %r8b,(%rdx,%r12,1)
jne    11d0 <CompareElements+0xd0>
nopl   0x0(%rax,%rax,1)
test   %r12,%r12
je     1180 <CompareElements+0x80>
cmp    %r8b,-0x1(%r12,%rdi,1)
je     11d0 <CompareElements+0xd0>
cmp    %r8b,-0x1(%rsi,%r12,1)
je     11d0 <CompareElements+0xd0>
cmp    %r8b,-0x1(%rdx,%r12,1)
jne    1180 <CompareElements+0x80>
nopw   0x0(%rax,%rax,1)
mov    $0xffffffff,%r10d
cmp    $0xffffffff,%ecx
je     1186 <CompareElements+0x86>
cmp    %r9,%r12
jne    1203 <CompareElements+0x103>
movslq %ecx,%r13
cmp    %r13,%r12
jl     1186 <CompareElements+0x86>
mov    %r12d,%ebx
sub    %ecx,%ebx
xor    %ebp,%ebp
cmp    $0x7,%ebx
mov    %eax,-0x3c(%rsp)
jae    121c <CompareElements+0x11c>
mov    %r13,%r15
xor    %r11d,%r11d
jmp    1468 <CompareElements+0x368>
cmp    %r8b,%bl
je     1214 <CompareElements+0x114>
cmp    %r8b,(%rsi,%r12,1)
je     1214 <CompareElements+0x114>
cmp    %r8b,(%rdx,%r12,1)
jne    11e0 <CompareElements+0xe0>
mov    %ecx,%r10d
jmp    1186 <CompareElements+0x86>
lea    0x1(%rbx),%rax
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x8(%rsp)
lea    (%rcx,%r13,1),%r15
add    $0x1,%rbx
and    $0xfffffffffffffff8,%rbx
mov    -0x10(%rsp),%rcx
lea    (%rcx,%r13,1),%r14
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r13,1),%r9
add    -0x20(%rsp),%r13
pxor   %xmm10,%xmm10
xor    %r11d,%r11d
pxor   %xmm12,%xmm12
pxor   %xmm13,%xmm13
pxor   %xmm14,%xmm14
cs nopw 0x0(%rax,%rax,1)
movd   -0x4(%r14,%r11,1),%xmm0
movd   (%r14,%r11,1),%xmm3
movdqa %xmm0,%xmm6
pcmpeqb %xmm11,%xmm6
movdqa %xmm6,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
movdqa %xmm3,%xmm2
pcmpeqb %xmm11,%xmm2
movdqa %xmm2,%xmm9
punpcklbw %xmm9,%xmm9
punpcklwd %xmm9,%xmm9
movd   -0x4(%r9,%r11,1),%xmm8
movd   (%r9,%r11,1),%xmm15
movdqa %xmm8,%xmm7
pcmpeqb %xmm11,%xmm7
movdqa %xmm7,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
por    %xmm1,%xmm4
movdqa %xmm15,%xmm1
pcmpeqb %xmm11,%xmm1
movdqa %xmm1,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
por    %xmm9,%xmm5
movdqa %xmm8,%xmm9
pand   %xmm6,%xmm9
por    %xmm6,%xmm7
pandn  %xmm11,%xmm6
por    %xmm9,%xmm6
movdqa %xmm15,%xmm9
pand   %xmm2,%xmm9
por    %xmm2,%xmm1
pandn  %xmm11,%xmm2
por    %xmm9,%xmm2
pcmpeqb %xmm6,%xmm0
pand   %xmm7,%xmm6
pandn  %xmm8,%xmm7
movdqa 0xcce(%rip),%xmm8
por    %xmm6,%xmm7
pcmpeqd %xmm6,%xmm6
pcmpeqb %xmm2,%xmm3
pand   %xmm1,%xmm2
pandn  %xmm15,%xmm1
por    %xmm2,%xmm1
pxor   %xmm6,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm8,%xmm4
pand   %xmm0,%xmm4
pxor   %xmm6,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
paddd  %xmm4,%xmm13
pand   %xmm8,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm5,%xmm14
movd   -0x4(%r13,%r11,1),%xmm2
movd   0x0(%r13,%r11,1),%xmm0
movdqa %xmm2,%xmm3
pcmpeqb %xmm11,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pcmpeqb %xmm7,%xmm2
pcmpeqb %xmm11,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
por    %xmm3,%xmm7
movdqa %xmm0,%xmm3
pcmpeqb %xmm11,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pcmpeqb %xmm1,%xmm0
pcmpeqb %xmm11,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
por    %xmm3,%xmm1
pxor   %xmm6,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm7,%xmm2
pxor   %xmm6,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm1,%xmm0
pand   %xmm8,%xmm2
paddd  %xmm2,%xmm10
pand   %xmm8,%xmm0
paddd  %xmm0,%xmm12
add    $0x8,%r11
cmp    %r11,%rbx
jne    1270 <CompareElements+0x170>
paddd  %xmm13,%xmm14
pshufd $0xee,%xmm14,%xmm0
paddd  %xmm14,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%r11d
paddd  %xmm10,%xmm12
pshufd $0xee,%xmm12,%xmm0
paddd  %xmm12,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebp
cmp    -0x8(%rsp),%rax
jne    1468 <CompareElements+0x368>
cmp    %ebp,%r11d
jle    14c1 <CompareElements+0x3c1>
mov    0x38(%rsp),%rax
jmp    14c8 <CompareElements+0x3c8>
lea    0x1(%r12),%r9
jmp    14a8 <CompareElements+0x3a8>
nop
mov    %ecx,%ebx
xor    %ecx,%ecx
cmp    %bl,%al
setne  %cl
add    %ecx,%r11d
mov    %ebx,%ecx
movzbl (%rdx,%r15,1),%eax
cmp    %r8b,%al
sete   %r14b
cmp    %r8b,%cl
sete   %bl
or     %r14b,%bl
cmp    %cl,%al
setne  %al
and    %bl,%al
movzbl %al,%eax
add    %eax,%ebp
add    $0x1,%r15
cmp    %r15d,%r9d
je     145c <CompareElements+0x35c>
movzbl (%rdi,%r15,1),%eax
movzbl (%rsi,%r15,1),%ecx
cmp    %r8b,%al
je     1470 <CompareElements+0x370>
mov    %r8d,%ebx
cmp    %r8b,%cl
je     1472 <CompareElements+0x372>
jmp    147e <CompareElements+0x37e>
jge    14cb <CompareElements+0x3cb>
mov    -0x28(%rsp),%rax
addl   $0x1,(%rax)
mov    -0x30(%rsp),%r9
mov    -0x38(%rsp),%rbp
mov    -0x3c(%rsp),%eax
jmp    1186 <CompareElements+0x86>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @CompareElements(i8* %0, i8* %1, i8* %2, i32 %3, i8 signext %4, i32* %5, i32* %6) {
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i8
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
store i8* %0, i8** %8
store i8* %1, i8** %9
store i8* %2, i8** %10
store i32 %3, i32* %11
store i8 %4, i8* %12
store i32* %5, i32** %13
store i32* %6, i32** %14
store i32 0, i32* %19
%21 = load i32*, i32** %13
store i32 0, i32* %21
%22 = load i32*, i32** %14
store i32 0, i32* %22
store i32 -1, i32* %20
store i32 0, i32* %15
br label %23
23: ; preds = %239, %7
%24 = load i32, i32* %15
%25 = load i32, i32* %11
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %242
27: ; preds = %23
%28 = load i8*, i8** %8
%29 = load i32, i32* %15
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
%34 = load i8, i8* %12
%35 = sext i8 %34 to i32
%36 = icmp eq i32 %33, %35
br i1 %36, label %57, label %37
37: ; preds = %27
%38 = load i8*, i8** %9
%39 = load i32, i32* %15
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = load i8, i8* %12
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %43, %45
br i1 %46, label %57, label %47
47: ; preds = %37
%48 = load i8*, i8** %10
%49 = load i32, i32* %15
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = load i8, i8* %12
%55 = sext i8 %54 to i32
%56 = icmp eq i32 %53, %55
br i1 %56, label %57, label %97
57: ; preds = %47, %37, %27
%58 = load i32, i32* %15
%59 = icmp eq i32 %58, 0
br i1 %59, label %93, label %60
60: ; preds = %57
%61 = load i8*, i8** %8
%62 = load i32, i32* %15
%63 = sub nsw i32 %62, 1
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %61, i64 %64
%66 = load i8, i8* %65
%67 = sext i8 %66 to i32
%68 = load i8, i8* %12
%69 = sext i8 %68 to i32
%70 = icmp ne i32 %67, %69
br i1 %70, label %71, label %97
71: ; preds = %60
%72 = load i8*, i8** %9
%73 = load i32, i32* %15
%74 = sub nsw i32 %73, 1
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %72, i64 %75
%77 = load i8, i8* %76
%78 = sext i8 %77 to i32
%79 = load i8, i8* %12
%80 = sext i8 %79 to i32
%81 = icmp ne i32 %78, %80
br i1 %81, label %82, label %97
82: ; preds = %71
%83 = load i8*, i8** %10
%84 = load i32, i32* %15
%85 = sub nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %83, i64 %86
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = load i8, i8* %12
%91 = sext i8 %90 to i32
%92 = icmp ne i32 %89, %91
br i1 %92, label %93, label %97
93: ; preds = %82, %57
%94 = load i32, i32* %19
%95 = add nsw i32 %94, 1
store i32 %95, i32* %19
%96 = load i32, i32* %15
store i32 %96, i32* %20
br label %238
97: ; preds = %82, %71, %60, %47
%98 = load i32, i32* %20
%99 = icmp ne i32 %98, -1
br i1 %99, label %100, label %237
100: ; preds = %97
%101 = load i32, i32* %15
%102 = load i32, i32* %11
%103 = sub nsw i32 %102, 1
%104 = icmp eq i32 %101, %103
br i1 %104, label %135, label %105
105: ; preds = %100
%106 = load i8*, i8** %8
%107 = load i32, i32* %15
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %106, i64 %108
%110 = load i8, i8* %109
%111 = sext i8 %110 to i32
%112 = load i8, i8* %12
%113 = sext i8 %112 to i32
%114 = icmp ne i32 %111, %113
br i1 %114, label %115, label %237
115: ; preds = %105
%116 = load i8*, i8** %9
%117 = load i32, i32* %15
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i8, i8* %116, i64 %118
%120 = load i8, i8* %119
%121 = sext i8 %120 to i32
%122 = load i8, i8* %12
%123 = sext i8 %122 to i32
%124 = icmp ne i32 %121, %123
br i1 %124, label %125, label %237
125: ; preds = %115
%126 = load i8*, i8** %10
%127 = load i32, i32* %15
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
%130 = load i8, i8* %129
%131 = sext i8 %130 to i32
%132 = load i8, i8* %12
%133 = sext i8 %132 to i32
%134 = icmp ne i32 %131, %133
br i1 %134, label %135, label %237
135: ; preds = %125, %100
store i32 0, i32* %18
store i32 0, i32* %17
%136 = load i32, i32* %20
store i32 %136, i32* %16
br label %137
137: ; preds = %216, %135
%138 = load i32, i32* %16
%139 = load i32, i32* %15
%140 = icmp sle i32 %138, %139
br i1 %140, label %141, label %219
141: ; preds = %137
%142 = load i8*, i8** %8
%143 = load i32, i32* %16
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i8, i8* %142, i64 %144
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = load i8, i8* %12
%149 = sext i8 %148 to i32
%150 = icmp eq i32 %147, %149
br i1 %150, label %161, label %151
151: ; preds = %141
%152 = load i8*, i8** %9
%153 = load i32, i32* %16
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i8, i8* %152, i64 %154
%156 = load i8, i8* %155
%157 = sext i8 %156 to i32
%158 = load i8, i8* %12
%159 = sext i8 %158 to i32
%160 = icmp eq i32 %157, %159
br i1 %160, label %161, label %178
161: ; preds = %151, %141
%162 = load i8*, i8** %8
%163 = load i32, i32* %16
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %162, i64 %164
%166 = load i8, i8* %165
%167 = sext i8 %166 to i32
%168 = load i8*, i8** %9
%169 = load i32, i32* %16
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i8, i8* %168, i64 %170
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = icmp ne i32 %167, %173
br i1 %174, label %175, label %178
175: ; preds = %161
%176 = load i32, i32* %17
%177 = add nsw i32 %176, 1
store i32 %177, i32* %17
br label %178
178: ; preds = %175, %161, %151
%179 = load i8*, i8** %10
%180 = load i32, i32* %16
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %179, i64 %181
%183 = load i8, i8* %182
%184 = sext i8 %183 to i32
%185 = load i8, i8* %12
%186 = sext i8 %185 to i32
%187 = icmp eq i32 %184, %186
br i1 %187, label %198, label %188
188: ; preds = %178
%189 = load i8*, i8** %9
%190 = load i32, i32* %16
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %189, i64 %191
%193 = load i8, i8* %192
%194 = sext i8 %193 to i32
%195 = load i8, i8* %12
%196 = sext i8 %195 to i32
%197 = icmp eq i32 %194, %196
br i1 %197, label %198, label %215
198: ; preds = %188, %178
%199 = load i8*, i8** %10
%200 = load i32, i32* %16
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i8, i8* %199, i64 %201
%203 = load i8, i8* %202
%204 = sext i8 %203 to i32
%205 = load i8*, i8** %9
%206 = load i32, i32* %16
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i8, i8* %205, i64 %207
%209 = load i8, i8* %208
%210 = sext i8 %209 to i32
%211 = icmp ne i32 %204, %210
br i1 %211, label %212, label %215
212: ; preds = %198
%213 = load i32, i32* %18
%214 = add nsw i32 %213, 1
store i32 %214, i32* %18
br label %215
215: ; preds = %212, %198, %188
br label %216
216: ; preds = %215
%217 = load i32, i32* %16
%218 = add nsw i32 %217, 1
store i32 %218, i32* %16
br label %137
219: ; preds = %137
%220 = load i32, i32* %17
%221 = load i32, i32* %18
%222 = icmp sgt i32 %220, %221
br i1 %222, label %223, label %227
223: ; preds = %219
%224 = load i32*, i32** %14
%225 = load i32, i32* %224
%226 = add nsw i32 %225, 1
store i32 %226, i32* %224
br label %236
227: ; preds = %219
%228 = load i32, i32* %18
%229 = load i32, i32* %17
%230 = icmp sgt i32 %228, %229
br i1 %230, label %231, label %235
231: ; preds = %227
%232 = load i32*, i32** %13
%233 = load i32, i32* %232
%234 = add nsw i32 %233, 1
store i32 %234, i32* %232
br label %235
235: ; preds = %231, %227
br label %236
236: ; preds = %235, %223
store i32 -1, i32* %20
br label %237
237: ; preds = %236, %125, %115, %105, %97
br label %238
238: ; preds = %237, %93
br label %239
239: ; preds = %238
%240 = load i32, i32* %15
%241 = add nsw i32 %240, 1
store i32 %241, i32* %15
br label %23
242: ; preds = %23
%243 = load i32, i32* %19
ret i32 %243
}

LLVM IR (-O2):
define i32 @CompareElements(i8* nocapture %0, i8* nocapture %1, i8* nocapture %2, i32 %3, i8 signext %4, i32* nocapture %5, i32* nocapture %6) {
store i32 0, i32* %5
store i32 0, i32* %6
%8 = icmp sgt i32 %3, 0
br i1 %8, label %9, label %198
9: ; preds = %7
%10 = add nsw i32 %3, -1
%11 = zext i32 %10 to i64
%12 = zext i32 %3 to i64
%13 = insertelement <4 x i8> poison, i8 %4, i64 0
%14 = shufflevector <4 x i8> %13, <4 x i8> poison, <4 x i32> zeroinitializer
%15 = insertelement <4 x i8> poison, i8 %4, i64 0
%16 = shufflevector <4 x i8> %15, <4 x i8> poison, <4 x i32> zeroinitializer
br label %17
17: ; preds = %9, %192
%18 = phi i64 [ 0, %9 ], [ %195, %192 ]
%19 = phi i32 [ 1, %9 ], [ %196, %192 ]
%20 = phi i32 [ -1, %9 ], [ %194, %192 ]
%21 = phi i32 [ 0, %9 ], [ %193, %192 ]
%22 = trunc i64 %18 to i32
%23 = getelementptr inbounds i8, i8* %0, i64 %18
%24 = load i8, i8* %23
%25 = icmp eq i8 %24, %4
br i1 %25, label %34, label %26
26: ; preds = %17
%27 = getelementptr inbounds i8, i8* %1, i64 %18
%28 = load i8, i8* %27
%29 = icmp eq i8 %28, %4
br i1 %29, label %34, label %30
30: ; preds = %26
%31 = getelementptr inbounds i8, i8* %2, i64 %18
%32 = load i8, i8* %31
%33 = icmp eq i8 %32, %4
br i1 %33, label %34, label %52
34: ; preds = %30, %26, %17
%35 = icmp eq i64 %18, 0
br i1 %35, label %49, label %36
36: ; preds = %34
%37 = add nsw i64 %18, -1
%38 = getelementptr inbounds i8, i8* %0, i64 %37
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, %4
br i1 %40, label %52, label %41
41: ; preds = %36
%42 = getelementptr inbounds i8, i8* %1, i64 %37
%43 = load i8, i8* %42
%44 = icmp eq i8 %43, %4
br i1 %44, label %52, label %45
45: ; preds = %41
%46 = getelementptr inbounds i8, i8* %2, i64 %37
%47 = load i8, i8* %46
%48 = icmp eq i8 %47, %4
br i1 %48, label %52, label %49
49: ; preds = %45, %34
%50 = add nsw i32 %21, 1
%51 = trunc i64 %18 to i32
br label %192
52: ; preds = %45, %41, %36, %30
%53 = icmp eq i32 %20, -1
br i1 %53, label %192, label %54
54: ; preds = %52
%55 = icmp eq i64 %18, %11
br i1 %55, label %65, label %56
56: ; preds = %54
br i1 %25, label %192, label %57
57: ; preds = %56
%58 = getelementptr inbounds i8, i8* %1, i64 %18
%59 = load i8, i8* %58
%60 = icmp eq i8 %59, %4
br i1 %60, label %192, label %61
61: ; preds = %57
%62 = getelementptr inbounds i8, i8* %2, i64 %18
%63 = load i8, i8* %62
%64 = icmp eq i8 %63, %4
br i1 %64, label %192, label %65
65: ; preds = %61, %54
%66 = sext i32 %20 to i64
%67 = icmp slt i64 %18, %66
br i1 %67, label %192, label %68
68: ; preds = %65
%69 = sub i32 %22, %20
%70 = zext i32 %69 to i64
%71 = add nuw nsw i64 %70, 1
%72 = icmp ult i32 %69, 7
br i1 %72, label %145, label %73
73: ; preds = %68
%74 = and i64 %71, 8589934584
%75 = add nsw i64 %74, %66
br label %76
76: ; preds = %76, %73
%77 = phi i64 [ 0, %73 ], [ %137, %76 ]
%78 = phi <4 x i32> [ zeroinitializer, %73 ], [ %135, %76 ]
%79 = phi <4 x i32> [ zeroinitializer, %73 ], [ %136, %76 ]
%80 = phi <4 x i32> [ zeroinitializer, %73 ], [ %113, %76 ]
%81 = phi <4 x i32> [ zeroinitializer, %73 ], [ %116, %76 ]
%82 = add i64 %77, %66
%83 = getelementptr inbounds i8, i8* %0, i64 %82
%84 = bitcast i8* %83 to <4 x i8>*
%85 = load <4 x i8>, <4 x i8>* %84
%86 = getelementptr inbounds i8, i8* %83, i64 4
%87 = bitcast i8* %86 to <4 x i8>*
%88 = load <4 x i8>, <4 x i8>* %87
%89 = icmp eq <4 x i8> %85, %14
%90 = icmp eq <4 x i8> %88, %16
%91 = getelementptr inbounds i8, i8* %1, i64 %82
%92 = bitcast i8* %91 to <4 x i8>*
%93 = load <4 x i8>, <4 x i8>* %92
%94 = getelementptr inbounds i8, i8* %91, i64 4
%95 = bitcast i8* %94 to <4 x i8>*
%96 = load <4 x i8>, <4 x i8>* %95
%97 = icmp eq <4 x i8> %93, %14
%98 = icmp eq <4 x i8> %96, %16
%99 = xor <4 x i1> %89, <i1 true, i1 true, i1 true, i1 true>
%100 = xor <4 x i1> %90, <i1 true, i1 true, i1 true, i1 true>
%101 = select <4 x i1> %99, <4 x i1> %97, <4 x i1> zeroinitializer
%102 = select <4 x i1> %100, <4 x i1> %98, <4 x i1> zeroinitializer
%103 = select <4 x i1> %89, <4 x i8> %93, <4 x i8> %14
%104 = select <4 x i1> %90, <4 x i8> %96, <4 x i8> %16
%105 = icmp ne <4 x i8> %85, %103
%106 = icmp ne <4 x i8> %88, %104
%107 = or <4 x i1> %89, %101
%108 = or <4 x i1> %90, %102
%109 = select <4 x i1> %107, <4 x i8> %103, <4 x i8> %93
%110 = select <4 x i1> %108, <4 x i8> %104, <4 x i8> %96
%111 = select <4 x i1> %107, <4 x i1> %105, <4 x i1> zeroinitializer
%112 = zext <4 x i1> %111 to <4 x i32>
%113 = add <4 x i32> %80, %112
%114 = select <4 x i1> %108, <4 x i1> %106, <4 x i1> zeroinitializer
%115 = zext <4 x i1> %114 to <4 x i32>
%116 = add <4 x i32> %81, %115
%117 = getelementptr inbounds i8, i8* %2, i64 %82
%118 = bitcast i8* %117 to <4 x i8>*
%119 = load <4 x i8>, <4 x i8>* %118
%120 = getelementptr inbounds i8, i8* %117, i64 4
%121 = bitcast i8* %120 to <4 x i8>*
%122 = load <4 x i8>, <4 x i8>* %121
%123 = icmp eq <4 x i8> %119, %14
%124 = icmp eq <4 x i8> %122, %16
%125 = icmp eq <4 x i8> %109, %14
%126 = icmp eq <4 x i8> %110, %16
%127 = select <4 x i1> %123, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %125
%128 = select <4 x i1> %124, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %126
%129 = icmp ne <4 x i8> %119, %109
%130 = icmp ne <4 x i8> %122, %110
%131 = select <4 x i1> %127, <4 x i1> %129, <4 x i1> zeroinitializer
%132 = select <4 x i1> %128, <4 x i1> %130, <4 x i1> zeroinitializer
%133 = zext <4 x i1> %131 to <4 x i32>
%134 = zext <4 x i1> %132 to <4 x i32>
%135 = add <4 x i32> %78, %133
%136 = add <4 x i32> %79, %134
%137 = add nuw i64 %77, 8
%138 = icmp eq i64 %137, %74
br i1 %138, label %139, label %76
139: ; preds = %76
%140 = add <4 x i32> %116, %113
%141 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %140)
%142 = add <4 x i32> %136, %135
%143 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %142)
%144 = icmp eq i64 %71, %74
br i1 %144, label %180, label %145
145: ; preds = %68, %139
%146 = phi i64 [ %66, %68 ], [ %75, %139 ]
%147 = phi i32 [ 0, %68 ], [ %143, %139 ]
%148 = phi i32 [ 0, %68 ], [ %141, %139 ]
br label %149
149: ; preds = %145, %165
%150 = phi i64 [ %177, %165 ], [ %146, %145 ]
%151 = phi i32 [ %176, %165 ], [ %147, %145 ]
%152 = phi i32 [ %167, %165 ], [ %148, %145 ]
%153 = getelementptr inbounds i8, i8* %0, i64 %150
%154 = load i8, i8* %153
%155 = icmp eq i8 %154, %4
%156 = getelementptr inbounds i8, i8* %1, i64 %150
%157 = load i8, i8* %156
br i1 %155, label %160, label %158
158: ; preds = %149
%159 = icmp eq i8 %157, %4
br i1 %159, label %160, label %165
160: ; preds = %149, %158
%161 = phi i8 [ %4, %158 ], [ %157, %149 ]
%162 = icmp ne i8 %154, %161
%163 = zext i1 %162 to i32
%164 = add nsw i32 %152, %163
br label %165
165: ; preds = %160, %158
%166 = phi i8 [ %157, %158 ], [ %161, %160 ]
%167 = phi i32 [ %152, %158 ], [ %164, %160 ]
%168 = getelementptr inbounds i8, i8* %2, i64 %150
%169 = load i8, i8* %168
%170 = icmp eq i8 %169, %4
%171 = icmp eq i8 %166, %4
%172 = select i1 %170, i1 true, i1 %171
%173 = icmp ne i8 %169, %166
%174 = select i1 %172, i1 %173, i1 false
%175 = zext i1 %174 to i32
%176 = add nuw nsw i32 %151, %175
%177 = add nsw i64 %150, 1
%178 = trunc i64 %177 to i32
%179 = icmp eq i32 %19, %178
br i1 %179, label %180, label %149
180: ; preds = %165, %139
%181 = phi i32 [ %141, %139 ], [ %167, %165 ]
%182 = phi i32 [ %143, %139 ], [ %176, %165 ]
%183 = icmp sgt i32 %181, %182
br i1 %183, label %184, label %187
184: ; preds = %180
%185 = load i32, i32* %6
%186 = add nsw i32 %185, 1
store i32 %186, i32* %6
br label %192
187: ; preds = %180
%188 = icmp sgt i32 %182, %181
br i1 %188, label %189, label %192
189: ; preds = %187
%190 = load i32, i32* %5
%191 = add nsw i32 %190, 1
store i32 %191, i32* %5
br label %192
192: ; preds = %65, %184, %189, %187, %49, %61, %57, %56, %52
%193 = phi i32 [ %50, %49 ], [ %21, %61 ], [ %21, %57 ], [ %21, %56 ], [ %21, %52 ], [ %21, %187 ], [ %21, %189 ], [ %21, %184 ], [ %21, %65 ]
%194 = phi i32 [ %51, %49 ], [ %20, %61 ], [ %20, %57 ], [ %20, %56 ], [ -1, %52 ], [ -1, %187 ], [ -1, %189 ], [ -1, %184 ], [ -1, %65 ]
%195 = add nuw nsw i64 %18, 1
%196 = add nuw i32 %19, 1
%197 = icmp eq i64 %195, %12
br i1 %197, label %198, label %17
198: ; preds = %192, %7
%199 = phi i32 [ 0, %7 ], [ %193, %192 ]
ret i32 %199
}