void xor_32regs_4(unsigned long bytes, unsigned long *p1, unsigned long *p2,
                  unsigned long *p3, unsigned long *p4) {
  long lines = bytes / (sizeof(long)) / 8;
  do {
    register long d0, d1, d2, d3, d4, d5, d6, d7;
    d0 = p1[0];
    d1 = p1[1];
    d2 = p1[2];
    d3 = p1[3];
    d4 = p1[4];
    d5 = p1[5];
    d6 = p1[6];
    d7 = p1[7];
    d0 ^= p2[0];
    d1 ^= p2[1];
    d2 ^= p2[2];
    d3 ^= p2[3];
    d4 ^= p2[4];
    d5 ^= p2[5];
    d6 ^= p2[6];
    d7 ^= p2[7];
    d0 ^= p3[0];
    d1 ^= p3[1];
    d2 ^= p3[2];
    d3 ^= p3[3];
    d4 ^= p3[4];
    d5 ^= p3[5];
    d6 ^= p3[6];
    d7 ^= p3[7];
    d0 ^= p4[0];
    d1 ^= p4[1];
    d2 ^= p4[2];
    d3 ^= p4[3];
    d4 ^= p4[4];
    d5 ^= p4[5];
    d6 ^= p4[6];
    d7 ^= p4[7];
    p1[0] = d0;
    p1[1] = d1;
    p1[2] = d2;
    p1[3] = d3;
    p1[4] = d4;
    p1[5] = d5;
    p1[6] = d6;
    p1[7] = d7;
    p1 += 8;
    p2 += 8;
    p3 += 8;
    p4 += 8;
  } while (--lines > 0);
}


x86 assembly (clang, -O0):
<xor_32regs_4>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x8(%rbp),%rax
shr    $0x3,%rax
shr    $0x3,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
xor    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
xor    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
xor    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
xor    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
xor    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
xor    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
xor    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rax),%rax
xor    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    0x18(%rax),%rax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
mov    0x20(%rax),%rax
xor    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x28(%rax),%rax
xor    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    0x30(%rax),%rax
xor    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
mov    0x38(%rax),%rax
xor    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
xor    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
xor    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    0x18(%rax),%rax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    0x20(%rax),%rax
xor    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    0x28(%rax),%rax
xor    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    0x30(%rax),%rax
xor    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    0x38(%rax),%rax
xor    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x48(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x50(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x58(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x60(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x68(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x70(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x38(%rax)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jg     1128 <xor_32regs_4+0x28>
pop    %rbp
ret

x86 assembly (clang, -O2):
<xor_32regs_4>:
shr    $0x6,%rdi
add    $0x1,%rdi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rax,1),%xmm0
movups 0x10(%rsi,%rax,1),%xmm1
movups 0x20(%rsi,%rax,1),%xmm2
movups 0x30(%rsi,%rax,1),%xmm3
movups (%rdx,%rax,1),%xmm4
xorps  %xmm0,%xmm4
movups 0x10(%rdx,%rax,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%rdx,%rax,1),%xmm1
xorps  %xmm2,%xmm1
movups 0x30(%rdx,%rax,1),%xmm2
xorps  %xmm3,%xmm2
movups (%rcx,%rax,1),%xmm3
movups 0x10(%rcx,%rax,1),%xmm5
movups 0x20(%rcx,%rax,1),%xmm6
movups 0x30(%rcx,%rax,1),%xmm8
movups (%r8,%rax,1),%xmm7
xorps  %xmm3,%xmm7
xorps  %xmm4,%xmm7
movups 0x10(%r8,%rax,1),%xmm3
xorps  %xmm5,%xmm3
xorps  %xmm0,%xmm3
movups 0x20(%r8,%rax,1),%xmm0
xorps  %xmm6,%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%r8,%rax,1),%xmm1
xorps  %xmm8,%xmm1
xorps  %xmm2,%xmm1
movups %xmm7,(%rsi,%rax,1)
movups %xmm3,0x10(%rsi,%rax,1)
movups %xmm0,0x20(%rsi,%rax,1)
movups %xmm1,0x30(%rsi,%rax,1)
add    $0xffffffffffffffff,%rdi
add    $0x40,%rax
cmp    $0x1,%rdi
ja     1110 <xor_32regs_4+0x10>
ret

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

LLVM IR (-O2):
define void @xor_32regs_4(i64 %0, i64* nocapture %1, i64* nocapture %2, i64* nocapture %3, i64* nocapture %4) {
%6 = lshr i64 %0, 6
br label %7
7: ; preds = %7, %5
%8 = phi i64 [ %6, %5 ], [ %77, %7 ]
%9 = phi i64* [ %4, %5 ], [ %76, %7 ]
%10 = phi i64* [ %3, %5 ], [ %75, %7 ]
%11 = phi i64* [ %2, %5 ], [ %74, %7 ]
%12 = phi i64* [ %1, %5 ], [ %73, %7 ]
%13 = bitcast i64* %12 to <2 x i64>*
%14 = load <2 x i64>, <2 x i64>* %13
%15 = getelementptr inbounds i64, i64* %12, i64 2
%16 = bitcast i64* %15 to <2 x i64>*
%17 = load <2 x i64>, <2 x i64>* %16
%18 = getelementptr inbounds i64, i64* %12, i64 4
%19 = bitcast i64* %18 to <2 x i64>*
%20 = load <2 x i64>, <2 x i64>* %19
%21 = getelementptr inbounds i64, i64* %12, i64 6
%22 = bitcast i64* %21 to <2 x i64>*
%23 = load <2 x i64>, <2 x i64>* %22
%24 = bitcast i64* %11 to <2 x i64>*
%25 = load <2 x i64>, <2 x i64>* %24
%26 = xor <2 x i64> %25, %14
%27 = getelementptr inbounds i64, i64* %11, i64 2
%28 = bitcast i64* %27 to <2 x i64>*
%29 = load <2 x i64>, <2 x i64>* %28
%30 = xor <2 x i64> %29, %17
%31 = getelementptr inbounds i64, i64* %11, i64 4
%32 = bitcast i64* %31 to <2 x i64>*
%33 = load <2 x i64>, <2 x i64>* %32
%34 = xor <2 x i64> %33, %20
%35 = getelementptr inbounds i64, i64* %11, i64 6
%36 = bitcast i64* %35 to <2 x i64>*
%37 = load <2 x i64>, <2 x i64>* %36
%38 = xor <2 x i64> %37, %23
%39 = bitcast i64* %10 to <2 x i64>*
%40 = load <2 x i64>, <2 x i64>* %39
%41 = xor <2 x i64> %26, %40
%42 = getelementptr inbounds i64, i64* %10, i64 2
%43 = bitcast i64* %42 to <2 x i64>*
%44 = load <2 x i64>, <2 x i64>* %43
%45 = xor <2 x i64> %30, %44
%46 = getelementptr inbounds i64, i64* %10, i64 4
%47 = bitcast i64* %46 to <2 x i64>*
%48 = load <2 x i64>, <2 x i64>* %47
%49 = xor <2 x i64> %34, %48
%50 = getelementptr inbounds i64, i64* %10, i64 6
%51 = bitcast i64* %50 to <2 x i64>*
%52 = load <2 x i64>, <2 x i64>* %51
%53 = xor <2 x i64> %38, %52
%54 = bitcast i64* %9 to <2 x i64>*
%55 = load <2 x i64>, <2 x i64>* %54
%56 = xor <2 x i64> %41, %55
%57 = getelementptr inbounds i64, i64* %9, i64 2
%58 = bitcast i64* %57 to <2 x i64>*
%59 = load <2 x i64>, <2 x i64>* %58
%60 = xor <2 x i64> %45, %59
%61 = getelementptr inbounds i64, i64* %9, i64 4
%62 = bitcast i64* %61 to <2 x i64>*
%63 = load <2 x i64>, <2 x i64>* %62
%64 = xor <2 x i64> %49, %63
%65 = getelementptr inbounds i64, i64* %9, i64 6
%66 = bitcast i64* %65 to <2 x i64>*
%67 = load <2 x i64>, <2 x i64>* %66
%68 = xor <2 x i64> %53, %67
%69 = bitcast i64* %12 to <2 x i64>*
store <2 x i64> %56, <2 x i64>* %69
%70 = bitcast i64* %15 to <2 x i64>*
store <2 x i64> %60, <2 x i64>* %70
%71 = bitcast i64* %18 to <2 x i64>*
store <2 x i64> %64, <2 x i64>* %71
%72 = bitcast i64* %21 to <2 x i64>*
store <2 x i64> %68, <2 x i64>* %72
%73 = getelementptr inbounds i64, i64* %12, i64 8
%74 = getelementptr inbounds i64, i64* %11, i64 8
%75 = getelementptr inbounds i64, i64* %10, i64 8
%76 = getelementptr inbounds i64, i64* %9, i64 8
%77 = add nsw i64 %8, -1
%78 = icmp ugt i64 %8, 1
br i1 %78, label %7, label %79
79: ; preds = %7
ret void
}