#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 */
double acos(double);
double powf(double, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, double *);
double sqrt(double);
int main() {
  int i, j, k;
  double v1[3];
  double v2[3];
  double value;
  double angle;
  double scalarProduct;
  double moduleVector1, moduleVector2;
  double finalCalc;
  printf("-------------------------------------------------------------\n");
  printf("Insert the values for the vectors (v1 and v2):\n");
  printf("-------------------------------------------------------------\n");
  printf("Insert the value to vector v1 for x: ");
  scanf("%lf", &value);
  v1[0] = value;
  printf("Insert the value to vector v1 for y: ");
  scanf("%lf", &value);
  v1[1] = value;
  printf("Insert the value to vector v1 for z: ");
  scanf("%lf", &value);
  v1[2] = value;
  printf("\n-------------------------------------------------------------\n\n");
  printf("Insert the value to vector v2 for x: ");
  scanf("%lf", &value);
  v2[0] = value;
  printf("Insert the value to vector v2 for y: ");
  scanf("%lf", &value);
  v2[1] = value;
  printf("Insert the value to vector v2 for z: ");
  scanf("%lf", &value);
  v2[2] = value;
  scalarProduct = (v1[0] * v2[0]) + (v1[1] * v2[1]) + (v1[2] * v2[2]);
  if (scalarProduct < 0) {
    scalarProduct = scalarProduct * (-1);
  }
  moduleVector1 = ((powf(v1[0], 2)) + (powf(v1[1], 2)) + (powf(v1[2], 2)));
  moduleVector1 = sqrt(moduleVector1);
  moduleVector2 = ((powf(v2[0], 2)) + (powf(v2[1], 2)) + (powf(v2[2], 2)));
  moduleVector2 = sqrt(moduleVector2);
  finalCalc = (scalarProduct) / (moduleVector1 * moduleVector2);
  angle = acos(finalCalc) * 180.0 / 3.14159265;
  printf("\nFinished! The angle is: %f \n", angle);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeaf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xee0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe93(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xef4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf0c(%rip),%rdi
lea    -0x58(%rbp),%rsi
call   1060 <scanf@plt>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
lea    0xef6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xee4(%rip),%rdi
lea    -0x58(%rbp),%rsi
call   1060 <scanf@plt>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
lea    0xef4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xebc(%rip),%rdi
lea    -0x58(%rbp),%rsi
call   1060 <scanf@plt>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
lea    0xef2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf25(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe86(%rip),%rdi
lea    -0x58(%rbp),%rsi
call   1060 <scanf@plt>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
lea    0xf23(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe5e(%rip),%rdi
lea    -0x58(%rbp),%rsi
call   1060 <scanf@plt>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
lea    0xf21(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe36(%rip),%rdi
lea    -0x58(%rbp),%rsi
call   1060 <scanf@plt>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    12dd <main+0x18d>
movsd  0xd2d(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <powf@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <powf@plt>
movaps %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <powf@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
call   1070 <sqrt@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <powf@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <powf@plt>
movaps %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <powf@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
call   1070 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
call   1050 <acos@plt>
movsd  0xc2b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc17(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
lea    0xdaa(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x58,%rsp
lea    0xfef(%rip),%rbx
mov    %rbx,%rdi
call   1030 <puts@plt>
lea    0xfb1(%rip),%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
call   1030 <puts@plt>
lea    0xe97(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xeaf(%rip),%rbx
lea    0x18(%rsp),%r14
mov    %rbx,%rdi
mov    %r14,%rsi
call   1070 <scanf@plt>
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
lea    0xe90(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1070 <scanf@plt>
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0xe91(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1070 <scanf@plt>
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
lea    0xf8f(%rip),%rdi
call   1030 <puts@plt>
lea    0xe86(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1070 <scanf@plt>
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
lea    0xe87(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1070 <scanf@plt>
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
lea    0xe88(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1070 <scanf@plt>
movsd  0x18(%rsp),%xmm4
movsd  0x8(%rsp),%xmm2
mulsd  0x30(%rsp),%xmm2
movsd  0x20(%rsp),%xmm0
movapd %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm2,%xmm1
movsd  0x28(%rsp),%xmm3
movsd  %xmm4,0x38(%rsp)
mulsd  %xmm4,%xmm3
addsd  %xmm1,%xmm3
movapd 0xd4a(%rip),%xmm1
xorpd  %xmm3,%xmm1
xorpd  %xmm4,%xmm4
movapd %xmm3,%xmm2
cmpltsd %xmm4,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm3,%xmm2
orpd   %xmm1,%xmm2
movapd %xmm2,0x40(%rsp)
mov    $0x2,%edi
call   1040 <powf@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <powf@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x28(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <powf@plt>
addsd  0x8(%rsp),%xmm0
ucomisd 0xcfd(%rip),%xmm0
jb     132b <main+0x1cb>
sqrtsd %xmm0,%xmm0
jmp    1330 <main+0x1d0>
call   1080 <sqrt@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <powf@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x30(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <powf@plt>
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x38(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <powf@plt>
addsd  0x10(%rsp),%xmm0
ucomisd 0xc9a(%rip),%xmm0
jb     138e <main+0x22e>
sqrtsd %xmm0,%xmm0
jmp    1393 <main+0x233>
call   1080 <sqrt@plt>
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd 0x40(%rsp),%xmm0
divsd  %xmm1,%xmm0
call   1060 <acos@plt>
mulsd  0xc5c(%rip),%xmm0
divsd  0xc5c(%rip),%xmm0
lea    0xd4d(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@.str = [63 x i8] c"-------------------------------------------------------------\0A\00"
@.str.1 = [48 x i8] c"Insert the values for the vectors (v1 and v2):\0A\00"
@.str.2 = [38 x i8] c"Insert the value to vector v1 for x: \00"
@.str.3 = [4 x i8] c"%lf\00"
@.str.4 = [38 x i8] c"Insert the value to vector v1 for y: \00"
@.str.5 = [38 x i8] c"Insert the value to vector v1 for z: \00"
@.str.6 = [65 x i8] c"\0A-------------------------------------------------------------\0A\0A\00"
@.str.7 = [38 x i8] c"Insert the value to vector v2 for x: \00"
@.str.8 = [38 x i8] c"Insert the value to vector v2 for y: \00"
@.str.9 = [38 x i8] c"Insert the value to vector v2 for z: \00"
@.str.10 = [30 x i8] c"\0AFinished! The angle is: %f \0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [3 x double]
%6 = alloca [3 x double]
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
store i32 0, i32* %1
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0))
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0))
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0))
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
%17 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %7)
%18 = load double, double* %7
%19 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
store double %18, double* %19
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.4, i64 0, i64 0))
%21 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %7)
%22 = load double, double* %7
%23 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
store double %22, double* %23
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.5, i64 0, i64 0))
%25 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %7)
%26 = load double, double* %7
%27 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
store double %26, double* %27
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.6, i64 0, i64 0))
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0))
%30 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %7)
%31 = load double, double* %7
%32 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
store double %31, double* %32
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.8, i64 0, i64 0))
%34 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %7)
%35 = load double, double* %7
%36 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
store double %35, double* %36
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.9, i64 0, i64 0))
%38 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %7)
%39 = load double, double* %7
%40 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %39, double* %40
%41 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%42 = load double, double* %41
%43 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%44 = load double, double* %43
%45 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%46 = load double, double* %45
%47 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%48 = load double, double* %47
%49 = fmul double %46, %48
%50 = call double @llvm.fmuladd.f64(double %42, double %44, double %49)
%51 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%52 = load double, double* %51
%53 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%54 = load double, double* %53
%55 = call double @llvm.fmuladd.f64(double %52, double %54, double %50)
store double %55, double* %9
%56 = load double, double* %9
%57 = fcmp olt double %56, 0.000000e+00
br i1 %57, label %58, label %61
58: ; preds = %0
%59 = load double, double* %9
%60 = fmul double %59, -1.000000e+00
store double %60, double* %9
br label %61
61: ; preds = %58, %0
%62 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%63 = load double, double* %62
%64 = call double @powf(double %63, i32 2)
%65 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%66 = load double, double* %65
%67 = call double @powf(double %66, i32 2)
%68 = fadd double %64, %67
%69 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%70 = load double, double* %69
%71 = call double @powf(double %70, i32 2)
%72 = fadd double %68, %71
store double %72, double* %10
%73 = load double, double* %10
%74 = call double @sqrt(double %73)
store double %74, double* %10
%75 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%76 = load double, double* %75
%77 = call double @powf(double %76, i32 2)
%78 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%79 = load double, double* %78
%80 = call double @powf(double %79, i32 2)
%81 = fadd double %77, %80
%82 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%83 = load double, double* %82
%84 = call double @powf(double %83, i32 2)
%85 = fadd double %81, %84
store double %85, double* %11
%86 = load double, double* %11
%87 = call double @sqrt(double %86)
store double %87, double* %11
%88 = load double, double* %9
%89 = load double, double* %10
%90 = load double, double* %11
%91 = fmul double %89, %90
%92 = fdiv double %88, %91
store double %92, double* %12
%93 = load double, double* %12
%94 = call double @acos(double %93)
%95 = fmul double %94, 1.800000e+02
%96 = fdiv double %95, 0x400921FB53C8D4F1
store double %96, double* %8
%97 = load double, double* %8
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.10, i64 0, i64 0), double %97)
%99 = load i32, i32* %1
ret i32 %99
}

LLVM IR (-O2):
@.str.2 = [38 x i8] c"Insert the value to vector v1 for x: \00"
@.str.3 = [4 x i8] c"%lf\00"
@.str.4 = [38 x i8] c"Insert the value to vector v1 for y: \00"
@.str.5 = [38 x i8] c"Insert the value to vector v1 for z: \00"
@.str.7 = [38 x i8] c"Insert the value to vector v2 for x: \00"
@.str.8 = [38 x i8] c"Insert the value to vector v2 for y: \00"
@.str.9 = [38 x i8] c"Insert the value to vector v2 for z: \00"
@.str.10 = [30 x i8] c"\0AFinished! The angle is: %f \0A\00"
@str.11 = [47 x i8] c"Insert the values for the vectors (v1 and v2):\00"
@str.12 = [62 x i8] c"-------------------------------------------------------------\00"
@str.13 = [64 x i8] c"\0A-------------------------------------------------------------\0A\00"
define i32 @main() {
%1 = alloca double
%2 = bitcast double* %1 to i8*
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @str.12, i64 0, i64 0))
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.11, i64 0, i64 0))
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @str.12, i64 0, i64 0))
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0))
%7 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %1)
%8 = load double, double* %1
%9 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.4, i64 0, i64 0))
%10 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %1)
%11 = load double, double* %1
%12 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.5, i64 0, i64 0))
%13 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %1)
%14 = load double, double* %1
%15 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.13, i64 0, i64 0))
%16 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0))
%17 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %1)
%18 = load double, double* %1
%19 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.8, i64 0, i64 0))
%20 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %1)
%21 = load double, double* %1
%22 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.9, i64 0, i64 0))
%23 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double* %1)
%24 = load double, double* %1
%25 = fmul double %11, %21
%26 = call double @llvm.fmuladd.f64(double %8, double %18, double %25)
%27 = call double @llvm.fmuladd.f64(double %14, double %24, double %26)
%28 = fcmp olt double %27, 0.000000e+00
%29 = fneg double %27
%30 = select i1 %28, double %29, double %27
%31 = call double @powf(double %8, i32 2)
%32 = call double @powf(double %11, i32 2)
%33 = fadd double %31, %32
%34 = call double @powf(double %14, i32 2)
%35 = fadd double %33, %34
%36 = call double @sqrt(double %35)
%37 = call double @powf(double %18, i32 2)
%38 = call double @powf(double %21, i32 2)
%39 = fadd double %37, %38
%40 = call double @powf(double %24, i32 2)
%41 = fadd double %39, %40
%42 = call double @sqrt(double %41)
%43 = fmul double %36, %42
%44 = fdiv double %30, %43
%45 = call double @acos(double %44)
%46 = fmul double %45, 1.800000e+02
%47 = fdiv double %46, 0x400921FB53C8D4F1
%48 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.10, i64 0, i64 0), double %47)
ret i32 0
}