#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*/ abort();
__attribute__((no)) int main1(int n) {
  int i;
  float a[256] __attribute__((__aligned__(16)));
  float b[256] __attribute__((__aligned__(16))) = {0,  3,  6,  9,  12, 15, 18,
                                                   21, 24, 27, 30, 33, 36, 39,
                                                   42, 45, 48, 51, 54, 57};
  float c[256] __attribute__((__aligned__(16))) = {
      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
  float *pa = a;
  float *pb = b;
  float *pc = c;
  for (i = 0; i < n / 2; i++) {
    pa[i] = pb[i + 1] * pc[i + 1];
  }
  for (i = 0; i < 256 / 2; i++) {
    if (pa[i] != (pb[i + 1] * pc[i + 1]))
      abort();
  }
  return 0;
}


x86 assembly (clang, -O0):
<main1>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc30,%rsp
mov    %edi,-0x4(%rbp)
lea    -0x810(%rbp),%rdi
lea    0xec4(%rip),%rsi
mov    $0x400,%edx
call   1040 <memcpy@plt>
lea    -0xc10(%rbp),%rdi
lea    0x12ac(%rip),%rsi
mov    $0x400,%edx
call   1040 <memcpy@plt>
lea    -0x410(%rbp),%rax
mov    %rax,-0xc18(%rbp)
lea    -0x810(%rbp),%rax
mov    %rax,-0xc20(%rbp)
lea    -0xc10(%rbp),%rax
mov    %rax,-0xc28(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xc2c(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xc2c(%rbp),%eax
cmp    %ecx,%eax
jge    11fb <main1+0xdb>
mov    -0xc20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xc28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0xc18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    118f <main1+0x6f>
movl   $0x0,-0x8(%rbp)
cmpl   $0x80,-0x8(%rbp)
jge    1277 <main1+0x157>
mov    -0xc18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xc20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0xc28(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
jne    125d <main1+0x13d>
jp     125d <main1+0x13d>
jmp    1264 <main1+0x144>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    1269 <main1+0x149>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1202 <main1+0xe2>
xor    %eax,%eax
add    $0xc30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main1>:
sub    $0x408,%rsp
cmp    $0x2,%edi
jl     123d <main1+0x12d>
mov    %edi,%r9d
shr    %r9d
cmp    $0x10,%edi
jae    1132 <main1+0x22>
xor    %ecx,%ecx
jmp    1207 <main1+0xf7>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     129e <main1+0x18e>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
lea    0xea0(%rip),%rsi
lea    0x1299(%rip),%rax
nopw   0x0(%rax,%rax,1)
movups 0x4(%rsi,%rdx,4),%xmm0
movups 0x14(%rsi,%rdx,4),%xmm1
movups 0x24(%rsi,%rdx,4),%xmm2
movups 0x34(%rsi,%rdx,4),%xmm3
movups 0x4(%rax,%rdx,4),%xmm4
mulps  %xmm0,%xmm4
movups 0x14(%rax,%rdx,4),%xmm0
mulps  %xmm1,%xmm0
movups 0x24(%rax,%rdx,4),%xmm1
mulps  %xmm2,%xmm1
movups 0x34(%rax,%rdx,4),%xmm2
mulps  %xmm3,%xmm2
movaps %xmm4,(%rsp,%rdx,4)
movaps %xmm0,0x10(%rsp,%rdx,4)
movaps %xmm1,0x20(%rsp,%rdx,4)
movaps %xmm2,0x30(%rsp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1170 <main1+0x60>
test   $0x1,%r8b
je     1202 <main1+0xf2>
lea    0x0(,%rdx,4),%rax
or     $0x4,%rax
lea    0xe26(%rip),%rsi
movups (%rax,%rsi,1),%xmm0
movups 0x10(%rax,%rsi,1),%xmm1
lea    0x1216(%rip),%rsi
movups (%rax,%rsi,1),%xmm2
mulps  %xmm0,%xmm2
movups 0x10(%rax,%rsi,1),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm2,(%rsp,%rdx,4)
movaps %xmm0,0x10(%rsp,%rdx,4)
cmp    %r9,%rcx
je     123d <main1+0x12d>
lea    0xdf2(%rip),%rax
lea    0x11eb(%rip),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x4(%rax,%rcx,4),%xmm0
mulss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rsp,%rcx,4)
lea    0x1(%rcx),%rsi
mov    %rsi,%rcx
cmp    %rsi,%r9
jne    1220 <main1+0x110>
xor    %eax,%eax
lea    0xdba(%rip),%rcx
lea    0x11b3(%rip),%rdx
nopl   (%rax)
cmp    $0x80,%rax
je     1294 <main1+0x184>
movss  (%rsp,%rax,4),%xmm0
movss  0x4(%rcx,%rax,4),%xmm1
mulss  0x4(%rdx,%rax,4),%xmm1
ucomiss %xmm1,%xmm0
jne    128d <main1+0x17d>
jp     128d <main1+0x17d>
movss  0x8(%rcx,%rax,4),%xmm0
mulss  0x8(%rdx,%rax,4),%xmm0
movss  0x4(%rsp,%rax,4),%xmm1
add    $0x2,%rax
ucomiss %xmm0,%xmm1
jne    128d <main1+0x17d>
jnp    1250 <main1+0x140>
xor    %eax,%eax
call   1030 <abort@plt>
xor    %eax,%eax
add    $0x408,%rsp
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    11c7 <main1+0xb7>
jmp    1202 <main1+0xf2>

LLVM IR (-O0):
@__const.main1.b = <{ [20 x float], [236 x float] }> <{ [20 x float] [float 0.000000e+00, float 3.000000e+00, float 6.000000e+00, float 9.000000e+00, float 1.200000e+01, float 1.500000e+01, float 1.800000e+01, float 2.100000e+01, float 2.400000e+01, float 2.700000e+01, float 3.000000e+01, float 3.300000e+01, float 3.600000e+01, float 3.900000e+01, float 4.200000e+01, float 4.500000e+01, float 4.800000e+01, float 5.100000e+01, float 5.400000e+01, float 5.700000e+01], [236 x float] zeroinitializer }>
@__const.main1.c = <{ [20 x float], [236 x float] }> <{ [20 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00, float 8.000000e+00, float 9.000000e+00, float 1.000000e+01, float 1.100000e+01, float 1.200000e+01, float 1.300000e+01, float 1.400000e+01, float 1.500000e+01, float 1.600000e+01, float 1.700000e+01, float 1.800000e+01, float 1.900000e+01], [236 x float] zeroinitializer }>
define i32 @main1(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca [256 x float]
%5 = alloca [256 x float]
%6 = alloca [256 x float]
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
store i32 %0, i32* %2
%10 = bitcast [256 x float]* %5 to i8*
%11 = bitcast [256 x float]* %6 to i8*
%12 = getelementptr inbounds [256 x float], [256 x float]* %4, i64 0, i64 0
store float* %12, float** %7
%13 = getelementptr inbounds [256 x float], [256 x float]* %5, i64 0, i64 0
store float* %13, float** %8
%14 = getelementptr inbounds [256 x float], [256 x float]* %6, i64 0, i64 0
store float* %14, float** %9
store i32 0, i32* %3
br label %15
15: ; preds = %38, %1
%16 = load i32, i32* %3
%17 = load i32, i32* %2
%18 = sdiv i32 %17, 2
%19 = icmp slt i32 %16, %18
br i1 %19, label %20, label %41
20: ; preds = %15
%21 = load float*, float** %8
%22 = load i32, i32* %3
%23 = add nsw i32 %22, 1
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds float, float* %21, i64 %24
%26 = load float, float* %25
%27 = load float*, float** %9
%28 = load i32, i32* %3
%29 = add nsw i32 %28, 1
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds float, float* %27, i64 %30
%32 = load float, float* %31
%33 = fmul float %26, %32
%34 = load float*, float** %7
%35 = load i32, i32* %3
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float, float* %34, i64 %36
store float %33, float* %37
br label %38
38: ; preds = %20
%39 = load i32, i32* %3
%40 = add nsw i32 %39, 1
store i32 %40, i32* %3
br label %15
41: ; preds = %15
store i32 0, i32* %3
br label %42
42: ; preds = %68, %41
%43 = load i32, i32* %3
%44 = icmp slt i32 %43, 128
br i1 %44, label %45, label %71
45: ; preds = %42
%46 = load float*, float** %7
%47 = load i32, i32* %3
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds float, float* %46, i64 %48
%50 = load float, float* %49
%51 = load float*, float** %8
%52 = load i32, i32* %3
%53 = add nsw i32 %52, 1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %51, i64 %54
%56 = load float, float* %55
%57 = load float*, float** %9
%58 = load i32, i32* %3
%59 = add nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %57, i64 %60
%62 = load float, float* %61
%63 = fmul float %56, %62
%64 = fcmp une float %50, %63
br i1 %64, label %65, label %67
65: ; preds = %45
%66 = call i32 (...) @abort()
unreachable
67: ; preds = %45
br label %68
68: ; preds = %67
%69 = load i32, i32* %3
%70 = add nsw i32 %69, 1
store i32 %70, i32* %3
br label %42
71: ; preds = %42
ret i32 0
}

LLVM IR (-O2):
@__const.main1.b = <{ [20 x float], [236 x float] }> <{ [20 x float] [float 0.000000e+00, float 3.000000e+00, float 6.000000e+00, float 9.000000e+00, float 1.200000e+01, float 1.500000e+01, float 1.800000e+01, float 2.100000e+01, float 2.400000e+01, float 2.700000e+01, float 3.000000e+01, float 3.300000e+01, float 3.600000e+01, float 3.900000e+01, float 4.200000e+01, float 4.500000e+01, float 4.800000e+01, float 5.100000e+01, float 5.400000e+01, float 5.700000e+01], [236 x float] zeroinitializer }>
@__const.main1.c = <{ [20 x float], [236 x float] }> <{ [20 x float] [float 0.000000e+00, float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00, float 8.000000e+00, float 9.000000e+00, float 1.000000e+01, float 1.100000e+01, float 1.200000e+01, float 1.300000e+01, float 1.400000e+01, float 1.500000e+01, float 1.600000e+01, float 1.700000e+01, float 1.800000e+01, float 1.900000e+01], [236 x float] zeroinitializer }>
define i32 @main1(i32 %0) {
%2 = alloca [256 x float]
%3 = bitcast [256 x float]* %2 to i8*
%4 = icmp sgt i32 %0, 1
br i1 %4, label %5, label %100
5: ; preds = %1
%6 = lshr i32 %0, 1
%7 = zext i32 %6 to i64
%8 = icmp ult i32 %0, 16
br i1 %8, label %88, label %9
9: ; preds = %5
%10 = and i64 %7, 2147483640
%11 = add nsw i64 %10, -8
%12 = lshr exact i64 %11, 3
%13 = add nuw nsw i64 %12, 1
%14 = and i64 %13, 1
%15 = icmp eq i64 %11, 0
br i1 %15, label %63, label %16
16: ; preds = %9
%17 = and i64 %13, 4611686018427387902
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %60, %18 ]
%20 = phi i64 [ 0, %16 ], [ %61, %18 ]
%21 = or i64 %19, 1
%22 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.b, i64 0, i32 0, i64 %21
%23 = bitcast float* %22 to <4 x float>*
%24 = load <4 x float>, <4 x float>* %23
%25 = getelementptr inbounds float, float* %22, i64 4
%26 = bitcast float* %25 to <4 x float>*
%27 = load <4 x float>, <4 x float>* %26
%28 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.c, i64 0, i32 0, i64 %21
%29 = bitcast float* %28 to <4 x float>*
%30 = load <4 x float>, <4 x float>* %29
%31 = getelementptr inbounds float, float* %28, i64 4
%32 = bitcast float* %31 to <4 x float>*
%33 = load <4 x float>, <4 x float>* %32
%34 = fmul <4 x float> %24, %30
%35 = fmul <4 x float> %27, %33
%36 = getelementptr inbounds [256 x float], [256 x float]* %2, i64 0, i64 %19
%37 = bitcast float* %36 to <4 x float>*
store <4 x float> %34, <4 x float>* %37
%38 = getelementptr inbounds float, float* %36, i64 4
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %35, <4 x float>* %39
%40 = or i64 %19, 8
%41 = or i64 %19, 9
%42 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.b, i64 0, i32 0, i64 %41
%43 = bitcast float* %42 to <4 x float>*
%44 = load <4 x float>, <4 x float>* %43
%45 = getelementptr inbounds float, float* %42, i64 4
%46 = bitcast float* %45 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.c, i64 0, i32 0, i64 %41
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = getelementptr inbounds float, float* %48, i64 4
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = fmul <4 x float> %44, %50
%55 = fmul <4 x float> %47, %53
%56 = getelementptr inbounds [256 x float], [256 x float]* %2, i64 0, i64 %40
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %54, <4 x float>* %57
%58 = getelementptr inbounds float, float* %56, i64 4
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %55, <4 x float>* %59
%60 = add nuw i64 %19, 16
%61 = add i64 %20, 2
%62 = icmp eq i64 %61, %17
br i1 %62, label %63, label %18
63: ; preds = %18, %9
%64 = phi i64 [ 0, %9 ], [ %60, %18 ]
%65 = icmp eq i64 %14, 0
br i1 %65, label %86, label %66
66: ; preds = %63
%67 = or i64 %64, 1
%68 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.b, i64 0, i32 0, i64 %67
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = getelementptr inbounds float, float* %68, i64 4
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.c, i64 0, i32 0, i64 %67
%75 = bitcast float* %74 to <4 x float>*
%76 = load <4 x float>, <4 x float>* %75
%77 = getelementptr inbounds float, float* %74, i64 4
%78 = bitcast float* %77 to <4 x float>*
%79 = load <4 x float>, <4 x float>* %78
%80 = fmul <4 x float> %70, %76
%81 = fmul <4 x float> %73, %79
%82 = getelementptr inbounds [256 x float], [256 x float]* %2, i64 0, i64 %64
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> %80, <4 x float>* %83
%84 = getelementptr inbounds float, float* %82, i64 4
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> %81, <4 x float>* %85
br label %86
86: ; preds = %63, %66
%87 = icmp eq i64 %10, %7
br i1 %87, label %100, label %88
88: ; preds = %5, %86
%89 = phi i64 [ 0, %5 ], [ %10, %86 ]
br label %90
90: ; preds = %88, %90
%91 = phi i64 [ %92, %90 ], [ %89, %88 ]
%92 = add nuw nsw i64 %91, 1
%93 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.b, i64 0, i32 0, i64 %92
%94 = load float, float* %93
%95 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.c, i64 0, i32 0, i64 %92
%96 = load float, float* %95
%97 = fmul float %94, %96
%98 = getelementptr inbounds [256 x float], [256 x float]* %2, i64 0, i64 %91
store float %97, float* %98
%99 = icmp eq i64 %92, %7
br i1 %99, label %100, label %90
100: ; preds = %90, %86, %1
br label %101
101: ; preds = %114, %100
%102 = phi i64 [ 0, %100 ], [ %117, %114 ]
%103 = icmp eq i64 %102, 128
br i1 %103, label %126, label %104
104: ; preds = %101
%105 = getelementptr inbounds [256 x float], [256 x float]* %2, i64 0, i64 %102
%106 = load float, float* %105
%107 = or i64 %102, 1
%108 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.b, i64 0, i32 0, i64 %107
%109 = load float, float* %108
%110 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.c, i64 0, i32 0, i64 %107
%111 = load float, float* %110
%112 = fmul float %109, %111
%113 = fcmp une float %106, %112
br i1 %113, label %124, label %114
114: ; preds = %104
%115 = getelementptr inbounds [256 x float], [256 x float]* %2, i64 0, i64 %107
%116 = load float, float* %115
%117 = add nuw nsw i64 %102, 2
%118 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.b, i64 0, i32 0, i64 %117
%119 = load float, float* %118
%120 = getelementptr inbounds <{ [20 x float], [236 x float] }>, <{ [20 x float], [236 x float] }>* @__const.main1.c, i64 0, i32 0, i64 %117
%121 = load float, float* %120
%122 = fmul float %119, %121
%123 = fcmp une float %116, %122
br i1 %123, label %124, label %101
124: ; preds = %114, %104
%125 = tail call i32 (...) @abort()
unreachable
126: ; preds = %101
ret i32 0
}