int poly1305aes_53_isequal(const unsigned char x[16],
                           const unsigned char y[16]) {
  register unsigned int d;
  register unsigned int x0;
  register unsigned int x1;
  register unsigned int x2;
  register unsigned int x3;
  register unsigned int x4;
  register unsigned int x5;
  register unsigned int x6;
  register unsigned int x7;
  register unsigned int x8;
  register unsigned int x9;
  register unsigned int x10;
  register unsigned int x11;
  register unsigned int x12;
  register unsigned int x13;
  register unsigned int x14;
  register unsigned int x15;
  register unsigned int y0;
  register unsigned int y1;
  register unsigned int y2;
  register unsigned int y3;
  register unsigned int y4;
  register unsigned int y5;
  register unsigned int y6;
  register unsigned int y7;
  register unsigned int y8;
  register unsigned int y9;
  register unsigned int y10;
  register unsigned int y11;
  register unsigned int y12;
  register unsigned int y13;
  register unsigned int y14;
  register unsigned int y15;
  x0 = *(unsigned char *)(x + 0);
  y0 = *(unsigned char *)(y + 0);
  x1 = *(unsigned char *)(x + 1);
  y1 = *(unsigned char *)(y + 1);
  x2 = *(unsigned char *)(x + 2);
  y2 = *(unsigned char *)(y + 2);
  d = y0 ^ x0;
  x3 = *(unsigned char *)(x + 3);
  y1 ^= x1;
  y3 = *(unsigned char *)(y + 3);
  d |= y1;
  x4 = *(unsigned char *)(x + 4);
  y2 ^= x2;
  y4 = *(unsigned char *)(y + 4);
  d |= y2;
  x5 = *(unsigned char *)(x + 5);
  y3 ^= x3;
  y5 = *(unsigned char *)(y + 5);
  d |= y3;
  x6 = *(unsigned char *)(x + 6);
  y4 ^= x4;
  y6 = *(unsigned char *)(y + 6);
  d |= y4;
  x7 = *(unsigned char *)(x + 7);
  y5 ^= x5;
  y7 = *(unsigned char *)(y + 7);
  d |= y5;
  x8 = *(unsigned char *)(x + 8);
  y6 ^= x6;
  y8 = *(unsigned char *)(y + 8);
  d |= y6;
  x9 = *(unsigned char *)(x + 9);
  y7 ^= x7;
  y9 = *(unsigned char *)(y + 9);
  d |= y7;
  x10 = *(unsigned char *)(x + 10);
  y8 ^= x8;
  y10 = *(unsigned char *)(y + 10);
  d |= y8;
  x11 = *(unsigned char *)(x + 11);
  y9 ^= x9;
  y11 = *(unsigned char *)(y + 11);
  d |= y9;
  x12 = *(unsigned char *)(x + 12);
  y10 ^= x10;
  y12 = *(unsigned char *)(y + 12);
  d |= y10;
  x13 = *(unsigned char *)(x + 13);
  y11 ^= x11;
  y13 = *(unsigned char *)(y + 13);
  d |= y11;
  x14 = *(unsigned char *)(x + 14);
  y12 ^= x12;
  y14 = *(unsigned char *)(y + 14);
  d |= y12;
  x15 = *(unsigned char *)(x + 15);
  y13 ^= x13;
  y15 = *(unsigned char *)(y + 15);
  d |= y13;
  y14 ^= x14;
  d |= y14;
  y15 ^= x15;
  d |= y15;
  d -= 1;
  d >>= 8;
  return d;
}


x86 assembly (clang, -O0):
<poly1305aes_53_isequal>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    %eax,-0x68(%rbp)
mov    -0x60(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x64(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
xor    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    %eax,-0x74(%rbp)
mov    -0x6c(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
xor    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    %eax,-0x78(%rbp)
mov    -0x70(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x9(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
xor    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x74(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xa(%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
xor    -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
mov    %eax,-0x80(%rbp)
mov    -0x78(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xb(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
xor    -0x7c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
mov    %eax,-0x84(%rbp)
mov    -0x7c(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xc(%rax),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
xor    -0x80(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%eax
mov    %eax,-0x88(%rbp)
mov    -0x80(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xd(%rax),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x84(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xe(%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
xor    -0x88(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xe(%rax),%eax
mov    %eax,-0x90(%rbp)
mov    -0x88(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0xf(%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x8c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
mov    %eax,-0x94(%rbp)
mov    -0x8c(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x50(%rbp),%eax
xor    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x54(%rbp),%eax
xor    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<poly1305aes_53_isequal>:
movdqu (%rdi),%xmm0
movdqu (%rsi),%xmm1
pxor   %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
por    %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
por    %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrld  $0x10,%xmm0
por    %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrlw  $0x8,%xmm1
por    %xmm0,%xmm1
movd   %xmm1,%eax
movzbl %al,%eax
add    $0xffffffff,%eax
shr    $0x8,%eax
ret

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

LLVM IR (-O2):
define i32 @poly1305aes_53_isequal(i8* nocapture %0, i8* nocapture %1) {
%3 = bitcast i8* %0 to <16 x i8>*
%4 = load <16 x i8>, <16 x i8>* %3
%5 = bitcast i8* %1 to <16 x i8>*
%6 = load <16 x i8>, <16 x i8>* %5
%7 = xor <16 x i8> %6, %4
%8 = call i8 @llvm.vector.reduce.or.v16i8(<16 x i8> %7)
%9 = zext i8 %8 to i32
%10 = add nsw i32 %9, -1
%11 = lshr i32 %10, 8
ret i32 %11
}