void deinterleave(int inptr[], int outptr[], int ngroups, int nsubgroups[],
                  int ncells[], int cellsize[]) {
  int i, j, k, l;
  int *start_inptr, *start_subgroup_ptr, *subgroup_ptr;
  int cell_inc, subgroup_inc;
  start_subgroup_ptr = outptr;
  for (i = 0; i < ngroups; i++) {
    cell_inc = 0;
    start_inptr = inptr;
    subgroup_inc = 0;
    for (j = 0; j < ncells[i]; j++) {
      subgroup_inc += cellsize[j];
    }
    for (j = 0; j < ncells[i]; j++) {
      subgroup_ptr = start_subgroup_ptr;
      for (k = 0; k < nsubgroups[i]; k++) {
        outptr = subgroup_ptr + cell_inc;
        for (l = 0; l < cellsize[j]; l++) {
          *outptr++ = *inptr++;
        }
        subgroup_ptr += subgroup_inc;
      }
      cell_inc += cellsize[j];
    }
    start_subgroup_ptr += (inptr - start_inptr);
  }
}


x86 assembly (clang, -O0):
<deinterleave>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    128d <deinterleave+0x18d>
movl   $0x0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1186 <deinterleave+0x86>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1153 <deinterleave+0x53>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1264 <deinterleave+0x164>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1245 <deinterleave+0x145>
mov    -0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x30(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1222 <deinterleave+0x122>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x10(%rbp)
mov    %ecx,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11de <deinterleave+0xde>
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11b0 <deinterleave+0xb0>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    118d <deinterleave+0x8d>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
shl    $0x2,%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    112a <deinterleave+0x2a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<deinterleave>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edx,%edx
jle    1316 <deinterleave+0x216>
mov    %edx,%eax
mov    %rax,-0x8(%rsp)
lea    0x10(%r9),%rax
mov    %rax,-0x10(%rsp)
xor    %r15d,%r15d
mov    %rdi,%rbx
jmp    114b <deinterleave+0x4b>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rax
sub    %rdi,%rax
add    %rax,%rsi
add    $0x1,%r15
mov    %rbx,%rdi
cmp    -0x8(%rsp),%r15
je     1316 <deinterleave+0x216>
mov    (%r8,%r15,4),%r14d
test   %r14d,%r14d
jle    1130 <deinterleave+0x30>
cmp    $0x8,%r14d
jae    1170 <deinterleave+0x70>
xor    %ebx,%ebx
xor    %eax,%eax
jmp    1270 <deinterleave+0x170>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rdx
mov    %rdx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdx
jae    119c <deinterleave+0x9c>
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
jmp    1211 <deinterleave+0x111>
and    $0xfffffffffffffffc,%rax
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu (%r9,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r9,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%r9,%rdx,4),%xmm1
movdqu 0x30(%r9,%rdx,4),%xmm3
movdqu 0x40(%r9,%rdx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%r9,%rdx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%r9,%rdx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%r9,%rdx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rax
jne    11b0 <deinterleave+0xb0>
test   %rbp,%rbp
je     124c <deinterleave+0x14c>
mov    -0x10(%rsp),%rax
lea    (%rax,%rdx,4),%rax
shl    $0x5,%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rax,%rdx,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rax,%rdx,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    1230 <deinterleave+0x130>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r14,%rbx
je     127d <deinterleave+0x17d>
nopl   0x0(%rax,%rax,1)
add    (%r9,%rbx,4),%eax
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1270 <deinterleave+0x170>
mov    %rdi,%rbx
test   %r14d,%r14d
jle    1130 <deinterleave+0x30>
movslq %eax,%r13
mov    (%rcx,%r15,4),%r10d
shl    $0x2,%r13
xor    %r11d,%r11d
xor    %r12d,%r12d
mov    %rdi,%rbx
jmp    12b7 <deinterleave+0x1b7>
nop
mov    (%r8,%r15,4),%r14d
add    %eax,%r12d
add    $0x1,%r11
movslq %r14d,%rax
cmp    %rax,%r11
jge    1130 <deinterleave+0x30>
test   %r10d,%r10d
jle    1310 <deinterleave+0x210>
movslq %r12d,%rdx
mov    (%r9,%r11,4),%eax
lea    (%rsi,%rdx,4),%rbp
xor    %r14d,%r14d
jmp    12dc <deinterleave+0x1dc>
nopl   0x0(%rax)
add    $0x1,%r14d
add    %r13,%rbp
cmp    %r10d,%r14d
jge    12a0 <deinterleave+0x1a0>
test   %eax,%eax
jle    12d0 <deinterleave+0x1d0>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx),%eax
add    $0x4,%rbx
mov    %eax,0x0(%rbp,%rdx,4)
mov    (%r9,%r11,4),%eax
add    $0x1,%rdx
cmp    %eax,%edx
jl     12f0 <deinterleave+0x1f0>
mov    (%rcx,%r15,4),%r10d
jmp    12d0 <deinterleave+0x1d0>
nopl   0x0(%rax)
mov    (%r9,%r11,4),%eax
jmp    12a4 <deinterleave+0x1a4>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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