#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 */
void *strlen(char const *);
void strinsert(const char cadena1[], char cadena2[], unsigned int pos) {
  if (cadena1 != NULL && cadena2 != NULL) {
    unsigned int tamHueco = strlen(cadena1);
    int i = strlen(cadena2);
    if (pos < (unsigned int)i) {
      *(cadena2 + i + tamHueco) = 0;
      for (--i; (unsigned int)i >= pos; --i) {
        cadena2[i + tamHueco] = cadena2[i];
      }
      for (i = 0; i < tamHueco; ++i) {
        cadena2[pos + i] = cadena1[i];
      }
    }
  }
}


x86 assembly (clang, -O0):
<strinsert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     11f1 <strinsert+0xe1>
cmpq   $0x0,-0x10(%rbp)
je     11f1 <strinsert+0xe1>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    11ec <strinsert+0xdc>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jb     11ac <strinsert+0x9c>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1178 <strinsert+0x68>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    11e7 <strinsert+0xd7>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b3 <strinsert+0xa3>
jmp    11ec <strinsert+0xdc>
jmp    11f1 <strinsert+0xe1>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strinsert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %rdi,%rdi
je     1258 <strinsert+0x148>
mov    %rsi,%r14
test   %rsi,%rsi
je     1258 <strinsert+0x148>
mov    %edx,%r15d
mov    %rdi,%r13
call   1030 <strlen@plt>
mov    %rax,%r12
mov    %r14,%rdi
call   1030 <strlen@plt>
cmp    %r15d,%eax
jbe    1258 <strinsert+0x148>
movslq %eax,%rcx
add    %r14,%rcx
mov    %r12d,%edx
movb   $0x0,(%rdx,%rcx,1)
lea    -0x1(%rax),%ecx
cmp    %r15d,%ecx
jb     11a6 <strinsert+0x96>
movslq %ecx,%r8
lea    -0x2(%rax),%r9d
lea    -0x1(%r15),%ebx
xor    %esi,%esi
mov    %r9d,%edx
sub    %ebx,%edx
cmovb  %esi,%edx
cmp    $0x3,%edx
jae    12b2 <strinsert+0x1a2>
mov    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r14,%rdx,1),%eax
lea    (%r12,%rdx,1),%ecx
mov    %al,(%r14,%rcx,1)
add    $0xffffffffffffffff,%rdx
cmp    %r15d,%edx
jae    1190 <strinsert+0x80>
test   %r12d,%r12d
je     1258 <strinsert+0x148>
mov    %r12d,%eax
cmp    $0x8,%rax
jae    1267 <strinsert+0x157>
xor    %ecx,%ecx
sub    %ecx,%r12d
mov    %rcx,%rdi
not    %rdi
add    %rax,%rdi
and    $0x3,%r12
je     11f7 <strinsert+0xe7>
mov    %r15d,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x0(%r13,%rcx,1),%edx
lea    (%rsi,%rcx,1),%ebp
mov    %dl,(%r14,%rbp,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%r12
jne    11e0 <strinsert+0xd0>
cmp    $0x3,%rdi
jb     1258 <strinsert+0x148>
mov    %r15d,%edx
add    $0x3,%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x3(%r13,%rcx,1),%ebx
lea    (%rcx,%rdx,1),%rsi
mov    %esi,%edi
mov    %bl,(%r14,%rdi,1)
movzbl -0x2(%r13,%rcx,1),%ebx
lea    0x1(%rsi),%edi
mov    %bl,(%r14,%rdi,1)
movzbl -0x1(%r13,%rcx,1),%ebx
lea    0x2(%rsi),%edi
mov    %bl,(%r14,%rdi,1)
movzbl 0x0(%r13,%rcx,1),%ebx
add    $0x3,%esi
mov    %bl,(%r14,%rsi,1)
add    $0xfffffffffffffffc,%rax
add    $0x4,%rdx
add    $0x4,%r13
cmp    %rax,%rcx
jne    1210 <strinsert+0x100>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rax),%rdx
xor    %ecx,%ecx
mov    %r15d,%esi
add    %edx,%esi
jb     11be <strinsert+0xae>
shr    $0x20,%rdx
jne    11be <strinsert+0xae>
mov    %r15d,%edx
lea    (%rax,%rdx,1),%rcx
add    %r14,%rcx
cmp    %r13,%rcx
jbe    12a2 <strinsert+0x192>
lea    (%rax,%r13,1),%rcx
lea    (%r14,%rdx,1),%rsi
cmp    %rcx,%rsi
jb     11bc <strinsert+0xac>
cmp    $0x20,%eax
jae    134d <strinsert+0x23d>
xor    %ecx,%ecx
jmp    1395 <strinsert+0x285>
mov    %r9d,%ecx
sub    %ebx,%ecx
cmovb  %esi,%ecx
lea    (%rax,%r12,1),%esi
add    $0xffffffff,%esi
cmp    %esi,%ecx
ja     1182 <strinsert+0x72>
add    %r14,%rsi
mov    %rsi,%rdi
sub    %rcx,%rdi
cmp    %rsi,%rdi
ja     1182 <strinsert+0x72>
lea    (%r14,%r8,1),%rsi
mov    %rsi,%rdi
sub    %rcx,%rdi
cmp    %rsi,%rdi
ja     1182 <strinsert+0x72>
add    %r12d,%eax
add    $0xffffffff,%eax
xor    %esi,%esi
mov    %r9d,%ecx
sub    %ebx,%ecx
cmovb  %esi,%ecx
mov    %rax,%rsi
sub    %rcx,%rsi
add    %r14,%rsi
lea    (%r8,%r14,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rsi
jae    132d <strinsert+0x21d>
add    %r14,%rax
add    $0x1,%rax
mov    %r8,%rsi
sub    %rcx,%rsi
add    %r14,%rsi
cmp    %rax,%rsi
jb     1182 <strinsert+0x72>
lea    0x1(%rdx),%r11
movabs $0x1fffffff0,%r10
xor    %eax,%eax
cmp    $0xf,%edx
jae    13d3 <strinsert+0x2c3>
xor    %edi,%edi
jmp    14bf <strinsert+0x3af>
mov    %r12d,%esi
and    $0x1f,%esi
mov    %rax,%rcx
sub    %rsi,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups 0x0(%r13,%rdi,1),%xmm0
movups 0x10(%r13,%rdi,1),%xmm1
lea    (%rdx,%rdi,1),%ebp
movups %xmm0,(%r14,%rbp,1)
movups %xmm1,0x10(%r14,%rbp,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1360 <strinsert+0x250>
test   %rsi,%rsi
je     1258 <strinsert+0x148>
cmp    $0x8,%esi
jb     11be <strinsert+0xae>
mov    %rcx,%rsi
mov    %r12d,%r8d
and    $0x7,%r8d
mov    %rax,%rcx
sub    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rsi,1),%rbp
lea    (%rdx,%rsi,1),%edi
mov    %rbp,(%r14,%rdi,1)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    13b0 <strinsert+0x2a0>
test   %r8,%r8
jne    11be <strinsert+0xae>
jmp    1258 <strinsert+0x148>
mov    %r11,%rdi
and    %r10,%rdi
lea    -0x10(%rdi),%rsi
mov    %rsi,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%r10d
and    $0x3,%r10d
cmp    $0x30,%rsi
jae    13f9 <strinsert+0x2e9>
xor    %esi,%esi
jmp    146d <strinsert+0x35d>
mov    %ebx,0x4(%rsp)
mov    %r9,%rbx
and    $0xfffffffffffffffc,%rdx
lea    (%r12,%r8,1),%rbp
mov    %r8,%rax
lea    (%r8,%r14,1),%r9
add    $0xfffffffffffffff1,%r9
xor    %esi,%esi
movups (%r9,%rsi,1),%xmm0
mov    %ebp,%r8d
movups %xmm0,-0xf(%r14,%r8,1)
movups -0x10(%r9,%rsi,1),%xmm0
lea    -0x10(%rbp),%ecx
movups %xmm0,-0xf(%r14,%rcx,1)
movups -0x20(%r9,%rsi,1),%xmm0
lea    -0x20(%rbp),%ecx
movups %xmm0,-0xf(%r14,%rcx,1)
movups -0x30(%r9,%rsi,1),%xmm0
lea    -0x30(%rbp),%ecx
movups %xmm0,-0xf(%r14,%rcx,1)
add    $0xffffffffffffffc0,%rbp
add    $0xffffffffffffffc0,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1415 <strinsert+0x305>
neg    %rsi
mov    %rax,%r8
mov    %rbx,%r9
mov    0x4(%rsp),%ebx
xor    %eax,%eax
test   %r10,%r10
je     14a6 <strinsert+0x396>
lea    (%r12,%r8,1),%rdx
sub    %rsi,%rdx
mov    %r8,%rcx
sub    %rsi,%rcx
lea    (%rcx,%r14,1),%rsi
add    $0xfffffffffffffff1,%rsi
shl    $0x4,%r10
xor    %ebp,%ebp
movups (%rsi,%rbp,1),%xmm0
lea    (%rdx,%rbp,1),%ecx
movups %xmm0,-0xf(%r14,%rcx,1)
add    $0xfffffffffffffff0,%rbp
mov    %r10,%rcx
add    %rbp,%rcx
jne    148d <strinsert+0x37d>
cmp    %rdi,%r11
je     11a6 <strinsert+0x96>
test   $0xc,%r11b
je     1512 <strinsert+0x402>
movabs $0x1fffffff0,%r10
sub    %ebx,%r9d
cmovb  %eax,%r9d
add    $0x1,%r9
add    $0xc,%r10
and    %r9,%r10
mov    %r8,%rdx
sub    %r10,%rdx
and    $0xfffffffffffffffc,%r11
neg    %r11
neg    %rdi
lea    (%r8,%r14,1),%rcx
add    $0xfffffffffffffffd,%rcx
mov    %r12,%rsi
add    %r8,%rsi
nop
mov    (%rcx,%rdi,1),%ebp
lea    (%rsi,%rdi,1),%eax
mov    %ebp,-0x3(%r14,%rax,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r11
jne    14f0 <strinsert+0x3e0>
cmp    %r10,%r9
jne    1190 <strinsert+0x80>
jmp    11a6 <strinsert+0x96>
sub    %rdi,%r8
jmp    1182 <strinsert+0x72>

LLVM IR (-O0):
define void @strinsert(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%9 = load i8*, i8** %4
%10 = icmp ne i8* %9, null
br i1 %10, label %11, label %75
11: ; preds = %3
%12 = load i8*, i8** %5
%13 = icmp ne i8* %12, null
br i1 %13, label %14, label %75
14: ; preds = %11
%15 = load i8*, i8** %4
%16 = call i8* @strlen(i8* %15)
%17 = ptrtoint i8* %16 to i32
store i32 %17, i32* %7
%18 = load i8*, i8** %5
%19 = call i8* @strlen(i8* %18)
%20 = ptrtoint i8* %19 to i32
store i32 %20, i32* %8
%21 = load i32, i32* %6
%22 = load i32, i32* %8
%23 = icmp ult i32 %21, %22
br i1 %23, label %24, label %74
24: ; preds = %14
%25 = load i8*, i8** %5
%26 = load i32, i32* %8
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %25, i64 %27
%29 = load i32, i32* %7
%30 = zext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
store i8 0, i8* %31
%32 = load i32, i32* %8
%33 = add nsw i32 %32, -1
store i32 %33, i32* %8
br label %34
34: ; preds = %50, %24
%35 = load i32, i32* %8
%36 = load i32, i32* %6
%37 = icmp uge i32 %35, %36
br i1 %37, label %38, label %53
38: ; preds = %34
%39 = load i8*, i8** %5
%40 = load i32, i32* %8
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
%43 = load i8, i8* %42
%44 = load i8*, i8** %5
%45 = load i32, i32* %8
%46 = load i32, i32* %7
%47 = add i32 %45, %46
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %44, i64 %48
store i8 %43, i8* %49
br label %50
50: ; preds = %38
%51 = load i32, i32* %8
%52 = add nsw i32 %51, -1
store i32 %52, i32* %8
br label %34
53: ; preds = %34
store i32 0, i32* %8
br label %54
54: ; preds = %70, %53
%55 = load i32, i32* %8
%56 = load i32, i32* %7
%57 = icmp ult i32 %55, %56
br i1 %57, label %58, label %73
58: ; preds = %54
%59 = load i8*, i8** %4
%60 = load i32, i32* %8
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
%63 = load i8, i8* %62
%64 = load i8*, i8** %5
%65 = load i32, i32* %6
%66 = load i32, i32* %8
%67 = add i32 %65, %66
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %64, i64 %68
store i8 %63, i8* %69
br label %70
70: ; preds = %58
%71 = load i32, i32* %8
%72 = add nsw i32 %71, 1
store i32 %72, i32* %8
br label %54
73: ; preds = %54
br label %74
74: ; preds = %73, %14
br label %75
75: ; preds = %74, %11, %3
ret void
}

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