#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void find_two_repeating(int arr[], size_t arr_len, int *a, int *b) {
  assert(arr_len > 3);
  size_t n = arr_len - 2;
  int i;
  int xor_dups = 0;
  for (i = 0; i < arr_len; i++)
    xor_dups ^= arr[i];
  for (i = 1; i <= n; i++)
    xor_dups ^= i;
  int diff_bit = xor_dups & -xor_dups;
  *a = 0;
  *b = 0;
  for (i = 0; i < arr_len; i++)
    if (arr[i] & diff_bit)
      *a ^= arr[i];
    else
      *b ^= arr[i];
  for (i = 1; i <= n; i++)
    if (i & diff_bit)
      *a ^= i;
    else
      *b ^= i;
}


x86 assembly (clang, -O0):
<find_two_repeating>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
cmpq   $0x3,-0x10(%rbp)
seta   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1181 <find_two_repeating+0x71>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1154 <find_two_repeating+0x44>
movl   $0x1,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
cmp    -0x28(%rbp),%rax
ja     11ad <find_two_repeating+0x9d>
mov    -0x2c(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1188 <find_two_repeating+0x78>
mov    -0x30(%rbp),%eax
xor    %ecx,%ecx
sub    -0x30(%rbp),%ecx
and    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1238 <find_two_repeating+0x128>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    -0x34(%rbp),%eax
cmp    $0x0,%eax
je     1212 <find_two_repeating+0x102>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x18(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
jmp    1225 <find_two_repeating+0x115>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x20(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
jmp    122a <find_two_repeating+0x11a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d5 <find_two_repeating+0xc5>
movl   $0x1,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
cmp    -0x28(%rbp),%rax
ja     128a <find_two_repeating+0x17a>
mov    -0x2c(%rbp),%eax
and    -0x34(%rbp),%eax
cmp    $0x0,%eax
je     126c <find_two_repeating+0x15c>
mov    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
jmp    1277 <find_two_repeating+0x167>
mov    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
jmp    127c <find_two_repeating+0x16c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123f <find_two_repeating+0x12f>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_two_repeating>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r14
mov    %rdx,%r12
mov    %rsi,%r15
mov    %rdi,%rbx
xor    %edi,%edi
cmp    $0x4,%rsi
setae  %dil
call   1030 <assert@plt>
test   %r15,%r15
je     1147 <find_two_repeating+0x37>
cmp    $0x8,%r15
jae    114e <find_two_repeating+0x3e>
xor    %eax,%eax
xor    %esi,%esi
jmp    1240 <find_two_repeating+0x130>
xor    %esi,%esi
jmp    1259 <find_two_repeating+0x149>
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdx
jae    117b <find_two_repeating+0x6b>
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
jmp    11e9 <find_two_repeating+0xd9>
and    $0xfffffffffffffffc,%rsi
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu (%rbx,%rdx,4),%xmm2
pxor   %xmm0,%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm0
pxor   %xmm1,%xmm0
movdqu 0x20(%rbx,%rdx,4),%xmm1
movdqu 0x30(%rbx,%rdx,4),%xmm3
movdqu 0x40(%rbx,%rdx,4),%xmm4
pxor   %xmm1,%xmm4
pxor   %xmm2,%xmm4
movdqu 0x50(%rbx,%rdx,4),%xmm2
pxor   %xmm3,%xmm2
pxor   %xmm0,%xmm2
movdqu 0x60(%rbx,%rdx,4),%xmm0
pxor   %xmm4,%xmm0
movdqu 0x70(%rbx,%rdx,4),%xmm1
pxor   %xmm2,%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1190 <find_two_repeating+0x80>
test   %rcx,%rcx
je     121c <find_two_repeating+0x10c>
lea    (%rbx,%rdx,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movdqu -0x10(%rdx,%rsi,1),%xmm2
pxor   %xmm2,%xmm0
movdqu (%rdx,%rsi,1),%xmm2
pxor   %xmm2,%xmm1
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1200 <find_two_repeating+0xf0>
pxor   %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pxor   %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pxor   %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %r15,%rax
je     124c <find_two_repeating+0x13c>
nopl   0x0(%rax,%rax,1)
xor    (%rbx,%rax,4),%esi
add    $0x1,%rax
cmp    %rax,%r15
jne    1240 <find_two_repeating+0x130>
mov    $0x1,%r8b
cmp    $0x2,%r15
je     13de <find_two_repeating+0x2ce>
lea    -0x1(%r15),%rcx
cmp    $0x3,%rcx
mov    $0x2,%eax
cmovae %rcx,%rax
lea    -0x1(%rax),%r8
mov    $0x1,%ecx
cmp    $0x8,%r8
jb     13d0 <find_two_repeating+0x2c0>
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %esi,%xmm0
lea    -0x8(%rcx),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rdx
jae    12b3 <find_two_repeating+0x1a3>
movdqa 0xd56(%rip),%xmm6
pxor   %xmm2,%xmm2
jmp    1378 <find_two_repeating+0x268>
and    $0xfffffffffffffffc,%rdi
movdqa 0xd41(%rip),%xmm6
pxor   %xmm2,%xmm2
movdqa 0xd44(%rip),%xmm8
movdqa 0xd4b(%rip),%xmm9
movdqa 0xd52(%rip),%xmm10
movdqa 0xd59(%rip),%xmm11
movdqa 0xd60(%rip),%xmm12
movdqa 0xd67(%rip),%xmm13
movdqa 0xd6f(%rip),%xmm4
movdqa 0xd77(%rip),%xmm5
nopl   0x0(%rax)
movdqa %xmm6,%xmm3
paddd  %xmm8,%xmm3
pxor   %xmm2,%xmm3
pxor   %xmm6,%xmm0
movdqa %xmm6,%xmm2
paddd  %xmm9,%xmm2
pxor   %xmm0,%xmm2
movdqa %xmm6,%xmm0
paddd  %xmm10,%xmm0
movdqa %xmm6,%xmm7
paddd  %xmm11,%xmm7
movdqa %xmm6,%xmm1
paddd  %xmm12,%xmm1
pxor   %xmm0,%xmm1
pxor   %xmm3,%xmm1
movdqa %xmm6,%xmm0
paddd  %xmm13,%xmm0
pxor   %xmm7,%xmm0
pxor   %xmm2,%xmm0
movdqa %xmm6,%xmm2
paddd  %xmm4,%xmm2
pxor   %xmm1,%xmm2
paddd  %xmm5,%xmm6
add    $0xfffffffffffffffc,%rdi
jne    1310 <find_two_repeating+0x200>
test   %rsi,%rsi
je     13aa <find_two_repeating+0x29a>
movdqa 0xc8b(%rip),%xmm3
movdqa 0xc93(%rip),%xmm4
nopl   (%rax)
movdqa %xmm6,%xmm1
paddd  %xmm3,%xmm1
pxor   %xmm1,%xmm2
pxor   %xmm6,%xmm0
paddd  %xmm4,%xmm6
add    $0xffffffffffffffff,%rsi
jne    1390 <find_two_repeating+0x280>
pxor   %xmm2,%xmm0
pshufd $0xee,%xmm0,%xmm1
pxor   %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pxor   %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %rcx,%r8
je     13db <find_two_repeating+0x2cb>
or     $0x1,%rcx
nopl   (%rax)
xor    %ecx,%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13d0 <find_two_repeating+0x2c0>
xor    %r8d,%r8d
mov    %esi,%eax
neg    %eax
and    %esi,%eax
movl   $0x0,(%r12)
movl   $0x0,(%r14)
test   %r15,%r15
je     144a <find_two_repeating+0x33a>
cmp    $0x1,%r15
jne    1402 <find_two_repeating+0x2f2>
xor    %edx,%edx
jmp    1436 <find_two_repeating+0x326>
mov    %r15,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,4),%edi
test   %eax,%edi
mov    %r12,%rcx
cmove  %r14,%rcx
xor    %edi,(%rcx)
mov    0x4(%rbx,%rdx,4),%ecx
test   %eax,%ecx
mov    %r12,%rdi
cmove  %r14,%rdi
xor    %ecx,(%rdi)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1410 <find_two_repeating+0x300>
test   $0x1,%r15b
je     144a <find_two_repeating+0x33a>
mov    (%rbx,%rdx,4),%edx
test   %eax,%edx
mov    %r12,%rsi
cmove  %r14,%rsi
xor    %edx,(%rsi)
test   %r8b,%r8b
jne    14cc <find_two_repeating+0x3bc>
add    $0xffffffffffffffff,%r15
cmp    $0x3,%r15
mov    $0x2,%r8d
cmovae %r15,%r8
add    $0xffffffffffffffff,%r8
mov    $0x1,%edx
cmp    $0x3,%r15
jb     14bc <find_two_repeating+0x3ac>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%edi
mov    $0x2,%edx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rdx),%ecx
test   %ecx,%eax
mov    %r12,%rcx
cmove  %r14,%rcx
xor    %edi,(%rcx)
test   %edx,%eax
mov    %r12,%rcx
cmove  %r14,%rcx
xor    %edx,(%rcx)
add    $0x2,%rdi
add    $0x2,%rbx
add    $0x2,%edx
cmp    %rsi,%rbx
jne    1490 <find_two_repeating+0x380>
add    $0xffffffff,%edx
test   $0x1,%r8b
je     14cc <find_two_repeating+0x3bc>
test   %edx,%eax
cmove  %r14,%r12
xor    %edx,(%r12)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @find_two_repeating(i32* %0, i64 %1, i32* %2, i32* %3) {
%5 = alloca i32*
%6 = alloca i64
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32* %0, i32** %5
store i64 %1, i64* %6
store i32* %2, i32** %7
store i32* %3, i32** %8
%13 = load i64, i64* %6
%14 = icmp ugt i64 %13, 3
%15 = zext i1 %14 to i32
%16 = call i32 @assert(i32 %15)
%17 = load i64, i64* %6
%18 = sub i64 %17, 2
store i64 %18, i64* %9
store i32 0, i32* %11
store i32 0, i32* %10
br label %19
19: ; preds = %32, %4
%20 = load i32, i32* %10
%21 = sext i32 %20 to i64
%22 = load i64, i64* %6
%23 = icmp ult i64 %21, %22
br i1 %23, label %24, label %35
24: ; preds = %19
%25 = load i32*, i32** %5
%26 = load i32, i32* %10
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i32, i32* %25, i64 %27
%29 = load i32, i32* %28
%30 = load i32, i32* %11
%31 = xor i32 %30, %29
store i32 %31, i32* %11
br label %32
32: ; preds = %24
%33 = load i32, i32* %10
%34 = add nsw i32 %33, 1
store i32 %34, i32* %10
br label %19
35: ; preds = %19
store i32 1, i32* %10
br label %36
36: ; preds = %45, %35
%37 = load i32, i32* %10
%38 = sext i32 %37 to i64
%39 = load i64, i64* %9
%40 = icmp ule i64 %38, %39
br i1 %40, label %41, label %48
41: ; preds = %36
%42 = load i32, i32* %10
%43 = load i32, i32* %11
%44 = xor i32 %43, %42
store i32 %44, i32* %11
br label %45
45: ; preds = %41
%46 = load i32, i32* %10
%47 = add nsw i32 %46, 1
store i32 %47, i32* %10
br label %36
48: ; preds = %36
%49 = load i32, i32* %11
%50 = load i32, i32* %11
%51 = sub nsw i32 0, %50
%52 = and i32 %49, %51
store i32 %52, i32* %12
%53 = load i32*, i32** %7
store i32 0, i32* %53
%54 = load i32*, i32** %8
store i32 0, i32* %54
store i32 0, i32* %10
br label %55
55: ; preds = %88, %48
%56 = load i32, i32* %10
%57 = sext i32 %56 to i64
%58 = load i64, i64* %6
%59 = icmp ult i64 %57, %58
br i1 %59, label %60, label %91
60: ; preds = %55
%61 = load i32*, i32** %5
%62 = load i32, i32* %10
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %61, i64 %63
%65 = load i32, i32* %64
%66 = load i32, i32* %12
%67 = and i32 %65, %66
%68 = icmp ne i32 %67, 0
br i1 %68, label %69, label %78
69: ; preds = %60
%70 = load i32*, i32** %5
%71 = load i32, i32* %10
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i32, i32* %70, i64 %72
%74 = load i32, i32* %73
%75 = load i32*, i32** %7
%76 = load i32, i32* %75
%77 = xor i32 %76, %74
store i32 %77, i32* %75
br label %87
78: ; preds = %60
%79 = load i32*, i32** %5
%80 = load i32, i32* %10
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %79, i64 %81
%83 = load i32, i32* %82
%84 = load i32*, i32** %8
%85 = load i32, i32* %84
%86 = xor i32 %85, %83
store i32 %86, i32* %84
br label %87
87: ; preds = %78, %69
br label %88
88: ; preds = %87
%89 = load i32, i32* %10
%90 = add nsw i32 %89, 1
store i32 %90, i32* %10
br label %55
91: ; preds = %55
store i32 1, i32* %10
br label %92
92: ; preds = %113, %91
%93 = load i32, i32* %10
%94 = sext i32 %93 to i64
%95 = load i64, i64* %9
%96 = icmp ule i64 %94, %95
br i1 %96, label %97, label %116
97: ; preds = %92
%98 = load i32, i32* %10
%99 = load i32, i32* %12
%100 = and i32 %98, %99
%101 = icmp ne i32 %100, 0
br i1 %101, label %102, label %107
102: ; preds = %97
%103 = load i32, i32* %10
%104 = load i32*, i32** %7
%105 = load i32, i32* %104
%106 = xor i32 %105, %103
store i32 %106, i32* %104
br label %112
107: ; preds = %97
%108 = load i32, i32* %10
%109 = load i32*, i32** %8
%110 = load i32, i32* %109
%111 = xor i32 %110, %108
store i32 %111, i32* %109
br label %112
112: ; preds = %107, %102
br label %113
113: ; preds = %112
%114 = load i32, i32* %10
%115 = add nsw i32 %114, 1
store i32 %115, i32* %10
br label %92
116: ; preds = %92
ret void
}

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