void cyclesort(int a[], int n) {
  int write = 0, start, element, pos, temp, i;
  for (start = 0; start <= n - 2; start++) {
    element = a[start];
    pos = start;
    for (i = start + 1; i < n; i++)
      if (a[i] < element)
        pos++;
    if (pos == start)
      continue;
    while (element == a[pos])
      pos += 1;
    if (pos != start) {
      temp = element;
      element = a[pos];
      a[pos] = temp;
      write++;
    }
    while (pos != start) {
      pos = start;
      for (i = start + 1; i < n; i++)
        if (a[i] < element)
          pos += 1;
      while (element == a[pos])
        pos += 1;
      if (element != a[pos]) {
        temp = element;
        element = a[pos];
        a[pos] = temp;
        write++;
      }
    }
  }
}


x86 assembly (clang, -O0):
<cyclesort>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     12cc <cyclesort+0x1cc>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1183 <cyclesort+0x83>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x18(%rbp),%eax
jge    1170 <cyclesort+0x70>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1175 <cyclesort+0x75>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1147 <cyclesort+0x47>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1194 <cyclesort+0x94>
jmp    12be <cyclesort+0x1be>
jmp    1199 <cyclesort+0x99>
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    11bb <cyclesort+0xbb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1199 <cyclesort+0x99>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     11f2 <cyclesort+0xf2>
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11f7 <cyclesort+0xf7>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     12b9 <cyclesort+0x1b9>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124e <cyclesort+0x14e>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x18(%rbp),%eax
jge    123b <cyclesort+0x13b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1240 <cyclesort+0x140>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1212 <cyclesort+0x112>
jmp    1253 <cyclesort+0x153>
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1275 <cyclesort+0x175>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1253 <cyclesort+0x153>
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     12b4 <cyclesort+0x1b4>
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11f7 <cyclesort+0xf7>
jmp    12be <cyclesort+0x1be>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1119 <cyclesort+0x19>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cyclesort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x2,%esi
jge    111a <cyclesort+0x1a>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rsi),%eax
mov    %rax,-0x20(%rsp)
mov    %esi,%r8d
lea    0x34(%rdi),%rdx
lea    -0x9(%r8),%r9
mov    $0x1,%r10d
xor    %r11d,%r11d
jmp    1158 <cyclesort+0x58>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x4,%rdx
mov    -0x18(%rsp),%r9
add    $0xffffffffffffffff,%r9
cmp    -0x20(%rsp),%r11
je     110f <cyclesort+0xf>
mov    %r11,%r13
mov    %r9,-0x18(%rsp)
shr    $0x3,%r9
add    $0x1,%r9
and    $0xfffffffffffffffe,%r9
mov    %r11,%r15
not    %r15
lea    (%r15,%r8,1),%r12
add    $0xfffffffffffffff8,%r12
add    %r8,%r15
mov    %r12,-0x28(%rsp)
shr    $0x3,%r12
add    $0x1,%r12
mov    (%rdi,%r11,4),%r14d
add    $0x1,%r11
mov    %r13d,%eax
cmp    %esi,%r11d
jge    12a4 <cyclesort+0x1a4>
mov    %r10,%rbp
mov    %r13d,%eax
cmp    $0x8,%r15
jb     1290 <cyclesort+0x190>
movd   %r13d,%xmm0
movd   %r14d,%xmm1
pshufd $0x0,%xmm1,%xmm2
cmpq   $0x8,-0x28(%rsp)
jae    11cd <cyclesort+0xcd>
pxor   %xmm1,%xmm1
xor    %eax,%eax
jmp    1231 <cyclesort+0x131>
pxor   %xmm1,%xmm1
mov    %r9,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movdqu -0x30(%rdx,%rax,4),%xmm3
movdqu -0x20(%rdx,%rax,4),%xmm4
movdqu -0x10(%rdx,%rax,4),%xmm5
movdqu (%rdx,%rax,4),%xmm6
movdqa %xmm2,%xmm7
pcmpgtd %xmm3,%xmm7
psubd  %xmm7,%xmm0
movdqa %xmm2,%xmm3
pcmpgtd %xmm4,%xmm3
psubd  %xmm3,%xmm1
movdqa %xmm2,%xmm3
pcmpgtd %xmm5,%xmm3
psubd  %xmm3,%xmm0
movdqa %xmm2,%xmm3
pcmpgtd %xmm6,%xmm3
psubd  %xmm3,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbp
jne    11e0 <cyclesort+0xe0>
mov    %r15,%rbp
and    $0xfffffffffffffff8,%rbp
test   $0x1,%r12b
je     1260 <cyclesort+0x160>
add    %r10,%rax
movdqu (%rdi,%rax,4),%xmm3
movdqu 0x10(%rdi,%rax,4),%xmm4
movdqa %xmm2,%xmm5
pcmpgtd %xmm3,%xmm5
psubd  %xmm5,%xmm0
pcmpgtd %xmm4,%xmm2
psubd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rbp,%r15
je     12a4 <cyclesort+0x1a4>
add    %r10,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
cmp    %r14d,(%rdi,%rbp,4)
setl   %bl
add    %ebx,%eax
add    $0x1,%rbp
cmp    %rbp,%r8
jne    1290 <cyclesort+0x190>
mov    %eax,%eax
cmp    %rax,%r13
je     1140 <cyclesort+0x40>
add    $0xffffffffffffffff,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x4(%rdi,%rax,4),%ebp
add    $0x1,%rax
cmp    %ebp,%r14d
je     12c0 <cyclesort+0x1c0>
mov    %eax,%eax
cmp    %r13,%rax
je     1140 <cyclesort+0x40>
mov    %r14d,(%rdi,%rax,4)
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,-0x8(%rsp)
add    %r10,%rax
mov    %rax,-0x10(%rsp)
movd   %r13d,%xmm8
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13d,%eax
cmp    %esi,%r11d
jge    1403 <cyclesort+0x303>
mov    %r10,%rbx
mov    %r13d,%eax
cmp    $0x8,%r15
jb     13f0 <cyclesort+0x2f0>
movd   %ebp,%xmm1
pshufd $0x0,%xmm1,%xmm0
cmpq   $0x8,-0x28(%rsp)
jae    133a <cyclesort+0x23a>
pxor   %xmm1,%xmm1
xor    %eax,%eax
movdqa %xmm8,%xmm3
jmp    13a1 <cyclesort+0x2a1>
pxor   %xmm1,%xmm1
mov    %r9,%r14
xor    %eax,%eax
movdqa %xmm8,%xmm3
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rdx,%rax,4),%xmm4
movdqu -0x20(%rdx,%rax,4),%xmm5
movdqu -0x10(%rdx,%rax,4),%xmm6
movdqu (%rdx,%rax,4),%xmm7
movdqa %xmm0,%xmm2
pcmpgtd %xmm4,%xmm2
psubd  %xmm2,%xmm3
movdqa %xmm0,%xmm2
pcmpgtd %xmm5,%xmm2
psubd  %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm6,%xmm2
psubd  %xmm2,%xmm3
movdqa %xmm0,%xmm2
pcmpgtd %xmm7,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%r14
jne    1350 <cyclesort+0x250>
test   $0x1,%r12b
je     13c9 <cyclesort+0x2c9>
add    %r10,%rax
movdqu (%rdi,%rax,4),%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm4
movdqa %xmm0,%xmm5
pcmpgtd %xmm2,%xmm5
psubd  %xmm5,%xmm3
pcmpgtd %xmm4,%xmm0
psubd  %xmm0,%xmm1
paddd  %xmm1,%xmm3
pshufd $0xee,%xmm3,%xmm0
paddd  %xmm3,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
mov    -0x10(%rsp),%rbx
cmp    -0x8(%rsp),%r15
je     1403 <cyclesort+0x303>
nop
xor    %ecx,%ecx
cmp    %ebp,(%rdi,%rbx,4)
setl   %cl
add    %ecx,%eax
add    $0x1,%rbx
cmp    %rbx,%r8
jne    13f0 <cyclesort+0x2f0>
mov    %eax,%eax
add    $0xffffffffffffffff,%rax
nopl   0x0(%rax)
mov    0x4(%rdi,%rax,4),%ebx
add    $0x1,%rax
cmp    %ebx,%ebp
je     1410 <cyclesort+0x310>
mov    %eax,%eax
mov    %ebp,(%rdi,%rax,4)
mov    %ebx,%ebp
cmp    %r13,%rax
jne    1300 <cyclesort+0x200>
jmp    1140 <cyclesort+0x40>

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

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