#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*/ exit(int /*<<< orphan*/);
int omp_get_num_threads();
int omp_get_thread_num();
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char *argv[]) {
  int i, nthreads, tid;
  float a[50], b[50], c[50], d[50];
  for (i = 0; i < 50; i++) {
    a[i] = i * 1.5;
    b[i] = i + 42.0;
    c[i] = d[i] = 0.0;
  }
#pragma omp parallel shared(a, b, c, d, nthreads) private(i, tid) num_threads(2)
  {
    tid = omp_get_thread_num();
    if (tid == 0) {
      nthreads = omp_get_num_threads();
      printf("Number of threads = %d\n", nthreads);
    }
    printf("Thread %d starting...\n", tid);
#pragma omp sections
    {
#pragma omp section
      {
        printf("Thread %d doing section 1\n", tid);
        for (i = 0; i < 50; i++) {
          c[i] = a[i] + b[i];
        }
      }
#pragma omp section
      {
        printf("Thread %d doing section 2\n", tid);
        for (i = 0; i < 50; i++) {
          d[i] = a[i] * b[i];
        }
      }
    }
    printf("Thread %d done.\n", tid);
  }
  printf("c:  ");
  for (i = 0; i < 50; i++) {
    printf("%.2f ", c[i]);
  }
  printf("\n\nd:  ");
  for (i = 0; i < 50; i++) {
    printf("%.2f ", d[i]);
  }
  printf("\n");
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x360,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x32,-0x14(%rbp)
jge    11dc <main+0x9c>
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  0xe91(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0xf0(%rbp,%rax,4)
ff ff
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  0xe67(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x1c0(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x360(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x290(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1160 <main+0x20>
mov    $0x0,%al
call   1030 <omp_get_thread_num@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    120b <main+0xcb>
mov    $0x0,%al
call   1050 <omp_get_num_threads@plt>
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%esi
lea    0xe0c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%esi
lea    0xe13(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%esi
lea    0xe19(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x32,-0x14(%rbp)
jge    1273 <main+0x133>
movslq -0x14(%rbp),%rax
movss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
addss  -0x1c0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x290(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1234 <main+0xf4>
mov    -0x1c(%rbp),%esi
lea    0xddd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x32,-0x14(%rbp)
jge    12ca <main+0x18a>
movslq -0x14(%rbp),%rax
movss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
mulss  -0x1c0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x360(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    128b <main+0x14b>
mov    -0x1c(%rbp),%esi
lea    0xda1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xda4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x32,-0x14(%rbp)
jge    1327 <main+0x1e7>
movslq -0x14(%rbp),%rax
movss  -0x290(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xd79(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12f0 <main+0x1b0>
lea    0xd63(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x32,-0x14(%rbp)
jge    1373 <main+0x233>
movslq -0x14(%rbp),%rax
movss  -0x360(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
lea    0xd2d(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    133c <main+0x1fc>
lea    0xcc3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %edi,%edi
call   1060 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
sub    $0x338,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0x250(%rsp)
movaps %xmm0,0x240(%rsp)
movaps %xmm0,0x230(%rsp)
movaps %xmm0,0x220(%rsp)
movaps %xmm0,0x210(%rsp)
movaps %xmm0,0x200(%rsp)
movaps %xmm0,0x1f0(%rsp)
movaps %xmm0,0x1e0(%rsp)
movaps %xmm0,0x1d0(%rsp)
movaps %xmm0,0x1c0(%rsp)
movaps %xmm0,0x1b0(%rsp)
movaps %xmm0,0x1a0(%rsp)
movq   $0x0,0x260(%rsp)
movaps %xmm0,0x270(%rsp)
movaps %xmm0,0x280(%rsp)
movaps %xmm0,0x290(%rsp)
movaps %xmm0,0x2a0(%rsp)
movaps %xmm0,0x2b0(%rsp)
movaps %xmm0,0x2c0(%rsp)
movaps %xmm0,0x2d0(%rsp)
movaps %xmm0,0x2e0(%rsp)
movaps %xmm0,0x2f0(%rsp)
movaps %xmm0,0x300(%rsp)
movaps %xmm0,0x310(%rsp)
movaps %xmm0,0x320(%rsp)
movq   $0x0,0x330(%rsp)
movaps 0xdc5(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movaps 0xdc6(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps 0xdcb(%rip),%xmm0
movaps %xmm0,0xe0(%rsp)
movaps 0xdcc(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xdd0(%rip),%xmm0
movaps %xmm0,0xf0(%rsp)
movaps 0xdd1(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xdd5(%rip),%xmm0
movaps %xmm0,0x100(%rsp)
movaps 0xdd6(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xdda(%rip),%xmm0
movaps %xmm0,0x110(%rsp)
movaps 0xddb(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xddf(%rip),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0xde0(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xde4(%rip),%xmm0
movaps %xmm0,0x130(%rsp)
movaps 0xde5(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xde9(%rip),%xmm0
movaps %xmm0,0x140(%rsp)
movaps 0xdea(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xdee(%rip),%xmm0
movaps %xmm0,0x150(%rsp)
movaps 0xdef(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0xdf0(%rip),%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0xdf1(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xdf2(%rip),%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0xdf3(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xdf4(%rip),%xmm0
movaps %xmm0,0x180(%rsp)
movaps 0xdf5(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movabs $0x4293000042900000,%rax
mov    %rax,0x190(%rsp)
movabs $0x42b6000042b40000,%rax
mov    %rax,0xc0(%rsp)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%ebp
test   %eax,%eax
jne    13cb <main+0x27b>
xor    %eax,%eax
call   1060 <omp_get_num_threads@plt>
lea    0xdbe(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdc6(%rip),%rdi
xor    %ebx,%ebx
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdcb(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
movaps 0xd0(%rsp),%xmm0
movaps 0xe0(%rsp),%xmm1
movaps 0xf0(%rsp),%xmm2
movaps 0x100(%rsp),%xmm3
addps  (%rsp),%xmm0
addps  0x10(%rsp),%xmm1
movaps %xmm0,0x270(%rsp)
movaps %xmm1,0x280(%rsp)
addps  0x20(%rsp),%xmm2
movaps %xmm2,0x290(%rsp)
addps  0x30(%rsp),%xmm3
movaps %xmm3,0x2a0(%rsp)
movaps 0x110(%rsp),%xmm0
addps  0x40(%rsp),%xmm0
movaps %xmm0,0x2b0(%rsp)
movaps 0x120(%rsp),%xmm0
addps  0x50(%rsp),%xmm0
movaps %xmm0,0x2c0(%rsp)
movaps 0x130(%rsp),%xmm0
movaps 0x140(%rsp),%xmm1
movaps 0x150(%rsp),%xmm2
movaps 0x160(%rsp),%xmm3
addps  0x60(%rsp),%xmm0
addps  0x70(%rsp),%xmm1
movaps %xmm0,0x2d0(%rsp)
movaps %xmm1,0x2e0(%rsp)
addps  0x80(%rsp),%xmm2
movaps %xmm2,0x2f0(%rsp)
addps  0x90(%rsp),%xmm3
movaps %xmm3,0x300(%rsp)
movaps 0x170(%rsp),%xmm0
addps  0xa0(%rsp),%xmm0
movaps %xmm0,0x310(%rsp)
movaps 0x180(%rsp),%xmm0
addps  0xb0(%rsp),%xmm0
movaps %xmm0,0x320(%rsp)
movss  0x190(%rsp),%xmm0
addss  0xc0(%rsp),%xmm0
movss  %xmm0,0x330(%rsp)
movss  0x194(%rsp),%xmm0
addss  0xc4(%rsp),%xmm0
movss  %xmm0,0x334(%rsp)
lea    0xc99(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
movaps 0xd0(%rsp),%xmm0
movaps 0xe0(%rsp),%xmm1
movaps 0xf0(%rsp),%xmm2
movaps 0x100(%rsp),%xmm3
mulps  (%rsp),%xmm0
mulps  0x10(%rsp),%xmm1
movaps %xmm0,0x1a0(%rsp)
movaps %xmm1,0x1b0(%rsp)
mulps  0x20(%rsp),%xmm2
movaps %xmm2,0x1c0(%rsp)
mulps  0x30(%rsp),%xmm3
movaps %xmm3,0x1d0(%rsp)
movaps 0x110(%rsp),%xmm0
mulps  0x40(%rsp),%xmm0
movaps %xmm0,0x1e0(%rsp)
movaps 0x120(%rsp),%xmm0
mulps  0x50(%rsp),%xmm0
movaps %xmm0,0x1f0(%rsp)
movaps 0x130(%rsp),%xmm0
movaps 0x140(%rsp),%xmm1
movaps 0x150(%rsp),%xmm2
movaps 0x160(%rsp),%xmm3
mulps  0x60(%rsp),%xmm0
mulps  0x70(%rsp),%xmm1
movaps %xmm0,0x200(%rsp)
movaps %xmm1,0x210(%rsp)
mulps  0x80(%rsp),%xmm2
movaps %xmm2,0x220(%rsp)
mulps  0x90(%rsp),%xmm3
movaps %xmm3,0x230(%rsp)
movaps 0x170(%rsp),%xmm0
mulps  0xa0(%rsp),%xmm0
movaps %xmm0,0x240(%rsp)
movaps 0x180(%rsp),%xmm0
mulps  0xb0(%rsp),%xmm0
movaps %xmm0,0x250(%rsp)
movss  0x190(%rsp),%xmm0
mulss  0xc0(%rsp),%xmm0
movss  %xmm0,0x260(%rsp)
movss  0x194(%rsp),%xmm0
mulss  0xc4(%rsp),%xmm0
movss  %xmm0,0x264(%rsp)
lea    0xb67(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xb68(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xb5f(%rip),%rbp
nopl   0x0(%rax)
movss  0x270(%rsp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    $0x32,%rbx
jne    16a0 <main+0x550>
lea    0xb39(%rip),%rdi
xor    %ebp,%ebp
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xb23(%rip),%rbx
nopl   0x0(%rax,%rax,1)
movss  0x1a0(%rsp,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbp
cmp    $0x32,%rbp
jne    16e0 <main+0x590>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %edi,%edi
call   1070 <exit@plt>

LLVM IR (-O0):
@.str = [24 x i8] c"Number of threads = %d\0A\00"
@.str.1 = [23 x i8] c"Thread %d starting...\0A\00"
@.str.2 = [27 x i8] c"Thread %d doing section 1\0A\00"
@.str.3 = [27 x i8] c"Thread %d doing section 2\0A\00"
@.str.4 = [17 x i8] c"Thread %d done.\0A\00"
@.str.5 = [5 x i8] c"c: \00"
@.str.6 = [6 x i8] c"%.2f \00"
@.str.7 = [7 x i8] c"\0A\0Ad: \00"
@.str.8 = [2 x i8] c"\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [50 x float]
%10 = alloca [50 x float]
%11 = alloca [50 x float]
%12 = alloca [50 x float]
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %6
br label %13
13: ; preds = %37, %2
%14 = load i32, i32* %6
%15 = icmp slt i32 %14, 50
br i1 %15, label %16, label %40
16: ; preds = %13
%17 = load i32, i32* %6
%18 = sitofp i32 %17 to double
%19 = fmul double %18, 1.500000e+00
%20 = fptrunc double %19 to float
%21 = load i32, i32* %6
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds [50 x float], [50 x float]* %9, i64 0, i64 %22
store float %20, float* %23
%24 = load i32, i32* %6
%25 = sitofp i32 %24 to double
%26 = fadd double %25, 4.200000e+01
%27 = fptrunc double %26 to float
%28 = load i32, i32* %6
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [50 x float], [50 x float]* %10, i64 0, i64 %29
store float %27, float* %30
%31 = load i32, i32* %6
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [50 x float], [50 x float]* %12, i64 0, i64 %32
store float 0.000000e+00, float* %33
%34 = load i32, i32* %6
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [50 x float], [50 x float]* %11, i64 0, i64 %35
store float 0.000000e+00, float* %36
br label %37
37: ; preds = %16
%38 = load i32, i32* %6
%39 = add nsw i32 %38, 1
store i32 %39, i32* %6
br label %13
40: ; preds = %13
%41 = call i32 (...) @omp_get_thread_num()
store i32 %41, i32* %8
%42 = load i32, i32* %8
%43 = icmp eq i32 %42, 0
br i1 %43, label %44, label %48
44: ; preds = %40
%45 = call i32 (...) @omp_get_num_threads()
store i32 %45, i32* %7
%46 = load i32, i32* %7
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0), i32 %46)
br label %48
48: ; preds = %44, %40
%49 = load i32, i32* %8
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0), i32 %49)
%51 = load i32, i32* %8
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), i32 %51)
store i32 0, i32* %6
br label %53
53: ; preds = %69, %48
%54 = load i32, i32* %6
%55 = icmp slt i32 %54, 50
br i1 %55, label %56, label %72
56: ; preds = %53
%57 = load i32, i32* %6
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [50 x float], [50 x float]* %9, i64 0, i64 %58
%60 = load float, float* %59
%61 = load i32, i32* %6
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [50 x float], [50 x float]* %10, i64 0, i64 %62
%64 = load float, float* %63
%65 = fadd float %60, %64
%66 = load i32, i32* %6
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [50 x float], [50 x float]* %11, i64 0, i64 %67
store float %65, float* %68
br label %69
69: ; preds = %56
%70 = load i32, i32* %6
%71 = add nsw i32 %70, 1
store i32 %71, i32* %6
br label %53
72: ; preds = %53
%73 = load i32, i32* %8
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.3, i64 0, i64 0), i32 %73)
store i32 0, i32* %6
br label %75
75: ; preds = %91, %72
%76 = load i32, i32* %6
%77 = icmp slt i32 %76, 50
br i1 %77, label %78, label %94
78: ; preds = %75
%79 = load i32, i32* %6
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [50 x float], [50 x float]* %9, i64 0, i64 %80
%82 = load float, float* %81
%83 = load i32, i32* %6
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [50 x float], [50 x float]* %10, i64 0, i64 %84
%86 = load float, float* %85
%87 = fmul float %82, %86
%88 = load i32, i32* %6
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [50 x float], [50 x float]* %12, i64 0, i64 %89
store float %87, float* %90
br label %91
91: ; preds = %78
%92 = load i32, i32* %6
%93 = add nsw i32 %92, 1
store i32 %93, i32* %6
br label %75
94: ; preds = %75
%95 = load i32, i32* %8
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 %95)
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %6
br label %98
98: ; preds = %108, %94
%99 = load i32, i32* %6
%100 = icmp slt i32 %99, 50
br i1 %100, label %101, label %111
101: ; preds = %98
%102 = load i32, i32* %6
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [50 x float], [50 x float]* %11, i64 0, i64 %103
%105 = load float, float* %104
%106 = fpext float %105 to double
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), double %106)
br label %108
108: ; preds = %101
%109 = load i32, i32* %6
%110 = add nsw i32 %109, 1
store i32 %110, i32* %6
br label %98
111: ; preds = %98
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %6
br label %113
113: ; preds = %123, %111
%114 = load i32, i32* %6
%115 = icmp slt i32 %114, 50
br i1 %115, label %116, label %126
116: ; preds = %113
%117 = load i32, i32* %6
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [50 x float], [50 x float]* %12, i64 0, i64 %118
%120 = load float, float* %119
%121 = fpext float %120 to double
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), double %121)
br label %123
123: ; preds = %116
%124 = load i32, i32* %6
%125 = add nsw i32 %124, 1
store i32 %125, i32* %6
br label %113
126: ; preds = %113
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%128 = call i32 @exit(i32 0)
unreachable
}

LLVM IR (-O2):
@.str = [24 x i8] c"Number of threads = %d\0A\00"
@.str.1 = [23 x i8] c"Thread %d starting...\0A\00"
@.str.2 = [27 x i8] c"Thread %d doing section 1\0A\00"
@.str.3 = [27 x i8] c"Thread %d doing section 2\0A\00"
@.str.4 = [17 x i8] c"Thread %d done.\0A\00"
@.str.5 = [5 x i8] c"c: \00"
@.str.6 = [6 x i8] c"%.2f \00"
@.str.7 = [7 x i8] c"\0A\0Ad: \00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [50 x float]
%4 = alloca [50 x float]
%5 = alloca [50 x float]
%6 = bitcast [50 x float]* %5 to i8*
%7 = alloca [50 x float]
%8 = bitcast [50 x float]* %7 to i8*
%9 = bitcast [50 x float]* %3 to i8*
%10 = bitcast [50 x float]* %4 to i8*
%11 = bitcast [50 x float]* %3 to <4 x float>*
store <4 x float> <float 0.000000e+00, float 1.500000e+00, float 3.000000e+00, float 4.500000e+00>, <4 x float>* %11
%12 = bitcast [50 x float]* %4 to <4 x float>*
store <4 x float> <float 4.200000e+01, float 4.300000e+01, float 4.400000e+01, float 4.500000e+01>, <4 x float>* %12
%13 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 4
%14 = bitcast float* %13 to <4 x float>*
store <4 x float> <float 6.000000e+00, float 7.500000e+00, float 9.000000e+00, float 1.050000e+01>, <4 x float>* %14
%15 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 4
%16 = bitcast float* %15 to <4 x float>*
store <4 x float> <float 4.600000e+01, float 4.700000e+01, float 4.800000e+01, float 4.900000e+01>, <4 x float>* %16
%17 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 8
%18 = bitcast float* %17 to <4 x float>*
store <4 x float> <float 1.200000e+01, float 1.350000e+01, float 1.500000e+01, float 1.650000e+01>, <4 x float>* %18
%19 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 8
%20 = bitcast float* %19 to <4 x float>*
store <4 x float> <float 5.000000e+01, float 5.100000e+01, float 5.200000e+01, float 5.300000e+01>, <4 x float>* %20
%21 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 12
%22 = bitcast float* %21 to <4 x float>*
store <4 x float> <float 1.800000e+01, float 1.950000e+01, float 2.100000e+01, float 2.250000e+01>, <4 x float>* %22
%23 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 12
%24 = bitcast float* %23 to <4 x float>*
store <4 x float> <float 5.400000e+01, float 5.500000e+01, float 5.600000e+01, float 5.700000e+01>, <4 x float>* %24
%25 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 16
%26 = bitcast float* %25 to <4 x float>*
store <4 x float> <float 2.400000e+01, float 2.550000e+01, float 2.700000e+01, float 2.850000e+01>, <4 x float>* %26
%27 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 16
%28 = bitcast float* %27 to <4 x float>*
store <4 x float> <float 5.800000e+01, float 5.900000e+01, float 6.000000e+01, float 6.100000e+01>, <4 x float>* %28
%29 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 20
%30 = bitcast float* %29 to <4 x float>*
store <4 x float> <float 3.000000e+01, float 3.150000e+01, float 3.300000e+01, float 3.450000e+01>, <4 x float>* %30
%31 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 20
%32 = bitcast float* %31 to <4 x float>*
store <4 x float> <float 6.200000e+01, float 6.300000e+01, float 6.400000e+01, float 6.500000e+01>, <4 x float>* %32
%33 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 24
%34 = bitcast float* %33 to <4 x float>*
store <4 x float> <float 3.600000e+01, float 3.750000e+01, float 3.900000e+01, float 4.050000e+01>, <4 x float>* %34
%35 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 24
%36 = bitcast float* %35 to <4 x float>*
store <4 x float> <float 6.600000e+01, float 6.700000e+01, float 6.800000e+01, float 6.900000e+01>, <4 x float>* %36
%37 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 28
%38 = bitcast float* %37 to <4 x float>*
store <4 x float> <float 4.200000e+01, float 4.350000e+01, float 4.500000e+01, float 4.650000e+01>, <4 x float>* %38
%39 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 28
%40 = bitcast float* %39 to <4 x float>*
store <4 x float> <float 7.000000e+01, float 7.100000e+01, float 7.200000e+01, float 7.300000e+01>, <4 x float>* %40
%41 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 32
%42 = bitcast float* %41 to <4 x float>*
store <4 x float> <float 4.800000e+01, float 4.950000e+01, float 5.100000e+01, float 5.250000e+01>, <4 x float>* %42
%43 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 32
%44 = bitcast float* %43 to <4 x float>*
store <4 x float> <float 7.400000e+01, float 7.500000e+01, float 7.600000e+01, float 7.700000e+01>, <4 x float>* %44
%45 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 36
%46 = bitcast float* %45 to <4 x float>*
store <4 x float> <float 5.400000e+01, float 5.550000e+01, float 5.700000e+01, float 5.850000e+01>, <4 x float>* %46
%47 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 36
%48 = bitcast float* %47 to <4 x float>*
store <4 x float> <float 7.800000e+01, float 7.900000e+01, float 8.000000e+01, float 8.100000e+01>, <4 x float>* %48
%49 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 40
%50 = bitcast float* %49 to <4 x float>*
store <4 x float> <float 6.000000e+01, float 6.150000e+01, float 6.300000e+01, float 6.450000e+01>, <4 x float>* %50
%51 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 40
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> <float 8.200000e+01, float 8.300000e+01, float 8.400000e+01, float 8.500000e+01>, <4 x float>* %52
%53 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 44
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> <float 6.600000e+01, float 6.750000e+01, float 6.900000e+01, float 7.050000e+01>, <4 x float>* %54
%55 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 44
%56 = bitcast float* %55 to <4 x float>*
store <4 x float> <float 8.600000e+01, float 8.700000e+01, float 8.800000e+01, float 8.900000e+01>, <4 x float>* %56
%57 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 48
store float 7.200000e+01, float* %57
%58 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 48
store float 9.000000e+01, float* %58
%59 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 49
store float 7.350000e+01, float* %59
%60 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 49
store float 9.100000e+01, float* %60
%61 = tail call i32 (...) @omp_get_thread_num()
%62 = icmp eq i32 %61, 0
br i1 %62, label %63, label %66
63: ; preds = %2
%64 = tail call i32 (...) @omp_get_num_threads()
%65 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0), i32 %64)
br label %66
66: ; preds = %63, %2
%67 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0), i32 %61)
%68 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), i32 %61)
%69 = bitcast [50 x float]* %3 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = bitcast [50 x float]* %4 to <4 x float>*
%72 = load <4 x float>, <4 x float>* %71
%73 = fadd <4 x float> %70, %72
%74 = bitcast [50 x float]* %5 to <4 x float>*
store <4 x float> %73, <4 x float>* %74
%75 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 4
%76 = bitcast float* %75 to <4 x float>*
%77 = load <4 x float>, <4 x float>* %76
%78 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 4
%79 = bitcast float* %78 to <4 x float>*
%80 = load <4 x float>, <4 x float>* %79
%81 = fadd <4 x float> %77, %80
%82 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 4
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> %81, <4 x float>* %83
%84 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 8
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 8
%88 = bitcast float* %87 to <4 x float>*
%89 = load <4 x float>, <4 x float>* %88
%90 = fadd <4 x float> %86, %89
%91 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 8
%92 = bitcast float* %91 to <4 x float>*
store <4 x float> %90, <4 x float>* %92
%93 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 12
%94 = bitcast float* %93 to <4 x float>*
%95 = load <4 x float>, <4 x float>* %94
%96 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 12
%97 = bitcast float* %96 to <4 x float>*
%98 = load <4 x float>, <4 x float>* %97
%99 = fadd <4 x float> %95, %98
%100 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 12
%101 = bitcast float* %100 to <4 x float>*
store <4 x float> %99, <4 x float>* %101
%102 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 16
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 16
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = fadd <4 x float> %104, %107
%109 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 16
%110 = bitcast float* %109 to <4 x float>*
store <4 x float> %108, <4 x float>* %110
%111 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 20
%112 = bitcast float* %111 to <4 x float>*
%113 = load <4 x float>, <4 x float>* %112
%114 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 20
%115 = bitcast float* %114 to <4 x float>*
%116 = load <4 x float>, <4 x float>* %115
%117 = fadd <4 x float> %113, %116
%118 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 20
%119 = bitcast float* %118 to <4 x float>*
store <4 x float> %117, <4 x float>* %119
%120 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 24
%121 = bitcast float* %120 to <4 x float>*
%122 = load <4 x float>, <4 x float>* %121
%123 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 24
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = fadd <4 x float> %122, %125
%127 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 24
%128 = bitcast float* %127 to <4 x float>*
store <4 x float> %126, <4 x float>* %128
%129 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 28
%130 = bitcast float* %129 to <4 x float>*
%131 = load <4 x float>, <4 x float>* %130
%132 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 28
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = fadd <4 x float> %131, %134
%136 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 28
%137 = bitcast float* %136 to <4 x float>*
store <4 x float> %135, <4 x float>* %137
%138 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 32
%139 = bitcast float* %138 to <4 x float>*
%140 = load <4 x float>, <4 x float>* %139
%141 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 32
%142 = bitcast float* %141 to <4 x float>*
%143 = load <4 x float>, <4 x float>* %142
%144 = fadd <4 x float> %140, %143
%145 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 32
%146 = bitcast float* %145 to <4 x float>*
store <4 x float> %144, <4 x float>* %146
%147 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 36
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 36
%151 = bitcast float* %150 to <4 x float>*
%152 = load <4 x float>, <4 x float>* %151
%153 = fadd <4 x float> %149, %152
%154 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 36
%155 = bitcast float* %154 to <4 x float>*
store <4 x float> %153, <4 x float>* %155
%156 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 40
%157 = bitcast float* %156 to <4 x float>*
%158 = load <4 x float>, <4 x float>* %157
%159 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 40
%160 = bitcast float* %159 to <4 x float>*
%161 = load <4 x float>, <4 x float>* %160
%162 = fadd <4 x float> %158, %161
%163 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 40
%164 = bitcast float* %163 to <4 x float>*
store <4 x float> %162, <4 x float>* %164
%165 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 44
%166 = bitcast float* %165 to <4 x float>*
%167 = load <4 x float>, <4 x float>* %166
%168 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 44
%169 = bitcast float* %168 to <4 x float>*
%170 = load <4 x float>, <4 x float>* %169
%171 = fadd <4 x float> %167, %170
%172 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 44
%173 = bitcast float* %172 to <4 x float>*
store <4 x float> %171, <4 x float>* %173
%174 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 48
%175 = load float, float* %174
%176 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 48
%177 = load float, float* %176
%178 = fadd float %175, %177
%179 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 48
store float %178, float* %179
%180 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 49
%181 = load float, float* %180
%182 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 49
%183 = load float, float* %182
%184 = fadd float %181, %183
%185 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 49
store float %184, float* %185
%186 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.3, i64 0, i64 0), i32 %61)
%187 = bitcast [50 x float]* %3 to <4 x float>*
%188 = load <4 x float>, <4 x float>* %187
%189 = bitcast [50 x float]* %4 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = fmul <4 x float> %188, %190
%192 = bitcast [50 x float]* %7 to <4 x float>*
store <4 x float> %191, <4 x float>* %192
%193 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 4
%194 = bitcast float* %193 to <4 x float>*
%195 = load <4 x float>, <4 x float>* %194
%196 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 4
%197 = bitcast float* %196 to <4 x float>*
%198 = load <4 x float>, <4 x float>* %197
%199 = fmul <4 x float> %195, %198
%200 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 4
%201 = bitcast float* %200 to <4 x float>*
store <4 x float> %199, <4 x float>* %201
%202 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 8
%203 = bitcast float* %202 to <4 x float>*
%204 = load <4 x float>, <4 x float>* %203
%205 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 8
%206 = bitcast float* %205 to <4 x float>*
%207 = load <4 x float>, <4 x float>* %206
%208 = fmul <4 x float> %204, %207
%209 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 8
%210 = bitcast float* %209 to <4 x float>*
store <4 x float> %208, <4 x float>* %210
%211 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 12
%212 = bitcast float* %211 to <4 x float>*
%213 = load <4 x float>, <4 x float>* %212
%214 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 12
%215 = bitcast float* %214 to <4 x float>*
%216 = load <4 x float>, <4 x float>* %215
%217 = fmul <4 x float> %213, %216
%218 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 12
%219 = bitcast float* %218 to <4 x float>*
store <4 x float> %217, <4 x float>* %219
%220 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 16
%221 = bitcast float* %220 to <4 x float>*
%222 = load <4 x float>, <4 x float>* %221
%223 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 16
%224 = bitcast float* %223 to <4 x float>*
%225 = load <4 x float>, <4 x float>* %224
%226 = fmul <4 x float> %222, %225
%227 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 16
%228 = bitcast float* %227 to <4 x float>*
store <4 x float> %226, <4 x float>* %228
%229 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 20
%230 = bitcast float* %229 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 20
%233 = bitcast float* %232 to <4 x float>*
%234 = load <4 x float>, <4 x float>* %233
%235 = fmul <4 x float> %231, %234
%236 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 20
%237 = bitcast float* %236 to <4 x float>*
store <4 x float> %235, <4 x float>* %237
%238 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 24
%239 = bitcast float* %238 to <4 x float>*
%240 = load <4 x float>, <4 x float>* %239
%241 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 24
%242 = bitcast float* %241 to <4 x float>*
%243 = load <4 x float>, <4 x float>* %242
%244 = fmul <4 x float> %240, %243
%245 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 24
%246 = bitcast float* %245 to <4 x float>*
store <4 x float> %244, <4 x float>* %246
%247 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 28
%248 = bitcast float* %247 to <4 x float>*
%249 = load <4 x float>, <4 x float>* %248
%250 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 28
%251 = bitcast float* %250 to <4 x float>*
%252 = load <4 x float>, <4 x float>* %251
%253 = fmul <4 x float> %249, %252
%254 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 28
%255 = bitcast float* %254 to <4 x float>*
store <4 x float> %253, <4 x float>* %255
%256 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 32
%257 = bitcast float* %256 to <4 x float>*
%258 = load <4 x float>, <4 x float>* %257
%259 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 32
%260 = bitcast float* %259 to <4 x float>*
%261 = load <4 x float>, <4 x float>* %260
%262 = fmul <4 x float> %258, %261
%263 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 32
%264 = bitcast float* %263 to <4 x float>*
store <4 x float> %262, <4 x float>* %264
%265 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 36
%266 = bitcast float* %265 to <4 x float>*
%267 = load <4 x float>, <4 x float>* %266
%268 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 36
%269 = bitcast float* %268 to <4 x float>*
%270 = load <4 x float>, <4 x float>* %269
%271 = fmul <4 x float> %267, %270
%272 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 36
%273 = bitcast float* %272 to <4 x float>*
store <4 x float> %271, <4 x float>* %273
%274 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 40
%275 = bitcast float* %274 to <4 x float>*
%276 = load <4 x float>, <4 x float>* %275
%277 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 40
%278 = bitcast float* %277 to <4 x float>*
%279 = load <4 x float>, <4 x float>* %278
%280 = fmul <4 x float> %276, %279
%281 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 40
%282 = bitcast float* %281 to <4 x float>*
store <4 x float> %280, <4 x float>* %282
%283 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 44
%284 = bitcast float* %283 to <4 x float>*
%285 = load <4 x float>, <4 x float>* %284
%286 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 44
%287 = bitcast float* %286 to <4 x float>*
%288 = load <4 x float>, <4 x float>* %287
%289 = fmul <4 x float> %285, %288
%290 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 44
%291 = bitcast float* %290 to <4 x float>*
store <4 x float> %289, <4 x float>* %291
%292 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 48
%293 = load float, float* %292
%294 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 48
%295 = load float, float* %294
%296 = fmul float %293, %295
%297 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 48
store float %296, float* %297
%298 = getelementptr inbounds [50 x float], [50 x float]* %3, i64 0, i64 49
%299 = load float, float* %298
%300 = getelementptr inbounds [50 x float], [50 x float]* %4, i64 0, i64 49
%301 = load float, float* %300
%302 = fmul float %299, %301
%303 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 49
store float %302, float* %303
%304 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 %61)
%305 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
br label %306
306: ; preds = %66, %306
%307 = phi i64 [ 0, %66 ], [ %312, %306 ]
%308 = getelementptr inbounds [50 x float], [50 x float]* %5, i64 0, i64 %307
%309 = load float, float* %308
%310 = fpext float %309 to double
%311 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), double %310)
%312 = add nuw nsw i64 %307, 1
%313 = icmp eq i64 %312, 50
br i1 %313, label %314, label %306
314: ; preds = %306
%315 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
br label %316
316: ; preds = %314, %316
%317 = phi i64 [ 0, %314 ], [ %322, %316 ]
%318 = getelementptr inbounds [50 x float], [50 x float]* %7, i64 0, i64 %317
%319 = load float, float* %318
%320 = fpext float %319 to double
%321 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), double %320)
%322 = add nuw nsw i64 %317, 1
%323 = icmp eq i64 %322, 50
br i1 %323, label %324, label %316
324: ; preds = %316
%325 = tail call i32 @putchar(i32 10)
%326 = tail call i32 @exit(i32 0)
unreachable
}