#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 */
float asin(float);
float atof(char *);
char check0(float, float, float);
int /*<<< orphan*/ printf(char *, ...);
float sqrt(float);
int /*<<< orphan*/ usage(char *);
int main(int argc, char *argv[]) {
  float a, b, c, sum, alpha, beta, sinalpha, sinbeta, p, q, h, flaeche, u;
  if (argc != 4)
    usage(argv[0]);
  a = atof(argv[1]);
  b = atof(argv[2]);
  c = atof(argv[3]);
  char check = check0(a, b, c);
  if (check == 'a')
    a = sqrt((c * c) - (b * b));
  if (check == 'b')
    b = sqrt((c * c) - (a * a));
  if (check == 'c')
    c = sqrt((a * a) + (b * b));
  u = a + b + c;
  flaeche = (a * b) / 2;
  q = (a * a) / c;
  p = c - q;
  h = sqrt(p * q);
  sinalpha = a / c;
  alpha = asin(sinalpha);
  alpha *= 180 / 3.1415926535;
  sinbeta = b / c;
  beta = asin(sinbeta);
  beta *= 180 / 3.1415926535;
  printf("#######################\n");
  printf("a = %f\tp = %f\nb = %f\tq = %f\nc = %f\th = %f\n", a, p, b, q, c, h);
  printf("#######################\n");
  printf("A = %f\tu = %f\n", flaeche, u);
  printf("#######################\n");
  printf("alpha = %f\tsinalpha = %f\nbeta  = %f\tsinbeta  = %f\n", alpha,
         sinalpha, beta, sinbeta);
  printf("#######################\n");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x4,-0x8(%rbp)
je     118c <main+0x2c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   1070 <usage@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1040 <atof@plt>
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1040 <atof@plt>
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   1040 <atof@plt>
movss  %xmm0,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
call   1030 <check0@plt>
mov    %al,-0x45(%rbp)
movsbl -0x45(%rbp),%eax
cmp    $0x61,%eax
jne    1219 <main+0xb9>
movss  -0x1c(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1080 <sqrt@plt>
movss  %xmm0,-0x14(%rbp)
movsbl -0x45(%rbp),%eax
cmp    $0x62,%eax
jne    1259 <main+0xf9>
movss  -0x1c(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1080 <sqrt@plt>
movss  %xmm0,-0x18(%rbp)
movsbl -0x45(%rbp),%eax
cmp    $0x63,%eax
jne    128c <main+0x12c>
movss  -0x14(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1080 <sqrt@plt>
movss  %xmm0,-0x1c(%rbp)
movss  -0x14(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  0xd56(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
divss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
call   1080 <sqrt@plt>
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
divss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
call   1060 <asin@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcdf(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x18(%rbp),%xmm0
divss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
call   1060 <asin@plt>
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xca3(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
lea    0xc9b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x18(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x38(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x1c(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  -0x3c(%rbp),%xmm5
cvtss2sd %xmm5,%xmm5
lea    0xc70(%rip),%rdi
mov    $0x6,%al
call   1050 <printf@plt>
lea    0xc49(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc6d(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
lea    0xc1b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x2c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x30(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xc3c(%rip),%rdi
mov    $0x4,%al
call   1050 <printf@plt>
lea    0xbdb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x30,%rsp
mov    %rsi,%rbx
cmp    $0x4,%edi
je     1185 <main+0x15>
mov    (%rbx),%rdi
call   1080 <usage@plt>
mov    0x8(%rbx),%rdi
call   1050 <atof@plt>
movss  %xmm0,(%rsp)
mov    0x10(%rbx),%rdi
call   1050 <atof@plt>
movss  %xmm0,0x8(%rsp)
mov    0x18(%rbx),%rdi
call   1050 <atof@plt>
movaps %xmm0,%xmm2
movss  (%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm2,0x4(%rsp)
call   1040 <check0@plt>
cmp    $0x63,%al
je     11ff <main+0x8f>
cmp    $0x62,%al
je     1224 <main+0xb4>
cmp    $0x61,%al
jne    126d <main+0xfd>
movss  0x8(%rsp),%xmm1
mulss  %xmm1,%xmm1
movss  0x4(%rsp),%xmm0
mulss  %xmm0,%xmm0
subss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1249 <main+0xd9>
sqrtss %xmm0,%xmm0
movss  %xmm0,(%rsp)
jmp    126d <main+0xfd>
movss  0x8(%rsp),%xmm1
mulss  %xmm1,%xmm1
movss  (%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1255 <main+0xe5>
sqrtss %xmm0,%xmm0
jmp    125a <main+0xea>
movss  (%rsp),%xmm1
mulss  %xmm1,%xmm1
movss  0x4(%rsp),%xmm0
mulss  %xmm0,%xmm0
subss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1262 <main+0xf2>
sqrtss %xmm0,%xmm0
jmp    1267 <main+0xf7>
call   1090 <sqrt@plt>
movss  %xmm0,(%rsp)
jmp    126d <main+0xfd>
call   1090 <sqrt@plt>
movss  %xmm0,0x4(%rsp)
jmp    126d <main+0xfd>
call   1090 <sqrt@plt>
movss  %xmm0,0x8(%rsp)
movss  0x8(%rsp),%xmm1
movaps %xmm1,%xmm2
movss  (%rsp),%xmm0
addss  %xmm0,%xmm2
mulss  %xmm0,%xmm1
mulss  0xd75(%rip),%xmm1
movss  %xmm1,0x28(%rsp)
movss  0x4(%rsp),%xmm1
addss  %xmm1,%xmm2
movss  %xmm2,0x2c(%rsp)
mulss  %xmm0,%xmm0
divss  %xmm1,%xmm0
subss  %xmm0,%xmm1
movss  %xmm0,0x20(%rsp)
movss  %xmm1,0x14(%rsp)
mulss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     12cb <main+0x15b>
sqrtss %xmm0,%xmm0
jmp    12d0 <main+0x160>
call   1090 <sqrt@plt>
movss  %xmm0,0xc(%rsp)
movss  (%rsp),%xmm0
divss  0x4(%rsp),%xmm0
movss  %xmm0,0x24(%rsp)
call   1070 <asin@plt>
cvtss2sd %xmm0,%xmm0
mulsd  0xd10(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0x8(%rsp),%xmm0
divss  0x4(%rsp),%xmm0
movss  %xmm0,0x18(%rsp)
call   1070 <asin@plt>
cvtss2sd %xmm0,%xmm0
mulsd  0xce3(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
lea    0xd47(%rip),%rbx
mov    %rbx,%rdi
call   1030 <puts@plt>
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x14(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x8(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x20(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x4(%rsp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  0xc(%rsp),%xmm5
cvtss2sd %xmm5,%xmm5
lea    0xc90(%rip),%rdi
mov    $0x6,%al
call   1060 <printf@plt>
mov    %rbx,%rdi
call   1030 <puts@plt>
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x2c(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc91(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
mov    %rbx,%rdi
call   1030 <puts@plt>
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x24(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x10(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x18(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
lea    0xc62(%rip),%rdi
mov    $0x4,%al
call   1060 <printf@plt>
mov    %rbx,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [25 x i8] c"#######################\0A\00"
@.str.1 = [43 x i8] c"a = %f\09p = %f\0Ab = %f\09q = %f\0Ac = %f\09h = %f\0A\00"
@.str.2 = [15 x i8] c"A = %f\09u = %f\0A\00"
@.str.3 = [51 x i8] c"alpha = %f\09sinalpha = %f\0Abeta = %f\09sinbeta = %f\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca i8
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%20 = load i32, i32* %4
%21 = icmp ne i32 %20, 4
br i1 %21, label %22, label %27
22: ; preds = %2
%23 = load i8**, i8*** %5
%24 = getelementptr inbounds i8*, i8** %23, i64 0
%25 = load i8*, i8** %24
%26 = call i32 @usage(i8* %25)
br label %27
27: ; preds = %22, %2
%28 = load i8**, i8*** %5
%29 = getelementptr inbounds i8*, i8** %28, i64 1
%30 = load i8*, i8** %29
%31 = call float @atof(i8* %30)
store float %31, float* %6
%32 = load i8**, i8*** %5
%33 = getelementptr inbounds i8*, i8** %32, i64 2
%34 = load i8*, i8** %33
%35 = call float @atof(i8* %34)
store float %35, float* %7
%36 = load i8**, i8*** %5
%37 = getelementptr inbounds i8*, i8** %36, i64 3
%38 = load i8*, i8** %37
%39 = call float @atof(i8* %38)
store float %39, float* %8
%40 = load float, float* %6
%41 = load float, float* %7
%42 = load float, float* %8
%43 = call signext i8 @check0(float %40, float %41, float %42)
store i8 %43, i8* %19
%44 = load i8, i8* %19
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 97
br i1 %46, label %47, label %56
47: ; preds = %27
%48 = load float, float* %8
%49 = load float, float* %8
%50 = load float, float* %7
%51 = load float, float* %7
%52 = fmul float %50, %51
%53 = fneg float %52
%54 = call float @llvm.fmuladd.f32(float %48, float %49, float %53)
%55 = call float @sqrt(float %54)
store float %55, float* %6
br label %56
56: ; preds = %47, %27
%57 = load i8, i8* %19
%58 = sext i8 %57 to i32
%59 = icmp eq i32 %58, 98
br i1 %59, label %60, label %69
60: ; preds = %56
%61 = load float, float* %8
%62 = load float, float* %8
%63 = load float, float* %6
%64 = load float, float* %6
%65 = fmul float %63, %64
%66 = fneg float %65
%67 = call float @llvm.fmuladd.f32(float %61, float %62, float %66)
%68 = call float @sqrt(float %67)
store float %68, float* %7
br label %69
69: ; preds = %60, %56
%70 = load i8, i8* %19
%71 = sext i8 %70 to i32
%72 = icmp eq i32 %71, 99
br i1 %72, label %73, label %81
73: ; preds = %69
%74 = load float, float* %6
%75 = load float, float* %6
%76 = load float, float* %7
%77 = load float, float* %7
%78 = fmul float %76, %77
%79 = call float @llvm.fmuladd.f32(float %74, float %75, float %78)
%80 = call float @sqrt(float %79)
store float %80, float* %8
br label %81
81: ; preds = %73, %69
%82 = load float, float* %6
%83 = load float, float* %7
%84 = fadd float %82, %83
%85 = load float, float* %8
%86 = fadd float %84, %85
store float %86, float* %18
%87 = load float, float* %6
%88 = load float, float* %7
%89 = fmul float %87, %88
%90 = fdiv float %89, 2.000000e+00
store float %90, float* %17
%91 = load float, float* %6
%92 = load float, float* %6
%93 = fmul float %91, %92
%94 = load float, float* %8
%95 = fdiv float %93, %94
store float %95, float* %15
%96 = load float, float* %8
%97 = load float, float* %15
%98 = fsub float %96, %97
store float %98, float* %14
%99 = load float, float* %14
%100 = load float, float* %15
%101 = fmul float %99, %100
%102 = call float @sqrt(float %101)
store float %102, float* %16
%103 = load float, float* %6
%104 = load float, float* %8
%105 = fdiv float %103, %104
store float %105, float* %12
%106 = load float, float* %12
%107 = call float @asin(float %106)
store float %107, float* %10
%108 = load float, float* %10
%109 = fpext float %108 to double
%110 = fmul double %109, 0x404CA5DC1A674644
%111 = fptrunc double %110 to float
store float %111, float* %10
%112 = load float, float* %7
%113 = load float, float* %8
%114 = fdiv float %112, %113
store float %114, float* %13
%115 = load float, float* %13
%116 = call float @asin(float %115)
store float %116, float* %11
%117 = load float, float* %11
%118 = fpext float %117 to double
%119 = fmul double %118, 0x404CA5DC1A674644
%120 = fptrunc double %119 to float
store float %120, float* %11
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str, i64 0, i64 0))
%122 = load float, float* %6
%123 = fpext float %122 to double
%124 = load float, float* %14
%125 = fpext float %124 to double
%126 = load float, float* %7
%127 = fpext float %126 to double
%128 = load float, float* %15
%129 = fpext float %128 to double
%130 = load float, float* %8
%131 = fpext float %130 to double
%132 = load float, float* %16
%133 = fpext float %132 to double
%134 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0), double %123, double %125, double %127, double %129, double %131, double %133)
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str, i64 0, i64 0))
%136 = load float, float* %17
%137 = fpext float %136 to double
%138 = load float, float* %18
%139 = fpext float %138 to double
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), double %137, double %139)
%141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str, i64 0, i64 0))
%142 = load float, float* %10
%143 = fpext float %142 to double
%144 = load float, float* %12
%145 = fpext float %144 to double
%146 = load float, float* %11
%147 = fpext float %146 to double
%148 = load float, float* %13
%149 = fpext float %148 to double
%150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.3, i64 0, i64 0), double %143, double %145, double %147, double %149)
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str, i64 0, i64 0))
%152 = load i32, i32* %3
ret i32 %152
}

LLVM IR (-O2):
@.str.1 = [43 x i8] c"a = %f\09p = %f\0Ab = %f\09q = %f\0Ac = %f\09h = %f\0A\00"
@.str.2 = [15 x i8] c"A = %f\09u = %f\0A\00"
@.str.3 = [51 x i8] c"alpha = %f\09sinalpha = %f\0Abeta = %f\09sinbeta = %f\0A\00"
@str.6 = [24 x i8] c"#######################\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp eq i32 %0, 4
br i1 %3, label %7, label %4
4: ; preds = %2
%5 = load i8*, i8** %1
%6 = tail call i32 @usage(i8* %5)
br label %7
7: ; preds = %4, %2
%8 = getelementptr inbounds i8*, i8** %1, i64 1
%9 = load i8*, i8** %8
%10 = tail call float @atof(i8* %9)
%11 = getelementptr inbounds i8*, i8** %1, i64 2
%12 = load i8*, i8** %11
%13 = tail call float @atof(i8* %12)
%14 = getelementptr inbounds i8*, i8** %1, i64 3
%15 = load i8*, i8** %14
%16 = tail call float @atof(i8* %15)
%17 = tail call signext i8 @check0(float %10, float %13, float %16)
switch i8 %17, label %32 [
i8 97, label %18
i8 98, label %23
i8 99, label %28
]
18: ; preds = %7
%19 = fneg float %13
%20 = fmul float %13, %19
%21 = tail call float @llvm.fmuladd.f32(float %16, float %16, float %20)
%22 = tail call float @sqrt(float %21)
br label %32
23: ; preds = %7
%24 = fneg float %10
%25 = fmul float %10, %24
%26 = tail call float @llvm.fmuladd.f32(float %16, float %16, float %25)
%27 = tail call float @sqrt(float %26)
br label %32
28: ; preds = %7
%29 = fmul float %13, %13
%30 = tail call float @llvm.fmuladd.f32(float %10, float %10, float %29)
%31 = tail call float @sqrt(float %30)
br label %32
32: ; preds = %7, %23, %18, %28
%33 = phi float [ %13, %28 ], [ %13, %18 ], [ %27, %23 ], [ %13, %7 ]
%34 = phi float [ %10, %28 ], [ %22, %18 ], [ %10, %23 ], [ %10, %7 ]
%35 = phi float [ %31, %28 ], [ %16, %18 ], [ %16, %23 ], [ %16, %7 ]
%36 = fadd float %33, %34
%37 = fadd float %36, %35
%38 = fmul float %33, %34
%39 = fmul float %38, 5.000000e-01
%40 = fmul float %34, %34
%41 = fdiv float %40, %35
%42 = fsub float %35, %41
%43 = fmul float %41, %42
%44 = tail call float @sqrt(float %43)
%45 = fdiv float %34, %35
%46 = tail call float @asin(float %45)
%47 = fpext float %46 to double
%48 = fmul double %47, 0x404CA5DC1A674644
%49 = fptrunc double %48 to float
%50 = fdiv float %33, %35
%51 = tail call float @asin(float %50)
%52 = fpext float %51 to double
%53 = fmul double %52, 0x404CA5DC1A674644
%54 = fptrunc double %53 to float
%55 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.6, i64 0, i64 0))
%56 = fpext float %34 to double
%57 = fpext float %42 to double
%58 = fpext float %33 to double
%59 = fpext float %41 to double
%60 = fpext float %35 to double
%61 = fpext float %44 to double
%62 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0), double %56, double %57, double %58, double %59, double %60, double %61)
%63 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.6, i64 0, i64 0))
%64 = fpext float %39 to double
%65 = fpext float %37 to double
%66 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), double %64, double %65)
%67 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.6, i64 0, i64 0))
%68 = fpext float %49 to double
%69 = fpext float %45 to double
%70 = fpext float %54 to double
%71 = fpext float %50 to double
%72 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.3, i64 0, i64 0), double %68, double %69, double %70, double %71)
%73 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.6, i64 0, i64 0))
ret i32 0
}