void merge_lists(int *nl, int *l11, int *l12, int *l21, int *l22, long *idx) {
  int i1 = 0, i2 = 0, i = 0, ii;
  const int n1 = nl[0], n2 = nl[1];
  i = 0;
  while (i2 < n2 && i1 < n1) {
    if ((l11[i1] < l21[i2]) || (l11[i1] == l21[i2] && l12[i1] < l22[i2])) {
      idx[i] = i1;
      i1++;
    } else {
      idx[i] = n1 + i2;
      i2++;
    }
    i++;
  }
  for (ii = i1; i1 < n1; ii++) {
    idx[i] = i1;
    i++;
    i1++;
  }
  for (ii = i2; i2 < n2; ii++) {
    idx[i] = n1 + i2;
    i++;
    i2++;
  }
}


x86 assembly (clang, -O0):
<merge_lists>:
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    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x38(%rbp),%ecx
xor    %eax,%eax
cmp    -0x48(%rbp),%ecx
mov    %al,-0x49(%rbp)
jge    1168 <merge_lists+0x68>
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    1178 <merge_lists+0x78>
jmp    1216 <merge_lists+0x116>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     11cc <merge_lists+0xcc>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    11ea <merge_lists+0xea>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11ea <merge_lists+0xea>
movslq -0x34(%rbp),%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1208 <merge_lists+0x108>
mov    -0x44(%rbp),%eax
add    -0x38(%rbp),%eax
movslq %eax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    114b <merge_lists+0x4b>
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1258 <merge_lists+0x158>
movslq -0x34(%rbp),%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    121c <merge_lists+0x11c>
mov    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    129f <merge_lists+0x19f>
mov    -0x44(%rbp),%eax
add    -0x38(%rbp),%eax
movslq %eax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    125e <merge_lists+0x15e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge_lists>:
push   %rbp
push   %r15
push   %r14
push   %rbx
mov    (%rdi),%r11d
movslq 0x4(%rdi),%r10
xor    %edi,%edi
test   %r10,%r10
jle    1179 <merge_lists+0x79>
mov    $0x0,%r14d
mov    $0x0,%r15d
test   %r11d,%r11d
jle    117f <merge_lists+0x7f>
xor    %edi,%edi
xor    %r15d,%r15d
xor    %r14d,%r14d
nopl   (%rax)
movslq %r15d,%rax
movslq %r14d,%rbx
mov    (%rcx,%rbx,4),%ebp
cmp    %ebp,(%rsi,%rax,4)
jge    1150 <merge_lists+0x50>
mov    %rax,(%r9,%rdi,8)
add    $0x1,%eax
mov    %eax,%r15d
jmp    1169 <merge_lists+0x69>
nopw   0x0(%rax,%rax,1)
jne    115b <merge_lists+0x5b>
mov    (%rdx,%rax,4),%ebp
cmp    (%r8,%rbx,4),%ebp
jl     113e <merge_lists+0x3e>
lea    (%r14,%r11,1),%eax
cltq
mov    %rax,(%r9,%rdi,8)
add    $0x1,%r14d
add    $0x1,%rdi
cmp    %r10d,%r14d
jge    117f <merge_lists+0x7f>
cmp    %r11d,%r15d
jl     1130 <merge_lists+0x30>
jmp    117f <merge_lists+0x7f>
xor    %r14d,%r14d
xor    %r15d,%r15d
movslq %r11d,%rcx
cmp    %r11d,%r15d
jge    1311 <merge_lists+0x211>
movslq %r15d,%rdx
mov    %edi,%edi
mov    %rcx,%r11
sub    %rdx,%r11
cmp    $0x4,%r11
jb     1300 <merge_lists+0x200>
mov    %r11,%r8
and    $0xfffffffffffffffc,%r8
movq   %rdx,%xmm0
pshufd $0x44,%xmm0,%xmm0
paddq  0xe47(%rip),%xmm0
lea    -0x4(%r8),%rsi
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r15d
and    $0x3,%r15d
cmp    $0xc,%rsi
jae    11dc <merge_lists+0xdc>
xor    %ebx,%ebx
jmp    12a8 <merge_lists+0x1a8>
and    $0xfffffffffffffffc,%rax
lea    (%r9,%rdi,8),%rsi
add    $0x70,%rsi
xor    %ebx,%ebx
movdqa 0xe1d(%rip),%xmm8
movdqa 0xe24(%rip),%xmm9
movdqa 0xe2b(%rip),%xmm10
movdqa 0xe33(%rip),%xmm4
movdqa 0xe3b(%rip),%xmm5
movdqa 0xe43(%rip),%xmm6
movdqa 0xe4b(%rip),%xmm7
movdqa 0xe53(%rip),%xmm1
nopl   (%rax)
movdqa %xmm0,%xmm2
paddq  %xmm8,%xmm2
movdqu %xmm0,-0x70(%rsi,%rbx,8)
movdqu %xmm2,-0x60(%rsi,%rbx,8)
movdqa %xmm0,%xmm2
paddq  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm10,%xmm3
movdqu %xmm2,-0x50(%rsi,%rbx,8)
movdqu %xmm3,-0x40(%rsi,%rbx,8)
movdqa %xmm0,%xmm2
paddq  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm5,%xmm3
movdqu %xmm2,-0x30(%rsi,%rbx,8)
movdqu %xmm3,-0x20(%rsi,%rbx,8)
movdqa %xmm0,%xmm2
paddq  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm7,%xmm3
movdqu %xmm2,-0x10(%rsi,%rbx,8)
movdqu %xmm3,(%rsi,%rbx,8)
add    $0x10,%rbx
paddq  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rax
jne    1230 <merge_lists+0x130>
test   %r15,%r15
je     12f0 <merge_lists+0x1f0>
add    %rdi,%rbx
lea    (%r9,%rbx,8),%rax
add    $0x10,%rax
shl    $0x5,%r15
xor    %esi,%esi
movdqa 0xd4a(%rip),%xmm1
movdqa 0xd52(%rip),%xmm2
xchg   %ax,%ax
movdqa %xmm0,%xmm3
paddq  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rax,%rsi,1)
movdqu %xmm3,(%rax,%rsi,1)
paddq  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%r15
jne    12d0 <merge_lists+0x1d0>
add    %r8,%rdi
cmp    %r8,%r11
je     1311 <merge_lists+0x211>
add    %r8,%rdx
nopl   0x0(%rax,%rax,1)
mov    %rdx,(%r9,%rdi,8)
add    $0x1,%rdi
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1300 <merge_lists+0x200>
cmp    %r10d,%r14d
jge    1451 <merge_lists+0x351>
movslq %r14d,%r14
mov    %edi,%r8d
mov    %r10,%rdi
sub    %r14,%rdi
cmp    $0x4,%rdi
jb     142f <merge_lists+0x32f>
mov    %rdi,%r11
and    $0xfffffffffffffffc,%r11
movq   %r14,%xmm0
pshufd $0x44,%xmm0,%xmm0
paddq  0xcb7(%rip),%xmm0
movq   %rcx,%xmm1
pshufd $0x44,%xmm1,%xmm1
lea    -0x4(%r11),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     1458 <merge_lists+0x358>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
or     $0x2,%rsi
and    %rbx,%rsi
lea    0x2(%rcx),%rax
movq   %rax,%xmm2
pshufd $0x44,%xmm2,%xmm2
lea    (%r9,%r8,8),%rax
add    $0x30,%rax
xor    %edx,%edx
movdqa 0xc84(%rip),%xmm3
movdqa 0xc9c(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm5
paddq  %xmm1,%xmm5
movdqa %xmm2,%xmm6
paddq  %xmm0,%xmm6
movdqu %xmm5,-0x30(%rax,%rdx,8)
movdqu %xmm6,-0x20(%rax,%rdx,8)
movdqa %xmm0,%xmm5
paddq  %xmm3,%xmm5
movdqa %xmm2,%xmm6
paddq  %xmm5,%xmm6
paddq  %xmm1,%xmm5
movdqu %xmm5,-0x10(%rax,%rdx,8)
movdqu %xmm6,(%rax,%rdx,8)
add    $0x8,%rdx
paddq  %xmm4,%xmm0
add    $0xfffffffffffffffe,%rsi
jne    13b0 <merge_lists+0x2b0>
test   $0x1,%bl
je     1424 <merge_lists+0x324>
add    %r8,%rdx
paddq  %xmm0,%xmm1
lea    0x2(%rcx),%rax
movq   %rax,%xmm2
pshufd $0x44,%xmm2,%xmm2
paddq  %xmm0,%xmm2
movdqu %xmm1,(%r9,%rdx,8)
movdqu %xmm2,0x10(%r9,%rdx,8)
cmp    %r11,%rdi
je     1451 <merge_lists+0x351>
add    %r11,%r8
add    %r11,%r14
lea    (%r9,%r8,8),%rax
add    %r14,%rcx
sub    %r14,%r10
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rdx,1),%rsi
mov    %rsi,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r10
jne    1440 <merge_lists+0x340>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%bl
jne    13fe <merge_lists+0x2fe>
jmp    1424 <merge_lists+0x324>

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

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