#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*/ free_lvector(long *, int, long);
long *lvector(int, long);
void lreverse(long ia, long n, long *lvec) {
  long i, *ltmp;
  ltmp = lvector(1, n);
  for (i = 1; i <= n; i++)
    ltmp[i] = lvec[n + ia - i];
  for (i = 1; i <= n; i++)
    lvec[ia + i - 1] = ltmp[i];
  free_lvector(ltmp, 1, n);
}


x86 assembly (clang, -O0):
<lreverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rsi
mov    $0x1,%edi
call   1040 <lvector@plt>
mov    %rax,-0x28(%rbp)
movq   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     118d <lreverse+0x6d>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x8(%rbp),%rcx
sub    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    114e <lreverse+0x2e>
movq   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     11d4 <lreverse+0xb4>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    -0x20(%rbp),%rcx
sub    $0x1,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1195 <lreverse+0x75>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    $0x1,%esi
call   1030 <free_lvector@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lreverse>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%r15
mov    $0x1,%edi
call   1040 <lvector@plt>
test   %r12,%r12
jle    144f <lreverse+0x32f>
lea    (%r12,%r15,1),%r8
mov    $0x1,%r10d
cmp    $0x4,%r12
jb     123f <lreverse+0x11f>
lea    0x8(%rax),%rcx
lea    (%r14,%r8,8),%rdx
cmp    %rdx,%rcx
jae    117a <lreverse+0x5a>
lea    (%rax,%r12,8),%rcx
add    $0x8,%rcx
lea    (%r14,%r15,8),%rdx
cmp    %rcx,%rdx
jb     123f <lreverse+0x11f>
mov    %r12,%r10
and    $0xfffffffffffffffc,%r10
lea    -0x4(%r10),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     146a <lreverse+0x34a>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x38(%rax),%rcx
lea    (%r14,%r8,8),%rbx
add    $0xfffffffffffffff0,%rbx
xor    %esi,%esi
xchg   %ax,%ax
movdqu -0x10(%rbx,%rsi,8),%xmm0
movdqu (%rbx,%rsi,8),%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshufd $0x4e,%xmm0,%xmm0
movdqu %xmm1,-0x30(%rcx)
movdqu %xmm0,-0x20(%rcx)
movdqu -0x30(%rbx,%rsi,8),%xmm0
movdqu -0x20(%rbx,%rsi,8),%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshufd $0x4e,%xmm0,%xmm0
movdqu %xmm1,-0x10(%rcx)
movdqu %xmm0,(%rcx)
add    $0x40,%rcx
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11b0 <lreverse+0x90>
neg    %rsi
test   $0x1,%r9b
je     1232 <lreverse+0x112>
or     $0x1,%rsi
mov    %r8,%rcx
sub    %rsi,%rcx
movdqu -0x18(%r14,%rcx,8),%xmm0
movdqu -0x8(%r14,%rcx,8),%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshufd $0x4e,%xmm0,%xmm0
movdqu %xmm1,(%rax,%rsi,8)
movdqu %xmm0,0x10(%rax,%rsi,8)
cmp    %r12,%r10
je     12df <lreverse+0x1bf>
or     $0x1,%r10
mov    %r12d,%ecx
sub    %r10d,%ecx
add    $0x1,%ecx
mov    %r12,%r9
sub    %r10,%r9
and    $0x3,%rcx
je     1287 <lreverse+0x167>
lea    (%rax,%r10,8),%rdi
mov    %r8,%rdx
sub    %r10,%rdx
lea    (%r14,%rdx,8),%rbx
neg    %rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,8),%rsi
mov    %rsi,(%rdi)
add    $0xffffffffffffffff,%rdx
add    $0x8,%rdi
cmp    %rdx,%rcx
jne    1270 <lreverse+0x150>
sub    %rdx,%r10
cmp    $0x3,%r9
jb     12df <lreverse+0x1bf>
lea    -0x1(%r10),%rcx
lea    (%rax,%r10,8),%rsi
add    $0x18,%rsi
mov    %r15,%rdx
sub    %r10,%rdx
lea    (%r14,%rdx,8),%rdx
mov    %r12,%rdi
cs nopw 0x0(%rax,%rax,1)
mov    (%rdx,%rdi,8),%rbx
mov    %rbx,-0x18(%rsi)
mov    -0x8(%rdx,%rdi,8),%rbx
mov    %rbx,-0x10(%rsi)
mov    -0x10(%rdx,%rdi,8),%rbx
mov    %rbx,-0x8(%rsi)
mov    -0x18(%rdx,%rdi,8),%rbx
mov    %rbx,(%rsi)
add    $0xfffffffffffffffc,%rdi
add    $0x20,%rsi
cmp    %rdi,%rcx
jne    12b0 <lreverse+0x190>
test   %r12,%r12
jle    144f <lreverse+0x32f>
mov    $0x1,%edx
cmp    $0x4,%r12
jb     13ba <lreverse+0x29a>
lea    (%r14,%r15,8),%rsi
lea    (%rax,%r12,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%rsi
jae    1319 <lreverse+0x1f9>
lea    (%r14,%r8,8),%rcx
lea    0x8(%rax),%rdi
cmp    %rcx,%rdi
jb     13ba <lreverse+0x29a>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rcx
mov    %rcx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rcx,%rcx
je     147b <lreverse+0x35b>
mov    %rbx,%rcx
and    $0xfffffffffffffffe,%rcx
mov    $0x6,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x28(%rax,%rdi,8),%xmm0
movups -0x18(%rax,%rdi,8),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,8)
movups %xmm1,-0x20(%rsi,%rdi,8)
movdqu -0x8(%rax,%rdi,8),%xmm0
movdqu 0x8(%rax,%rdi,8),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdi,8)
movdqu %xmm1,(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1350 <lreverse+0x230>
add    $0xfffffffffffffffb,%rdi
test   $0x1,%bl
je     13ad <lreverse+0x28d>
lea    -0x1(%r15),%rcx
movdqu (%rax,%rdi,8),%xmm0
movdqu 0x10(%rax,%rdi,8),%xmm1
add    %rdi,%rcx
movdqu %xmm0,(%r14,%rcx,8)
movdqu %xmm1,0x10(%r14,%rcx,8)
cmp    %r12,%rdx
je     144f <lreverse+0x32f>
or     $0x1,%rdx
mov    %r12d,%esi
sub    %edx,%esi
add    $0x1,%esi
mov    %r12,%rcx
sub    %rdx,%rcx
and    $0x3,%rsi
je     13f2 <lreverse+0x2d2>
lea    (%r14,%r15,8),%rdi
add    $0xfffffffffffffff8,%rdi
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rbx
mov    %rbx,(%rdi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    13e0 <lreverse+0x2c0>
cmp    $0x3,%rcx
jb     144f <lreverse+0x32f>
mov    %r12,%rcx
sub    %rdx,%rcx
add    %rdx,%r15
lea    (%r14,%r15,8),%rsi
add    $0x10,%rsi
lea    (%rax,%rdx,8),%rdx
add    $0x18,%rdx
mov    $0xffffffffffffffff,%rdi
nopl   0x0(%rax,%rax,1)
mov    -0x10(%rdx,%rdi,8),%rbx
mov    %rbx,-0x10(%rsi,%rdi,8)
mov    -0x8(%rdx,%rdi,8),%rbx
mov    %rbx,-0x8(%rsi,%rdi,8)
mov    (%rdx,%rdi,8),%rbx
mov    %rbx,(%rsi,%rdi,8)
mov    0x8(%rdx,%rdi,8),%rbx
mov    %rbx,0x8(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1420 <lreverse+0x300>
mov    %rax,%rdi
mov    $0x1,%esi
mov    %r12,%rdx
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1030 <free_lvector@plt>
xor    %esi,%esi
test   $0x1,%r9b
jne    1205 <lreverse+0xe5>
jmp    1232 <lreverse+0x112>
mov    $0x1,%edi
test   $0x1,%bl
jne    138e <lreverse+0x26e>
jmp    13ad <lreverse+0x28d>

LLVM IR (-O0):
define void @lreverse(i64 %0, i64 %1, i64* %2) {
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64*
%7 = alloca i64
%8 = alloca i64*
store i64 %0, i64* %4
store i64 %1, i64* %5
store i64* %2, i64** %6
%9 = load i64, i64* %5
%10 = call i64* @lvector(i32 1, i64 %9)
store i64* %10, i64** %8
store i64 1, i64* %7
br label %11
11: ; preds = %27, %3
%12 = load i64, i64* %7
%13 = load i64, i64* %5
%14 = icmp sle i64 %12, %13
br i1 %14, label %15, label %30
15: ; preds = %11
%16 = load i64*, i64** %6
%17 = load i64, i64* %5
%18 = load i64, i64* %4
%19 = add nsw i64 %17, %18
%20 = load i64, i64* %7
%21 = sub nsw i64 %19, %20
%22 = getelementptr inbounds i64, i64* %16, i64 %21
%23 = load i64, i64* %22
%24 = load i64*, i64** %8
%25 = load i64, i64* %7
%26 = getelementptr inbounds i64, i64* %24, i64 %25
store i64 %23, i64* %26
br label %27
27: ; preds = %15
%28 = load i64, i64* %7
%29 = add nsw i64 %28, 1
store i64 %29, i64* %7
br label %11
30: ; preds = %11
store i64 1, i64* %7
br label %31
31: ; preds = %46, %30
%32 = load i64, i64* %7
%33 = load i64, i64* %5
%34 = icmp sle i64 %32, %33
br i1 %34, label %35, label %49
35: ; preds = %31
%36 = load i64*, i64** %8
%37 = load i64, i64* %7
%38 = getelementptr inbounds i64, i64* %36, i64 %37
%39 = load i64, i64* %38
%40 = load i64*, i64** %6
%41 = load i64, i64* %4
%42 = load i64, i64* %7
%43 = add nsw i64 %41, %42
%44 = sub nsw i64 %43, 1
%45 = getelementptr inbounds i64, i64* %40, i64 %44
store i64 %39, i64* %45
br label %46
46: ; preds = %35
%47 = load i64, i64* %7
%48 = add nsw i64 %47, 1
store i64 %48, i64* %7
br label %31
49: ; preds = %31
%50 = load i64*, i64** %8
%51 = load i64, i64* %5
%52 = call i32 @free_lvector(i64* %50, i32 1, i64 %51)
ret void
}

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