#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*/ printf(char *);
int mymemcpy(unsigned int *wdst, unsigned int *wsrc, int words) {
  int i;
  if ((wsrc + words > wdst) && (wsrc < wdst)) {
    for (i = words - 1; i >= 0; i--) {
      *(wdst + i) = *(wsrc + i);
    }
  } else {
    for (i = 0; i < words; i++) {
      *(wdst + i) = *(wsrc + i);
    }
  }
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<mymemcpy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
cmp    -0x8(%rbp),%rax
jbe    1186 <mymemcpy+0x76>
mov    -0x10(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1186 <mymemcpy+0x76>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     1181 <mymemcpy+0x71>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1153 <mymemcpy+0x43>
jmp    11c2 <mymemcpy+0xb2>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11bd <mymemcpy+0xad>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    118d <mymemcpy+0x7d>
jmp    11c2 <mymemcpy+0xb2>
lea    0xe37(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mymemcpy>:
push   %rbx
cmp    %rdi,%rsi
jae    1158 <mymemcpy+0x48>
movslq %edx,%rax
lea    (%rsi,%rax,4),%rax
cmp    %rdi,%rax
jbe    1158 <mymemcpy+0x48>
test   %edx,%edx
jle    13d4 <mymemcpy+0x2c4>
mov    %edx,%eax
cmp    $0x8,%edx
jae    11ec <mymemcpy+0xdc>
add    $0x1,%rax
nopl   0x0(%rax)
lea    -0x2(%rax),%ecx
mov    (%rsi,%rcx,4),%edx
mov    %edx,(%rdi,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1140 <mymemcpy+0x30>
jmp    13d4 <mymemcpy+0x2c4>
test   %edx,%edx
jle    13d4 <mymemcpy+0x2c4>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     1182 <mymemcpy+0x72>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    12cf <mymemcpy+0x1bf>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    12cf <mymemcpy+0x1bf>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rdx
and    $0x3,%rdx
je     11b0 <mymemcpy+0xa0>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rcx,4),%eax
mov    %eax,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    11a0 <mymemcpy+0x90>
cmp    $0x3,%r8
jb     13d4 <mymemcpy+0x2c4>
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,4),%eax
mov    %eax,(%rdi,%rcx,4)
mov    0x4(%rsi,%rcx,4),%eax
mov    %eax,0x4(%rdi,%rcx,4)
mov    0x8(%rsi,%rcx,4),%eax
mov    %eax,0x8(%rdi,%rcx,4)
mov    0xc(%rsi,%rcx,4),%eax
mov    %eax,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    11c0 <mymemcpy+0xb0>
jmp    13d4 <mymemcpy+0x2c4>
lea    -0x1(%rax),%r10
add    $0xffffffff,%edx
cmp    %r10d,%edx
jb     1135 <mymemcpy+0x25>
mov    %r10,%rcx
shr    $0x20,%rcx
jne    1135 <mymemcpy+0x25>
mov    %rax,%rcx
neg    %rcx
lea    (%rdx,%rcx,1),%r9
add    $0x1,%r9
lea    (%rdi,%r9,4),%r8
lea    (%rsi,%rdx,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%r8
jae    123d <mymemcpy+0x12d>
lea    (%rdi,%rdx,4),%rcx
add    $0x4,%rcx
lea    (%rsi,%r9,4),%rdx
cmp    %rcx,%rdx
jb     1135 <mymemcpy+0x25>
mov    %eax,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     13a7 <mymemcpy+0x297>
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
or     $0x2,%rcx
and    %r9,%rcx
mov    $0xfffffff7,%edx
add    %rax,%rdx
mov    $0x1,%r11d
nopl   0x0(%rax,%rax,1)
mov    %r10d,%ebx
shl    $0x2,%rbx
movups -0x1c(%rsi,%rbx,1),%xmm0
movups -0xc(%rsi,%rbx,1),%xmm1
movups %xmm1,-0xc(%rdi,%rbx,1)
movups %xmm0,-0x1c(%rdi,%rbx,1)
mov    %edx,%ebx
shl    $0x2,%rbx
movups -0x1c(%rsi,%rbx,1),%xmm0
movups -0xc(%rsi,%rbx,1),%xmm1
movups %xmm1,-0xc(%rdi,%rbx,1)
movups %xmm0,-0x1c(%rdi,%rbx,1)
add    $0x10,%r11
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffff0,%r10
add    $0xfffffffffffffffe,%rcx
jne    1280 <mymemcpy+0x170>
neg    %r11
jmp    13ae <mymemcpy+0x29e>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rax
jae    12f5 <mymemcpy+0x1e5>
xor    %eax,%eax
jmp    1358 <mymemcpy+0x248>
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdi,%rax,4)
movups %xmm1,0x10(%rdi,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdi,%rax,4)
movups %xmm1,0x30(%rdi,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdi,%rax,4)
movups %xmm1,0x50(%rdi,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,0x60(%rdi,%rax,4)
movups %xmm1,0x70(%rdi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdx
jne    1300 <mymemcpy+0x1f0>
test   %r8,%r8
je     139d <mymemcpy+0x28d>
lea    (%rdi,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%r10,%rdx,1)
movups %xmm1,(%r10,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1380 <mymemcpy+0x270>
cmp    %r9,%rcx
je     13d4 <mymemcpy+0x2c4>
jmp    1184 <mymemcpy+0x74>
mov    $0xffffffffffffffff,%r11
test   $0x1,%r9b
je     13cf <mymemcpy+0x2bf>
add    %eax,%r11d
movups -0x1c(%rsi,%r11,4),%xmm0
movups -0xc(%rsi,%r11,4),%xmm1
movups %xmm1,-0xc(%rdi,%r11,4)
movups %xmm0,-0x1c(%rdi,%r11,4)
cmp    %rax,%r8
jne    13e2 <mymemcpy+0x2d2>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
pop    %rbx
ret
and    $0x7,%eax
jmp    1135 <mymemcpy+0x25>

LLVM IR (-O0):
@.str = [2 x i8] c"\0A\00"
define i32 @mymemcpy(i32* %0, i32* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
%8 = load i32*, i32** %5
%9 = load i32, i32* %6
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds i32, i32* %8, i64 %10
%12 = load i32*, i32** %4
%13 = icmp ugt i32* %11, %12
br i1 %13, label %14, label %38
14: ; preds = %3
%15 = load i32*, i32** %5
%16 = load i32*, i32** %4
%17 = icmp ult i32* %15, %16
br i1 %17, label %18, label %38
18: ; preds = %14
%19 = load i32, i32* %6
%20 = sub nsw i32 %19, 1
store i32 %20, i32* %7
br label %21
21: ; preds = %34, %18
%22 = load i32, i32* %7
%23 = icmp sge i32 %22, 0
br i1 %23, label %24, label %37
24: ; preds = %21
%25 = load i32*, i32** %5
%26 = load i32, i32* %7
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i32, i32* %25, i64 %27
%29 = load i32, i32* %28
%30 = load i32*, i32** %4
%31 = load i32, i32* %7
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %30, i64 %32
store i32 %29, i32* %33
br label %34
34: ; preds = %24
%35 = load i32, i32* %7
%36 = add nsw i32 %35, -1
store i32 %36, i32* %7
br label %21
37: ; preds = %21
br label %57
38: ; preds = %14, %3
store i32 0, i32* %7
br label %39
39: ; preds = %53, %38
%40 = load i32, i32* %7
%41 = load i32, i32* %6
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %56
43: ; preds = %39
%44 = load i32*, i32** %5
%45 = load i32, i32* %7
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
%48 = load i32, i32* %47
%49 = load i32*, i32** %4
%50 = load i32, i32* %7
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %49, i64 %51
store i32 %48, i32* %52
br label %53
53: ; preds = %43
%54 = load i32, i32* %7
%55 = add nsw i32 %54, 1
store i32 %55, i32* %7
br label %39
56: ; preds = %39
br label %57
57: ; preds = %56, %37
%58 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
ret i32 0
}

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