void lzah_move(p, q, n) int *p, *q, n;
{
  if (p > q) {
    while (n-- > 0) {
      *q++ = *p++;
    }
  } else {
    p += n;
    q += n;
    while (n-- > 0) {
      *--q = *--p;
    }
  }
}


x86 assembly (clang, -O0):
<lzah_move>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    1162 <lzah_move+0x62>
jmp    1122 <lzah_move+0x22>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    115d <lzah_move+0x5d>
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)
jmp    1122 <lzah_move+0x22>
jmp    11ce <lzah_move+0xce>
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    11c9 <lzah_move+0xc9>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x8(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x4(%rax)
jmp    118c <lzah_move+0x8c>
jmp    11ce <lzah_move+0xce>
pop    %rbp
ret

x86 assembly (clang, -O2):
<lzah_move>:
push   %r14
push   %rbx
cmp    %rsi,%rdi
jbe    116e <lzah_move+0x6e>
test   %edx,%edx
jle    1362 <lzah_move+0x262>
lea    -0x1(%rdx),%r9d
cmp    $0x7,%r9d
jb     134b <lzah_move+0x24b>
lea    (%rdi,%r9,4),%rax
add    $0x4,%rax
cmp    %rsi,%rax
jbe    113c <lzah_move+0x3c>
lea    (%rsi,%r9,4),%rax
add    $0x4,%rax
cmp    %rdi,%rax
ja     134b <lzah_move+0x24b>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0x18,%rax
jae    129a <lzah_move+0x19a>
xor    %eax,%eax
jmp    12f8 <lzah_move+0x1f8>
test   %edx,%edx
jle    1362 <lzah_move+0x262>
movslq %edx,%r11
lea    (%rsi,%r11,4),%r14
lea    (%rdi,%r11,4),%rcx
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     1272 <lzah_move+0x172>
mov    %r8,%rax
not    %rax
add    %r11,%rax
lea    (%rsi,%rax,4),%rbx
cmp    %rcx,%rbx
jae    11ae <lzah_move+0xae>
lea    (%rdi,%rax,4),%rax
cmp    %r14,%rax
jb     1272 <lzah_move+0x172>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1366 <lzah_move+0x266>
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
or     $0x2,%rbx
and    %r10,%rbx
lea    (%rdi,%r11,4),%rdi
add    $0xfffffffffffffff0,%rdi
lea    (%rsi,%r11,4),%rax
add    $0xfffffffffffffff0,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rdi,%rsi,4),%xmm0
movups (%rdi,%rsi,4),%xmm1
movups %xmm1,(%rax,%rsi,4)
movups %xmm0,-0x10(%rax,%rsi,4)
movups -0x30(%rdi,%rsi,4),%xmm0
movups -0x20(%rdi,%rsi,4),%xmm1
movups %xmm1,-0x20(%rax,%rsi,4)
movups %xmm0,-0x30(%rax,%rsi,4)
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1200 <lzah_move+0x100>
neg    %rsi
test   $0x1,%r10b
je     1259 <lzah_move+0x159>
shl    $0x2,%rsi
mov    %r14,%rax
sub    %rsi,%rax
mov    %rcx,%rdi
sub    %rsi,%rdi
movups -0x20(%rdi),%xmm0
movups -0x10(%rdi),%xmm1
movups %xmm1,-0x10(%rax)
movups %xmm0,-0x20(%rax)
cmp    %r9,%r8
je     1362 <lzah_move+0x262>
mov    %r9,%rax
shl    $0x2,%rax
sub    %r9d,%edx
sub    %rax,%r14
sub    %rax,%rcx
add    $0x1,%edx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    -0x4(%rcx,%rax,4),%esi
mov    %esi,-0x4(%r14,%rax,4)
add    $0xffffffffffffffff,%rax
lea    (%rdx,%rax,1),%esi
cmp    $0x1,%esi
ja     1280 <lzah_move+0x180>
jmp    1362 <lzah_move+0x262>
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdi,%rax,4),%xmm0
movups 0x50(%rdi,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdi,%rax,4),%xmm0
movups 0x70(%rdi,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    12a0 <lzah_move+0x1a0>
test   %r10,%r10
je     133b <lzah_move+0x23b>
lea    (%rdi,%rax,4),%rcx
add    $0x10,%rcx
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rax,%rbx,1)
movups %xmm1,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1320 <lzah_move+0x220>
cmp    %r8,%r9
je     1362 <lzah_move+0x262>
sub    %r8d,%edx
lea    (%rsi,%r8,4),%rsi
lea    (%rdi,%r8,4),%rdi
add    $0x1,%edx
xor    %eax,%eax
mov    (%rdi,%rax,1),%ecx
mov    %ecx,(%rsi,%rax,1)
add    $0xffffffff,%edx
add    $0x4,%rax
cmp    $0x1,%edx
ja     1350 <lzah_move+0x250>
pop    %rbx
pop    %r14
ret
xor    %esi,%esi
test   $0x1,%r10b
jne    1239 <lzah_move+0x139>
jmp    1259 <lzah_move+0x159>

LLVM IR (-O0):
define void @lzah_move(i32* %0, i32* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
%7 = load i32*, i32** %4
%8 = load i32*, i32** %5
%9 = icmp ugt i32* %7, %8
br i1 %9, label %10, label %22
10: ; preds = %3
br label %11
11: ; preds = %15, %10
%12 = load i32, i32* %6
%13 = add nsw i32 %12, -1
store i32 %13, i32* %6
%14 = icmp sgt i32 %12, 0
br i1 %14, label %15, label %21
15: ; preds = %11
%16 = load i32*, i32** %4
%17 = getelementptr inbounds i32, i32* %16, i32 1
store i32* %17, i32** %4
%18 = load i32, i32* %16
%19 = load i32*, i32** %5
%20 = getelementptr inbounds i32, i32* %19, i32 1
store i32* %20, i32** %5
store i32 %18, i32* %19
br label %11
21: ; preds = %11
br label %42
22: ; preds = %3
%23 = load i32, i32* %6
%24 = load i32*, i32** %4
%25 = sext i32 %23 to i64
%26 = getelementptr inbounds i32, i32* %24, i64 %25
store i32* %26, i32** %4
%27 = load i32, i32* %6
%28 = load i32*, i32** %5
%29 = sext i32 %27 to i64
%30 = getelementptr inbounds i32, i32* %28, i64 %29
store i32* %30, i32** %5
br label %31
31: ; preds = %35, %22
%32 = load i32, i32* %6
%33 = add nsw i32 %32, -1
store i32 %33, i32* %6
%34 = icmp sgt i32 %32, 0
br i1 %34, label %35, label %41
35: ; preds = %31
%36 = load i32*, i32** %4
%37 = getelementptr inbounds i32, i32* %36, i32 -1
store i32* %37, i32** %4
%38 = load i32, i32* %37
%39 = load i32*, i32** %5
%40 = getelementptr inbounds i32, i32* %39, i32 -1
store i32* %40, i32** %5
store i32 %38, i32* %40
br label %31
41: ; preds = %31
br label %42
42: ; preds = %41, %21
ret void
}

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