void concat(char result[], const char str1[], int n1, const char str2[],
            int n2) {
  int i, j;
  for (i = 0; i < n1; ++i) {
    result[i] = str1[i];
  }
  for (j = 0; j < n2; ++j) {
    result[n1 + j] = str2[j];
  }
}


x86 assembly (clang, -O0):
<concat>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    114e <concat+0x4e>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    111e <concat+0x1e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    118a <concat+0x8a>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1155 <concat+0x55>
pop    %rbp
ret

x86 assembly (clang, -O2):
<concat>:
push   %r15
push   %r14
push   %rbx
test   %edx,%edx
jle    11a3 <concat+0xa3>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     112f <concat+0x2f>
lea    (%rsi,%r9,1),%rax
cmp    %rdi,%rax
jbe    1241 <concat+0x141>
lea    (%rdi,%r9,1),%rax
cmp    %rsi,%rax
jbe    1241 <concat+0x141>
xor    %r15d,%r15d
mov    %r15,%r10
not    %r10
add    %r9,%r10
mov    %r9,%rbx
and    $0x3,%rbx
je     1163 <concat+0x63>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rsi,%r15,1),%eax
mov    %al,(%rdi,%r15,1)
add    $0x1,%r15
add    $0xffffffffffffffff,%rbx
jne    1150 <concat+0x50>
cmp    $0x3,%r10
jb     11a3 <concat+0xa3>
nopl   0x0(%rax)
movzbl (%rsi,%r15,1),%eax
mov    %al,(%rdi,%r15,1)
movzbl 0x1(%rsi,%r15,1),%eax
mov    %al,0x1(%rdi,%r15,1)
movzbl 0x2(%rsi,%r15,1),%eax
mov    %al,0x2(%rdi,%r15,1)
movzbl 0x3(%rsi,%r15,1),%eax
mov    %al,0x3(%rdi,%r15,1)
add    $0x4,%r15
cmp    %r15,%r9
jne    1170 <concat+0x70>
test   %r8d,%r8d
jle    123b <concat+0x13b>
movslq %edx,%r9
mov    %r8d,%r11d
cmp    $0x8,%r8d
jb     11d5 <concat+0xd5>
lea    (%rdi,%r9,1),%r10
lea    (%rcx,%r11,1),%rax
cmp    %rax,%r10
jae    124e <concat+0x14e>
lea    (%r9,%r11,1),%rax
add    %rdi,%rax
cmp    %rcx,%rax
jbe    124e <concat+0x14e>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r11,%r8
mov    %r11,%rdx
and    $0x3,%rdx
je     1201 <concat+0x101>
lea    (%rdi,%r9,1),%rbx
nopl   (%rax)
movzbl (%rcx,%rsi,1),%eax
mov    %al,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    11f0 <concat+0xf0>
cmp    $0x3,%r8
jb     123b <concat+0x13b>
lea    (%r9,%rdi,1),%rax
add    $0x3,%rax
nop
movzbl (%rcx,%rsi,1),%edx
mov    %dl,-0x3(%rax,%rsi,1)
movzbl 0x1(%rcx,%rsi,1),%edx
mov    %dl,-0x2(%rax,%rsi,1)
movzbl 0x2(%rcx,%rsi,1),%edx
mov    %dl,-0x1(%rax,%rsi,1)
movzbl 0x3(%rcx,%rsi,1),%edx
mov    %dl,(%rax,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r11
jne    1210 <concat+0x110>
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x20,%edx
jae    125b <concat+0x15b>
xor    %r15d,%r15d
jmp    1372 <concat+0x272>
cmp    $0x20,%r8d
jae    1285 <concat+0x185>
xor    %esi,%esi
jmp    145e <concat+0x35e>
mov    %r9d,%r15d
and    $0xffffffe0,%r15d
lea    -0x20(%r15),%rbx
mov    %rbx,%r11
shr    $0x5,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x60,%rbx
jae    12b2 <concat+0x1b2>
xor    %ebx,%ebx
jmp    1318 <concat+0x218>
mov    %r11d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rax
mov    %rax,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x60,%rax
jae    139f <concat+0x29f>
xor    %eax,%eax
jmp    1408 <concat+0x308>
and    $0xfffffffffffffffc,%r11
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
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,%r11
jne    12c0 <concat+0x1c0>
test   %r10,%r10
je     135f <concat+0x25f>
lea    (%rdi,%rbx,1),%r11
add    $0x10,%r11
lea    (%rsi,%rbx,1),%r14
add    $0x10,%r14
shl    $0x5,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r14,%rbx,1),%xmm0
movups (%r14,%rbx,1),%xmm1
movups %xmm0,-0x10(%r11,%rbx,1)
movups %xmm1,(%r11,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1340 <concat+0x240>
cmp    %r9,%r15
je     11a3 <concat+0xa3>
test   $0x18,%r9b
je     1132 <concat+0x32>
mov    %r15,%r10
mov    %r9d,%r15d
and    $0xfffffff8,%r15d
nopl   0x0(%rax)
mov    (%rsi,%r10,1),%rbx
mov    %rbx,(%rdi,%r10,1)
add    $0x8,%r10
cmp    %r10,%r15
jne    1380 <concat+0x280>
cmp    %r9,%r15
je     11a3 <concat+0xa3>
jmp    1132 <concat+0x32>
and    $0xfffffffffffffffc,%rdx
lea    (%r9,%rdi,1),%rbx
add    $0x70,%rbx
xor    %eax,%eax
nopl   (%rax)
movups (%rcx,%rax,1),%xmm0
movups 0x10(%rcx,%rax,1),%xmm1
movups %xmm0,-0x70(%rbx,%rax,1)
movups %xmm1,-0x60(%rbx,%rax,1)
movups 0x20(%rcx,%rax,1),%xmm0
movups 0x30(%rcx,%rax,1),%xmm1
movups %xmm0,-0x50(%rbx,%rax,1)
movups %xmm1,-0x40(%rbx,%rax,1)
movups 0x40(%rcx,%rax,1),%xmm0
movups 0x50(%rcx,%rax,1),%xmm1
movups %xmm0,-0x30(%rbx,%rax,1)
movups %xmm1,-0x20(%rbx,%rax,1)
movups 0x60(%rcx,%rax,1),%xmm0
movups 0x70(%rcx,%rax,1),%xmm1
movups %xmm0,-0x10(%rbx,%rax,1)
movups %xmm1,(%rbx,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rdx
jne    13b0 <concat+0x2b0>
test   %r8,%r8
je     144b <concat+0x34b>
lea    (%rax,%r9,1),%rdx
add    %rdi,%rdx
add    $0x10,%rdx
add    %rcx,%rax
add    $0x10,%rax
shl    $0x5,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm1,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1430 <concat+0x330>
cmp    %r11,%rsi
je     123b <concat+0x13b>
test   $0x18,%r11b
je     11d7 <concat+0xd7>
mov    %rsi,%rax
mov    %r11d,%esi
and    $0xfffffff8,%esi
nopw   0x0(%rax,%rax,1)
mov    (%rcx,%rax,1),%rdx
mov    %rdx,(%r10,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1470 <concat+0x370>
cmp    %r11,%rsi
je     123b <concat+0x13b>
jmp    11d7 <concat+0xd7>

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

LLVM IR (-O2):
define void @concat(i8* nocapture writeonly %0, i8* nocapture %1, i32 %2, i8* nocapture %3, i32 %4) {
%6 = icmp sgt i32 %2, 0
br i1 %6, label %7, label %132
7: ; preds = %5
%8 = zext i32 %2 to i64
%9 = icmp ult i32 %2, 8
br i1 %9, label %114, label %10
10: ; preds = %7
%11 = getelementptr i8, i8* %0, i64 %8
%12 = getelementptr i8, i8* %1, i64 %8
%13 = icmp ugt i8* %12, %0
%14 = icmp ugt i8* %11, %1
%15 = and i1 %13, %14
br i1 %15, label %114, label %16
16: ; preds = %10
%17 = icmp ult i32 %2, 32
br i1 %17, label %100, label %18
18: ; preds = %16
%19 = and i64 %8, 4294967264
%20 = add nsw i64 %19, -32
%21 = lshr exact i64 %20, 5
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %22, 3
%24 = icmp ult i64 %20, 96
br i1 %24, label %76, label %25
25: ; preds = %18
%26 = and i64 %22, 1152921504606846972
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %73, %27 ]
%29 = phi i64 [ 0, %25 ], [ %74, %27 ]
%30 = getelementptr inbounds i8, i8* %1, i64 %28
%31 = bitcast i8* %30 to <16 x i8>*
%32 = load <16 x i8>, <16 x i8>* %31
%33 = getelementptr inbounds i8, i8* %30, i64 16
%34 = bitcast i8* %33 to <16 x i8>*
%35 = load <16 x i8>, <16 x i8>* %34
%36 = getelementptr inbounds i8, i8* %0, i64 %28
%37 = bitcast i8* %36 to <16 x i8>*
store <16 x i8> %32, <16 x i8>* %37
%38 = getelementptr inbounds i8, i8* %36, i64 16
%39 = bitcast i8* %38 to <16 x i8>*
store <16 x i8> %35, <16 x i8>* %39
%40 = or i64 %28, 32
%41 = getelementptr inbounds i8, i8* %1, i64 %40
%42 = bitcast i8* %41 to <16 x i8>*
%43 = load <16 x i8>, <16 x i8>* %42
%44 = getelementptr inbounds i8, i8* %41, i64 16
%45 = bitcast i8* %44 to <16 x i8>*
%46 = load <16 x i8>, <16 x i8>* %45
%47 = getelementptr inbounds i8, i8* %0, i64 %40
%48 = bitcast i8* %47 to <16 x i8>*
store <16 x i8> %43, <16 x i8>* %48
%49 = getelementptr inbounds i8, i8* %47, i64 16
%50 = bitcast i8* %49 to <16 x i8>*
store <16 x i8> %46, <16 x i8>* %50
%51 = or i64 %28, 64
%52 = getelementptr inbounds i8, i8* %1, i64 %51
%53 = bitcast i8* %52 to <16 x i8>*
%54 = load <16 x i8>, <16 x i8>* %53
%55 = getelementptr inbounds i8, i8* %52, i64 16
%56 = bitcast i8* %55 to <16 x i8>*
%57 = load <16 x i8>, <16 x i8>* %56
%58 = getelementptr inbounds i8, i8* %0, i64 %51
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %54, <16 x i8>* %59
%60 = getelementptr inbounds i8, i8* %58, i64 16
%61 = bitcast i8* %60 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %61
%62 = or i64 %28, 96
%63 = getelementptr inbounds i8, i8* %1, i64 %62
%64 = bitcast i8* %63 to <16 x i8>*
%65 = load <16 x i8>, <16 x i8>* %64
%66 = getelementptr inbounds i8, i8* %63, i64 16
%67 = bitcast i8* %66 to <16 x i8>*
%68 = load <16 x i8>, <16 x i8>* %67
%69 = getelementptr inbounds i8, i8* %0, i64 %62
%70 = bitcast i8* %69 to <16 x i8>*
store <16 x i8> %65, <16 x i8>* %70
%71 = getelementptr inbounds i8, i8* %69, i64 16
%72 = bitcast i8* %71 to <16 x i8>*
store <16 x i8> %68, <16 x i8>* %72
%73 = add nuw i64 %28, 128
%74 = add i64 %29, 4
%75 = icmp eq i64 %74, %26
br i1 %75, label %76, label %27
76: ; preds = %27, %18
%77 = phi i64 [ 0, %18 ], [ %73, %27 ]
%78 = icmp eq i64 %23, 0
br i1 %78, label %95, label %79
79: ; preds = %76, %79
%80 = phi i64 [ %92, %79 ], [ %77, %76 ]
%81 = phi i64 [ %93, %79 ], [ 0, %76 ]
%82 = getelementptr inbounds i8, i8* %1, i64 %80
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = getelementptr inbounds i8, i8* %82, i64 16
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds i8, i8* %0, i64 %80
%89 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %89
%90 = getelementptr inbounds i8, i8* %88, i64 16
%91 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %87, <16 x i8>* %91
%92 = add nuw i64 %80, 32
%93 = add i64 %81, 1
%94 = icmp eq i64 %93, %23
br i1 %94, label %95, label %79
95: ; preds = %79, %76
%96 = icmp eq i64 %19, %8
br i1 %96, label %132, label %97
97: ; preds = %95
%98 = and i64 %8, 24
%99 = icmp eq i64 %98, 0
br i1 %99, label %114, label %100
100: ; preds = %16, %97
%101 = phi i64 [ %19, %97 ], [ 0, %16 ]
%102 = and i64 %8, 4294967288
br label %103
103: ; preds = %103, %100
%104 = phi i64 [ %101, %100 ], [ %110, %103 ]
%105 = getelementptr inbounds i8, i8* %1, i64 %104
%106 = bitcast i8* %105 to <8 x i8>*
%107 = load <8 x i8>, <8 x i8>* %106
%108 = getelementptr inbounds i8, i8* %0, i64 %104
%109 = bitcast i8* %108 to <8 x i8>*
store <8 x i8> %107, <8 x i8>* %109
%110 = add nuw i64 %104, 8
%111 = icmp eq i64 %110, %102
br i1 %111, label %112, label %103
112: ; preds = %103
%113 = icmp eq i64 %102, %8
br i1 %113, label %132, label %114
114: ; preds = %10, %7, %97, %112
%115 = phi i64 [ 0, %7 ], [ 0, %10 ], [ %19, %97 ], [ %102, %112 ]
%116 = xor i64 %115, -1
%117 = add nsw i64 %116, %8
%118 = and i64 %8, 3
%119 = icmp eq i64 %118, 0
br i1 %119, label %129, label %120
120: ; preds = %114, %120
%121 = phi i64 [ %126, %120 ], [ %115, %114 ]
%122 = phi i64 [ %127, %120 ], [ 0, %114 ]
%123 = getelementptr inbounds i8, i8* %1, i64 %121
%124 = load i8, i8* %123
%125 = getelementptr inbounds i8, i8* %0, i64 %121
store i8 %124, i8* %125
%126 = add nuw nsw i64 %121, 1
%127 = add i64 %122, 1
%128 = icmp eq i64 %127, %118
br i1 %128, label %129, label %120
129: ; preds = %120, %114
%130 = phi i64 [ %115, %114 ], [ %126, %120 ]
%131 = icmp ult i64 %117, 3
br i1 %131, label %132, label %269
132: ; preds = %129, %269, %95, %112, %5
%133 = icmp sgt i32 %4, 0
br i1 %133, label %134, label %311
134: ; preds = %132
%135 = sext i32 %2 to i64
%136 = zext i32 %4 to i64
%137 = icmp ult i32 %4, 8
br i1 %137, label %250, label %138
138: ; preds = %134
%139 = getelementptr i8, i8* %0, i64 %135
%140 = add nsw i64 %135, %136
%141 = getelementptr i8, i8* %0, i64 %140
%142 = getelementptr i8, i8* %3, i64 %136
%143 = icmp ult i8* %139, %142
%144 = icmp ugt i8* %141, %3
%145 = and i1 %143, %144
br i1 %145, label %250, label %146
146: ; preds = %138
%147 = icmp ult i32 %4, 32
br i1 %147, label %235, label %148
148: ; preds = %146
%149 = and i64 %136, 4294967264
%150 = add nsw i64 %149, -32
%151 = lshr exact i64 %150, 5
%152 = add nuw nsw i64 %151, 1
%153 = and i64 %152, 3
%154 = icmp ult i64 %150, 96
br i1 %154, label %210, label %155
155: ; preds = %148
%156 = and i64 %152, 1152921504606846972
br label %157
157: ; preds = %157, %155
%158 = phi i64 [ 0, %155 ], [ %207, %157 ]
%159 = phi i64 [ 0, %155 ], [ %208, %157 ]
%160 = getelementptr inbounds i8, i8* %3, i64 %158
%161 = bitcast i8* %160 to <16 x i8>*
%162 = load <16 x i8>, <16 x i8>* %161
%163 = getelementptr inbounds i8, i8* %160, i64 16
%164 = bitcast i8* %163 to <16 x i8>*
%165 = load <16 x i8>, <16 x i8>* %164
%166 = add nsw i64 %158, %135
%167 = getelementptr inbounds i8, i8* %0, i64 %166
%168 = bitcast i8* %167 to <16 x i8>*
store <16 x i8> %162, <16 x i8>* %168
%169 = getelementptr inbounds i8, i8* %167, i64 16
%170 = bitcast i8* %169 to <16 x i8>*
store <16 x i8> %165, <16 x i8>* %170
%171 = or i64 %158, 32
%172 = getelementptr inbounds i8, i8* %3, i64 %171
%173 = bitcast i8* %172 to <16 x i8>*
%174 = load <16 x i8>, <16 x i8>* %173
%175 = getelementptr inbounds i8, i8* %172, i64 16
%176 = bitcast i8* %175 to <16 x i8>*
%177 = load <16 x i8>, <16 x i8>* %176
%178 = add nsw i64 %171, %135
%179 = getelementptr inbounds i8, i8* %0, i64 %178
%180 = bitcast i8* %179 to <16 x i8>*
store <16 x i8> %174, <16 x i8>* %180
%181 = getelementptr inbounds i8, i8* %179, i64 16
%182 = bitcast i8* %181 to <16 x i8>*
store <16 x i8> %177, <16 x i8>* %182
%183 = or i64 %158, 64
%184 = getelementptr inbounds i8, i8* %3, i64 %183
%185 = bitcast i8* %184 to <16 x i8>*
%186 = load <16 x i8>, <16 x i8>* %185
%187 = getelementptr inbounds i8, i8* %184, i64 16
%188 = bitcast i8* %187 to <16 x i8>*
%189 = load <16 x i8>, <16 x i8>* %188
%190 = add nsw i64 %183, %135
%191 = getelementptr inbounds i8, i8* %0, i64 %190
%192 = bitcast i8* %191 to <16 x i8>*
store <16 x i8> %186, <16 x i8>* %192
%193 = getelementptr inbounds i8, i8* %191, i64 16
%194 = bitcast i8* %193 to <16 x i8>*
store <16 x i8> %189, <16 x i8>* %194
%195 = or i64 %158, 96
%196 = getelementptr inbounds i8, i8* %3, i64 %195
%197 = bitcast i8* %196 to <16 x i8>*
%198 = load <16 x i8>, <16 x i8>* %197
%199 = getelementptr inbounds i8, i8* %196, i64 16
%200 = bitcast i8* %199 to <16 x i8>*
%201 = load <16 x i8>, <16 x i8>* %200
%202 = add nsw i64 %195, %135
%203 = getelementptr inbounds i8, i8* %0, i64 %202
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %198, <16 x i8>* %204
%205 = getelementptr inbounds i8, i8* %203, i64 16
%206 = bitcast i8* %205 to <16 x i8>*
store <16 x i8> %201, <16 x i8>* %206
%207 = add nuw i64 %158, 128
%208 = add i64 %159, 4
%209 = icmp eq i64 %208, %156
br i1 %209, label %210, label %157
210: ; preds = %157, %148
%211 = phi i64 [ 0, %148 ], [ %207, %157 ]
%212 = icmp eq i64 %153, 0
br i1 %212, label %230, label %213
213: ; preds = %210, %213
%214 = phi i64 [ %227, %213 ], [ %211, %210 ]
%215 = phi i64 [ %228, %213 ], [ 0, %210 ]
%216 = getelementptr inbounds i8, i8* %3, i64 %214
%217 = bitcast i8* %216 to <16 x i8>*
%218 = load <16 x i8>, <16 x i8>* %217
%219 = getelementptr inbounds i8, i8* %216, i64 16
%220 = bitcast i8* %219 to <16 x i8>*
%221 = load <16 x i8>, <16 x i8>* %220
%222 = add nsw i64 %214, %135
%223 = getelementptr inbounds i8, i8* %0, i64 %222
%224 = bitcast i8* %223 to <16 x i8>*
store <16 x i8> %218, <16 x i8>* %224
%225 = getelementptr inbounds i8, i8* %223, i64 16
%226 = bitcast i8* %225 to <16 x i8>*
store <16 x i8> %221, <16 x i8>* %226
%227 = add nuw i64 %214, 32
%228 = add i64 %215, 1
%229 = icmp eq i64 %228, %153
br i1 %229, label %230, label %213
230: ; preds = %213, %210
%231 = icmp eq i64 %149, %136
br i1 %231, label %311, label %232
232: ; preds = %230
%233 = and i64 %136, 24
%234 = icmp eq i64 %233, 0
br i1 %234, label %250, label %235
235: ; preds = %146, %232
%236 = phi i64 [ %149, %232 ], [ 0, %146 ]
%237 = and i64 %136, 4294967288
br label %238
238: ; preds = %238, %235
%239 = phi i64 [ %236, %235 ], [ %246, %238 ]
%240 = getelementptr inbounds i8, i8* %3, i64 %239
%241 = bitcast i8* %240 to <8 x i8>*
%242 = load <8 x i8>, <8 x i8>* %241
%243 = add nsw i64 %239, %135
%244 = getelementptr inbounds i8, i8* %0, i64 %243
%245 = bitcast i8* %244 to <8 x i8>*
store <8 x i8> %242, <8 x i8>* %245
%246 = add nuw i64 %239, 8
%247 = icmp eq i64 %246, %237
br i1 %247, label %248, label %238
248: ; preds = %238
%249 = icmp eq i64 %237, %136
br i1 %249, label %311, label %250
250: ; preds = %138, %134, %232, %248
%251 = phi i64 [ 0, %134 ], [ 0, %138 ], [ %149, %232 ], [ %237, %248 ]
%252 = xor i64 %251, -1
%253 = add nsw i64 %252, %136
%254 = and i64 %136, 3
%255 = icmp eq i64 %254, 0
br i1 %255, label %266, label %256
256: ; preds = %250, %256
%257 = phi i64 [ %263, %256 ], [ %251, %250 ]
%258 = phi i64 [ %264, %256 ], [ 0, %250 ]
%259 = getelementptr inbounds i8, i8* %3, i64 %257
%260 = load i8, i8* %259
%261 = add nsw i64 %257, %135
%262 = getelementptr inbounds i8, i8* %0, i64 %261
store i8 %260, i8* %262
%263 = add nuw nsw i64 %257, 1
%264 = add i64 %258, 1
%265 = icmp eq i64 %264, %254
br i1 %265, label %266, label %256
266: ; preds = %256, %250
%267 = phi i64 [ %251, %250 ], [ %263, %256 ]
%268 = icmp ult i64 %253, 3
br i1 %268, label %311, label %288
269: ; preds = %129, %269
%270 = phi i64 [ %286, %269 ], [ %130, %129 ]
%271 = getelementptr inbounds i8, i8* %1, i64 %270
%272 = load i8, i8* %271
%273 = getelementptr inbounds i8, i8* %0, i64 %270
store i8 %272, i8* %273
%274 = add nuw nsw i64 %270, 1
%275 = getelementptr inbounds i8, i8* %1, i64 %274
%276 = load i8, i8* %275
%277 = getelementptr inbounds i8, i8* %0, i64 %274
store i8 %276, i8* %277
%278 = add nuw nsw i64 %270, 2
%279 = getelementptr inbounds i8, i8* %1, i64 %278
%280 = load i8, i8* %279
%281 = getelementptr inbounds i8, i8* %0, i64 %278
store i8 %280, i8* %281
%282 = add nuw nsw i64 %270, 3
%283 = getelementptr inbounds i8, i8* %1, i64 %282
%284 = load i8, i8* %283
%285 = getelementptr inbounds i8, i8* %0, i64 %282
store i8 %284, i8* %285
%286 = add nuw nsw i64 %270, 4
%287 = icmp eq i64 %286, %8
br i1 %287, label %132, label %269
288: ; preds = %266, %288
%289 = phi i64 [ %309, %288 ], [ %267, %266 ]
%290 = getelementptr inbounds i8, i8* %3, i64 %289
%291 = load i8, i8* %290
%292 = add nsw i64 %289, %135
%293 = getelementptr inbounds i8, i8* %0, i64 %292
store i8 %291, i8* %293
%294 = add nuw nsw i64 %289, 1
%295 = getelementptr inbounds i8, i8* %3, i64 %294
%296 = load i8, i8* %295
%297 = add nsw i64 %294, %135
%298 = getelementptr inbounds i8, i8* %0, i64 %297
store i8 %296, i8* %298
%299 = add nuw nsw i64 %289, 2
%300 = getelementptr inbounds i8, i8* %3, i64 %299
%301 = load i8, i8* %300
%302 = add nsw i64 %299, %135
%303 = getelementptr inbounds i8, i8* %0, i64 %302
store i8 %301, i8* %303
%304 = add nuw nsw i64 %289, 3
%305 = getelementptr inbounds i8, i8* %3, i64 %304
%306 = load i8, i8* %305
%307 = add nsw i64 %304, %135
%308 = getelementptr inbounds i8, i8* %0, i64 %307
store i8 %306, i8* %308
%309 = add nuw nsw i64 %289, 4
%310 = icmp eq i64 %309, %136
br i1 %310, label %311, label %288
311: ; preds = %266, %288, %230, %248, %132
ret void
}