void duplicate_single_pixel(unsigned char *dst, unsigned char *src, int n,
                            int w, int h) {
  int i;
  for (i = n; i > 0; i--)
    *dst++ = *src++;
  for (i = (w * h - 1) * n; i > 0; i--) {
    *dst = dst[-n];
    dst++;
  }
}


x86 assembly (clang, -O0):
<duplicate_single_pixel>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    1156 <duplicate_single_pixel+0x56>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    111c <duplicate_single_pixel+0x1c>
mov    -0x18(%rbp),%eax
imul   -0x1c(%rbp),%eax
sub    $0x1,%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    11a0 <duplicate_single_pixel+0xa0>
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1167 <duplicate_single_pixel+0x67>
pop    %rbp
ret

x86 assembly (clang, -O2):
<duplicate_single_pixel>:
push   %r15
push   %r14
push   %rbx
test   %edx,%edx
jle    1155 <duplicate_single_pixel+0x55>
lea    -0x1(%rdx),%r10d
cmp    $0x1f,%r10d
jb     1135 <duplicate_single_pixel+0x35>
lea    (%rsi,%r10,1),%rax
add    $0x1,%rax
cmp    %rdi,%rax
jbe    11ba <duplicate_single_pixel+0xba>
lea    (%rdi,%r10,1),%rax
add    $0x1,%rax
cmp    %rsi,%rax
jbe    11ba <duplicate_single_pixel+0xba>
mov    %edx,%eax
add    $0x1,%eax
nopw   0x0(%rax,%rax,1)
movzbl (%rsi),%ebx
add    $0x1,%rsi
mov    %bl,(%rdi)
add    $0x1,%rdi
add    $0xffffffff,%eax
cmp    $0x1,%eax
ja     1140 <duplicate_single_pixel+0x40>
imul   %ecx,%r8d
add    $0xffffffff,%r8d
imul   %edx,%r8d
test   %r8d,%r8d
jle    11b4 <duplicate_single_pixel+0xb4>
movslq %edx,%rax
neg    %rax
lea    -0x1(%r8),%r11d
cmp    $0x7,%r11d
jb     1197 <duplicate_single_pixel+0x97>
lea    (%r11,%rax,1),%rcx
add    $0x1,%rcx
add    %rdi,%rcx
cmp    %rcx,%rdi
jae    11e8 <duplicate_single_pixel+0xe8>
lea    (%rdi,%r11,1),%rcx
add    $0x1,%rcx
lea    (%rdi,%rax,1),%rdx
cmp    %rcx,%rdx
jae    11e8 <duplicate_single_pixel+0xe8>
mov    %rdi,%rdx
add    $0x1,%r8d
xchg   %ax,%ax
movzbl (%rdx,%rax,1),%ecx
mov    %cl,(%rdx)
add    $0x1,%rdx
add    $0xffffffff,%r8d
cmp    $0x1,%r8d
ja     11a0 <duplicate_single_pixel+0xa0>
pop    %rbx
pop    %r14
pop    %r15
ret
add    $0x1,%r10
mov    %r10,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rbx
mov    %rbx,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r11d
and    $0x3,%r11d
cmp    $0x60,%rbx
jae    1203 <duplicate_single_pixel+0x103>
xor    %ebx,%ebx
jmp    1268 <duplicate_single_pixel+0x168>
movabs $0x1ffffffe0,%r10
cmp    $0x1f,%r11d
jae    12c6 <duplicate_single_pixel+0x1c6>
xor    %esi,%esi
jmp    13a9 <duplicate_single_pixel+0x2a9>
and    $0xfffffffffffffffc,%rax
xor    %ebx,%ebx
nopl   0x0(%rax)
movups (%rsi,%rbx,1),%xmm0
movups 0x10(%rsi,%rbx,1),%xmm1
movups %xmm0,(%rdi,%rbx,1)
movups %xmm1,0x10(%rdi,%rbx,1)
movups 0x20(%rsi,%rbx,1),%xmm0
movups 0x30(%rsi,%rbx,1),%xmm1
movups %xmm0,0x20(%rdi,%rbx,1)
movups %xmm1,0x30(%rdi,%rbx,1)
movups 0x40(%rsi,%rbx,1),%xmm0
movups 0x50(%rsi,%rbx,1),%xmm1
movups %xmm0,0x40(%rdi,%rbx,1)
movups %xmm1,0x50(%rdi,%rbx,1)
movups 0x60(%rsi,%rbx,1),%xmm0
movups 0x70(%rsi,%rbx,1),%xmm1
movups %xmm0,0x60(%rdi,%rbx,1)
movups %xmm1,0x70(%rdi,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rax
jne    1210 <duplicate_single_pixel+0x110>
test   %r11,%r11
je     12ad <duplicate_single_pixel+0x1ad>
lea    (%rsi,%rbx,1),%r14
add    $0x10,%r14
add    %rdi,%rbx
add    $0x10,%rbx
shl    $0x5,%r11
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%r14,%rax,1),%xmm0
movups (%r14,%rax,1),%xmm1
movups %xmm0,-0x10(%rbx,%rax,1)
movups %xmm1,(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r11
jne    1290 <duplicate_single_pixel+0x190>
add    %r9,%rdi
cmp    %r9,%r10
je     1155 <duplicate_single_pixel+0x55>
mov    %edx,%eax
sub    %r9d,%eax
add    %r9,%rsi
jmp    1137 <duplicate_single_pixel+0x37>
lea    0x1(%r11),%r9
mov    %r9,%rsi
and    %r10,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,%r15
shr    $0x5,%r15
add    $0x1,%r15
mov    %r15d,%r14d
and    $0x3,%r14d
cmp    $0x60,%rcx
jae    12f0 <duplicate_single_pixel+0x1f0>
xor    %ebx,%ebx
jmp    1368 <duplicate_single_pixel+0x268>
and    $0xfffffffffffffffc,%r15
lea    0x70(%rdi),%rcx
lea    (%rdi,%rax,1),%rdx
add    $0x70,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%rdx,%rbx,1),%xmm0
movups -0x60(%rdx,%rbx,1),%xmm1
movups %xmm0,-0x70(%rcx,%rbx,1)
movups %xmm1,-0x60(%rcx,%rbx,1)
movups -0x50(%rdx,%rbx,1),%xmm0
movups -0x40(%rdx,%rbx,1),%xmm1
movups %xmm0,-0x50(%rcx,%rbx,1)
movups %xmm1,-0x40(%rcx,%rbx,1)
movups -0x30(%rdx,%rbx,1),%xmm0
movups -0x20(%rdx,%rbx,1),%xmm1
movups %xmm0,-0x30(%rcx,%rbx,1)
movups %xmm1,-0x20(%rcx,%rbx,1)
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%r15
jne    1310 <duplicate_single_pixel+0x210>
test   %r14,%r14
je     139a <duplicate_single_pixel+0x29a>
lea    (%rbx,%rdi,1),%rcx
add    $0x10,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rcx,%rax,1),%xmm0
movups (%rcx,%rax,1),%xmm1
movups %xmm0,-0x10(%rcx)
movups %xmm1,(%rcx)
add    $0x20,%rcx
add    $0xffffffffffffffff,%r14
jne    1380 <duplicate_single_pixel+0x280>
cmp    %rsi,%r9
je     11b4 <duplicate_single_pixel+0xb4>
test   $0x18,%r9b
je     13ef <duplicate_single_pixel+0x2ef>
add    $0x1,%r11
add    $0x18,%r10
and    %r11,%r10
sub    %r10d,%r8d
lea    (%rdi,%r10,1),%rdx
add    %rsi,%rdi
sub    %r10,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rax,1),%rcx
mov    %rcx,(%rdi)
add    $0x8,%rdi
add    $0x8,%rsi
jne    13d0 <duplicate_single_pixel+0x2d0>
cmp    %r10,%r11
jne    119a <duplicate_single_pixel+0x9a>
jmp    11b4 <duplicate_single_pixel+0xb4>
add    %rsi,%rdi
sub    %esi,%r8d
jmp    1197 <duplicate_single_pixel+0x97>

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

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