#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 */
typedef int /*<<< orphan*/ coins;

/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
int main(void) {
  const int coins[] = {1, 2, 5, 10, 20, 50, 100, 200};
  const int clen = sizeof(coins) / sizeof(coins[0]);
  int orderings[200 + 1] = {0};
  orderings[0] = 1;
  int i, j;
  for (i = 0; i < clen; ++i)
    for (j = coins[i]; j <= 200; ++j)
      orderings[j] += orderings[j - coins[i]];
  printf("%d\n", orderings[200]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x370,%rsp
movl   $0x0,-0x4(%rbp)
mov    0xec7(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xec4(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    0xec1(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0xebe(%rip),%rax
mov    %rax,-0x18(%rbp)
movl   $0x8,-0x34(%rbp)
lea    -0x360(%rbp),%rdi
xor    %esi,%esi
mov    $0x324,%edx
call   1040 <memset@plt>
movl   $0x1,-0x360(%rbp)
movl   $0x0,-0x364(%rbp)
cmpl   $0x8,-0x364(%rbp)
jge    1216 <main+0xf6>
movslq -0x364(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,-0x368(%rbp)
cmpl   $0xc8,-0x368(%rbp)
jg     11fd <main+0xdd>
mov    -0x368(%rbp),%eax
movslq -0x364(%rbp),%rcx
sub    -0x30(%rbp,%rcx,4),%eax
cltq
mov    -0x360(%rbp,%rax,4),%ecx
movslq -0x368(%rbp),%rax
add    -0x360(%rbp,%rax,4),%ecx
mov    %ecx,-0x360(%rbp,%rax,4)
mov    -0x368(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x368(%rbp)
jmp    11aa <main+0x8a>
jmp    1202 <main+0xe2>
mov    -0x364(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x364(%rbp)
jmp    118c <main+0x6c>
mov    -0x40(%rbp),%esi
lea    0xe00(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x370,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x328,%rsp
mov    %rsp,%rdi
mov    $0x324,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x1,(%rsp)
mov    $0x1,%eax
mov    $0x5,%ecx
nopw   0x0(%rax,%rax,1)
add    -0x10(%rsp,%rcx,4),%eax
mov    %eax,-0x10(%rsp,%rcx,4)
add    -0xc(%rsp,%rcx,4),%eax
mov    %eax,-0xc(%rsp,%rcx,4)
add    -0x8(%rsp,%rcx,4),%eax
mov    %eax,-0x8(%rsp,%rcx,4)
add    -0x4(%rsp,%rcx,4),%eax
mov    %eax,-0x4(%rsp,%rcx,4)
add    (%rsp,%rcx,4),%eax
mov    %eax,(%rsp,%rcx,4)
add    $0x5,%rcx
cmp    $0xcd,%rcx
jne    1150 <main+0x30>
mov    $0x6,%eax
movq   (%rsp),%xmm0
nopl   (%rax)
movq   -0x10(%rsp,%rax,4),%xmm1
paddd  %xmm0,%xmm1
movq   -0x8(%rsp,%rax,4),%xmm2
paddd  %xmm1,%xmm2
punpcklqdq %xmm2,%xmm1
movdqu %xmm1,-0x10(%rsp,%rax,4)
movq   (%rsp,%rax,4),%xmm0
paddd  %xmm2,%xmm0
movq   %xmm0,(%rsp,%rax,4)
add    $0x6,%rax
cmp    $0xcc,%rax
jne    1190 <main+0x70>
mov    0x318(%rsp),%eax
add    %eax,0x320(%rsp)
mov    $0x6,%eax
nopl   0x0(%rax,%rax,1)
mov    -0x18(%rsp,%rax,4),%ecx
mov    -0x14(%rsp,%rax,4),%edx
add    %ecx,-0x4(%rsp,%rax,4)
add    %edx,(%rsp,%rax,4)
add    $0x2,%rax
cmp    $0xca,%rax
jne    11e0 <main+0xc0>
mov    $0x10,%eax
movq   -0x40(%rsp,%rax,4),%xmm0
movq   -0x18(%rsp,%rax,4),%xmm1
paddd  %xmm0,%xmm1
movq   -0x38(%rsp,%rax,4),%xmm0
movq   -0x10(%rsp,%rax,4),%xmm2
paddd  %xmm0,%xmm2
punpcklqdq %xmm2,%xmm1
movdqu %xmm1,-0x18(%rsp,%rax,4)
movq   -0x30(%rsp,%rax,4),%xmm0
movq   -0x8(%rsp,%rax,4),%xmm1
paddd  %xmm0,%xmm1
movq   %xmm1,-0x8(%rsp,%rax,4)
cmp    $0xc8,%rax
je     1262 <main+0x142>
movq   -0x28(%rsp,%rax,4),%xmm0
movq   (%rsp,%rax,4),%xmm1
paddd  %xmm0,%xmm1
movq   %xmm1,(%rsp,%rax,4)
add    $0x8,%rax
jmp    1200 <main+0xe0>
mov    0x2f8(%rsp),%eax
add    %eax,0x320(%rsp)
mov    $0x1c,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movdqa -0x20(%rsp,%rax,4),%xmm0
movdqa -0x10(%rsp,%rax,4),%xmm1
paddd  -0x70(%rsp,%rax,4),%xmm0
movdqa (%rsp,%rax,4),%xmm2
movdqa %xmm0,-0x20(%rsp,%rax,4)
paddd  -0x60(%rsp,%rax,4),%xmm1
movdqa %xmm1,-0x10(%rsp,%rax,4)
paddd  -0x50(%rsp,%rax,4),%xmm2
movdqa %xmm2,(%rsp,%rax,4)
add    $0xc,%rax
cmp    $0xd0,%rax
jne    1280 <main+0x160>
mov    0x2d0(%rsp),%eax
add    %eax,0x320(%rsp)
mov    $0x36,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   -0xd8(%rsp,%rax,4),%xmm0
ff ff
movq   -0x10(%rsp,%rax,4),%xmm1
paddd  %xmm0,%xmm1
movq   -0xd0(%rsp,%rax,4),%xmm0
ff ff
movq   -0x8(%rsp,%rax,4),%xmm2
paddd  %xmm0,%xmm2
punpcklqdq %xmm2,%xmm1
movdqu %xmm1,-0x10(%rsp,%rax,4)
movq   -0xc8(%rsp,%rax,4),%xmm0
ff ff
movq   (%rsp,%rax,4),%xmm1
paddd  %xmm0,%xmm1
movq   %xmm1,(%rsp,%rax,4)
add    $0x6,%rax
cmp    $0xcc,%rax
jne    12e0 <main+0x1c0>
mov    0x258(%rsp),%eax
add    %eax,0x320(%rsp)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa 0x190(%rsp,%rax,4),%xmm0
paddd  (%rsp,%rax,4),%xmm0
movdqa %xmm0,0x190(%rsp,%rax,4)
cmp    $0x60,%rax
je     13bb <main+0x29b>
movdqa 0x1a0(%rsp,%rax,4),%xmm0
movdqa 0x1b0(%rsp,%rax,4),%xmm1
movdqa 0x1c0(%rsp,%rax,4),%xmm2
paddd  0x10(%rsp,%rax,4),%xmm0
movdqa %xmm0,0x1a0(%rsp,%rax,4)
paddd  0x20(%rsp,%rax,4),%xmm1
movdqa %xmm1,0x1b0(%rsp,%rax,4)
paddd  0x30(%rsp,%rax,4),%xmm2
movdqa %xmm2,0x1c0(%rsp,%rax,4)
add    $0x10,%rax
jmp    1350 <main+0x230>
mov    0x190(%rsp),%eax
mov    0x320(%rsp),%ecx
lea    (%rcx,%rax,1),%edx
mov    %edx,0x320(%rsp)
lea    (%rcx,%rax,1),%esi
add    $0x1,%esi
lea    0xc20(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x328,%rsp
ret

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

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