#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 Ang(float *, float *, float *);
float Dist(float *, float *);
float cos(float);
float sin(float);
void Place123_X(float *Coord1, float *Coord2, float *Coord3, float Dist3X,
                float Ang23X, float *CoordX) {
  float Length_23, Length_12;
  float Proj3X_1, Proj3X_2, Proj12_1, Proj12_2, Rad1, Rad2;
  float UnVect1[3], UnVect2[3];
  int i;
  Length_23 = Dist(Coord3, Coord2);
  Length_12 = Dist(Coord2, Coord1);
  Rad1 = (180.0 - Ang23X) * 3.1415927 / 180.0;
  Rad2 = (Ang(Coord1, Coord2, Coord3) - 90.0) * 3.1415927 / 180.0;
  Proj3X_1 = Dist3X * cos(Rad1);
  Proj3X_2 = Dist3X * sin(Rad1);
  Proj12_2 = cos(Rad2) * Length_12;
  Proj12_1 = sin(Rad2) * Length_12;
  for (i = 0; i < 3; i++) {
    UnVect1[i] = (Coord3[i] - Coord2[i]) / Length_23;
    UnVect2[i] =
        ((Coord1[i] - Coord2[i]) - (-UnVect1[i] * Proj12_1)) / Proj12_2;
  }
  for (i = 0; i < 3; i++)
    CoordX[i] = Proj3X_1 * UnVect1[i] + Proj3X_2 * UnVect2[i] + Coord3[i];
}


x86 assembly (clang, -O0):
<Place123_X>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <Dist@plt>
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <Dist@plt>
movss  %xmm0,-0x30(%rbp)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe69(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  0xe65(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe51(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1050 <Ang@plt>
movsd  0xe3b(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0xe27(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe13(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x44(%rbp),%xmm0
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movss  -0x6c(%rbp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x44(%rbp),%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movss  -0x68(%rbp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x48(%rbp),%xmm0
call   1060 <cos@plt>
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x48(%rbp),%xmm0
call   1040 <sin@plt>
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x3,-0x64(%rbp)
jge    130e <Place123_X+0x1ce>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x2c(%rbp),%xmm0
movslq -0x64(%rbp),%rax
movss  %xmm0,-0x54(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
movslq -0x64(%rbp),%rax
movss  -0x54(%rbp,%rax,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x3c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x40(%rbp),%xmm0
movslq -0x64(%rbp),%rax
movss  %xmm0,-0x60(%rbp,%rax,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1273 <Place123_X+0x133>
movl   $0x0,-0x64(%rbp)
cmpl   $0x3,-0x64(%rbp)
jge    136d <Place123_X+0x22d>
movss  -0x34(%rbp),%xmm0
movslq -0x64(%rbp),%rax
movss  -0x54(%rbp,%rax,4),%xmm2
movss  -0x38(%rbp),%xmm1
movslq -0x64(%rbp),%rax
mulss  -0x60(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1315 <Place123_X+0x1d5>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Place123_X>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r14
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x24(%rsp)
mov    %rdx,%r12
mov    %rsi,%rbx
mov    %rdi,%r15
mov    %rdx,%rdi
call   1030 <Dist@plt>
movss  %xmm0,0x1c(%rsp)
mov    %rbx,%rdi
mov    %r15,%rsi
call   1030 <Dist@plt>
movss  %xmm0,0x14(%rsp)
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe6c(%rip),%xmm2
movapd %xmm2,%xmm1
subsd  %xmm0,%xmm1
mulsd  0xe64(%rip),%xmm1
divsd  %xmm2,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0xc(%rsp)
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1050 <Ang@plt>
addsd  0xe45(%rip),%xmm0
mulsd  0xe35(%rip),%xmm0
divsd  0xe25(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
movss  0xc(%rsp),%xmm0
call   1060 <cos@plt>
movss  %xmm0,0x20(%rsp)
movss  0xc(%rsp),%xmm0
call   1040 <sin@plt>
movss  %xmm0,0xc(%rsp)
movss  0x10(%rsp),%xmm0
call   1060 <cos@plt>
mulss  0x14(%rsp),%xmm0
movss  %xmm0,0x18(%rsp)
movss  0x10(%rsp),%xmm0
call   1040 <sin@plt>
mulss  0x14(%rsp),%xmm0
movss  (%r12),%xmm8
movss  0x4(%r12),%xmm1
movss  (%rbx),%xmm4
movss  0x4(%rbx),%xmm5
movaps %xmm8,%xmm3
subss  %xmm4,%xmm3
movss  0x1c(%rsp),%xmm2
divss  %xmm2,%xmm3
movss  (%r15),%xmm6
movss  0x4(%r15),%xmm7
subss  %xmm4,%xmm6
movaps %xmm3,%xmm4
mulss  %xmm0,%xmm4
addss  %xmm6,%xmm4
movss  0x18(%rsp),%xmm10
divss  %xmm10,%xmm4
subss  %xmm5,%xmm1
divss  %xmm2,%xmm1
subss  %xmm5,%xmm7
movaps %xmm1,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm7,%xmm6
divss  %xmm10,%xmm6
movss  0x8(%r12),%xmm9
movss  0x8(%rbx),%xmm7
subss  %xmm7,%xmm9
divss  %xmm2,%xmm9
movss  0x8(%r15),%xmm2
subss  %xmm7,%xmm2
mulss  %xmm9,%xmm0
addss  %xmm2,%xmm0
movss  0x24(%rsp),%xmm2
movss  0x20(%rsp),%xmm7
mulss  %xmm2,%xmm7
movss  0xc(%rsp),%xmm5
mulss  %xmm2,%xmm5
mulss  %xmm5,%xmm4
mulss  %xmm7,%xmm3
addss  %xmm4,%xmm3
addss  %xmm8,%xmm3
movss  %xmm3,(%r14)
mulss  %xmm5,%xmm6
mulss  %xmm7,%xmm1
addss  %xmm6,%xmm1
addss  0x4(%r12),%xmm1
divss  %xmm10,%xmm0
movss  %xmm1,0x4(%r14)
mulss  %xmm0,%xmm5
movaps %xmm7,%xmm0
mulss  %xmm9,%xmm0
addss  %xmm5,%xmm0
addss  0x8(%r12),%xmm0
movss  %xmm0,0x8(%r14)
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @Place123_X(float* %0, float* %1, float* %2, float %3, float %4, float* %5) {
%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 float
%20 = alloca float
%21 = alloca [3 x float]
%22 = alloca [3 x float]
%23 = alloca i32
store float* %0, float** %7
store float* %1, float** %8
store float* %2, float** %9
store float %3, float* %10
store float %4, float* %11
store float* %5, float** %12
%24 = load float*, float** %9
%25 = load float*, float** %8
%26 = call float @Dist(float* %24, float* %25)
store float %26, float* %13
%27 = load float*, float** %8
%28 = load float*, float** %7
%29 = call float @Dist(float* %27, float* %28)
store float %29, float* %14
%30 = load float, float* %11
%31 = fpext float %30 to double
%32 = fsub double 1.800000e+02, %31
%33 = fmul double %32, 0x400921FB5A7ED197
%34 = fdiv double %33, 1.800000e+02
%35 = fptrunc double %34 to float
store float %35, float* %19
%36 = load float*, float** %7
%37 = load float*, float** %8
%38 = load float*, float** %9
%39 = call double @Ang(float* %36, float* %37, float* %38)
%40 = fsub double %39, 9.000000e+01
%41 = fmul double %40, 0x400921FB5A7ED197
%42 = fdiv double %41, 1.800000e+02
%43 = fptrunc double %42 to float
store float %43, float* %20
%44 = load float, float* %10
%45 = load float, float* %19
%46 = call float @cos(float %45)
%47 = fmul float %44, %46
store float %47, float* %15
%48 = load float, float* %10
%49 = load float, float* %19
%50 = call float @sin(float %49)
%51 = fmul float %48, %50
store float %51, float* %16
%52 = load float, float* %20
%53 = call float @cos(float %52)
%54 = load float, float* %14
%55 = fmul float %53, %54
store float %55, float* %18
%56 = load float, float* %20
%57 = call float @sin(float %56)
%58 = load float, float* %14
%59 = fmul float %57, %58
store float %59, float* %17
store i32 0, i32* %23
br label %60
60: ; preds = %104, %6
%61 = load i32, i32* %23
%62 = icmp slt i32 %61, 3
br i1 %62, label %63, label %107
63: ; preds = %60
%64 = load float*, float** %9
%65 = load i32, i32* %23
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = load float*, float** %8
%70 = load i32, i32* %23
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %69, i64 %71
%73 = load float, float* %72
%74 = fsub float %68, %73
%75 = load float, float* %13
%76 = fdiv float %74, %75
%77 = load i32, i32* %23
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 %78
store float %76, float* %79
%80 = load float*, float** %7
%81 = load i32, i32* %23
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
%84 = load float, float* %83
%85 = load float*, float** %8
%86 = load i32, i32* %23
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %85, i64 %87
%89 = load float, float* %88
%90 = fsub float %84, %89
%91 = load i32, i32* %23
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 %92
%94 = load float, float* %93
%95 = fneg float %94
%96 = load float, float* %17
%97 = fneg float %95
%98 = call float @llvm.fmuladd.f32(float %97, float %96, float %90)
%99 = load float, float* %18
%100 = fdiv float %98, %99
%101 = load i32, i32* %23
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 %102
store float %100, float* %103
br label %104
104: ; preds = %63
%105 = load i32, i32* %23
%106 = add nsw i32 %105, 1
store i32 %106, i32* %23
br label %60
107: ; preds = %60
store i32 0, i32* %23
br label %108
108: ; preds = %134, %107
%109 = load i32, i32* %23
%110 = icmp slt i32 %109, 3
br i1 %110, label %111, label %137
111: ; preds = %108
%112 = load float, float* %15
%113 = load i32, i32* %23
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 %114
%116 = load float, float* %115
%117 = load float, float* %16
%118 = load i32, i32* %23
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 %119
%121 = load float, float* %120
%122 = fmul float %117, %121
%123 = call float @llvm.fmuladd.f32(float %112, float %116, float %122)
%124 = load float*, float** %9
%125 = load i32, i32* %23
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %124, i64 %126
%128 = load float, float* %127
%129 = fadd float %123, %128
%130 = load float*, float** %12
%131 = load i32, i32* %23
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %130, i64 %132
store float %129, float* %133
br label %134
134: ; preds = %111
%135 = load i32, i32* %23
%136 = add nsw i32 %135, 1
store i32 %136, i32* %23
br label %108
137: ; preds = %108
ret void
}

LLVM IR (-O2):
define void @Place123_X(float* %0, float* %1, float* %2, float %3, float %4, float* nocapture writeonly %5) {
%7 = tail call float @Dist(float* %2, float* %1)
%8 = tail call float @Dist(float* %1, float* %0)
%9 = fpext float %4 to double
%10 = fsub double 1.800000e+02, %9
%11 = fmul double %10, 0x400921FB5A7ED197
%12 = fdiv double %11, 1.800000e+02
%13 = fptrunc double %12 to float
%14 = tail call double @Ang(float* %0, float* %1, float* %2)
%15 = fadd double %14, -9.000000e+01
%16 = fmul double %15, 0x400921FB5A7ED197
%17 = fdiv double %16, 1.800000e+02
%18 = fptrunc double %17 to float
%19 = tail call float @cos(float %13)
%20 = tail call float @sin(float %13)
%21 = tail call float @cos(float %18)
%22 = fmul float %8, %21
%23 = tail call float @sin(float %18)
%24 = fmul float %8, %23
%25 = load float, float* %2
%26 = load float, float* %1
%27 = fsub float %25, %26
%28 = fdiv float %27, %7
%29 = load float, float* %0
%30 = fsub float %29, %26
%31 = tail call float @llvm.fmuladd.f32(float %28, float %24, float %30)
%32 = fdiv float %31, %22
%33 = getelementptr inbounds float, float* %2, i64 1
%34 = load float, float* %33
%35 = getelementptr inbounds float, float* %1, i64 1
%36 = load float, float* %35
%37 = fsub float %34, %36
%38 = fdiv float %37, %7
%39 = getelementptr inbounds float, float* %0, i64 1
%40 = load float, float* %39
%41 = fsub float %40, %36
%42 = tail call float @llvm.fmuladd.f32(float %38, float %24, float %41)
%43 = fdiv float %42, %22
%44 = getelementptr inbounds float, float* %2, i64 2
%45 = load float, float* %44
%46 = getelementptr inbounds float, float* %1, i64 2
%47 = load float, float* %46
%48 = fsub float %45, %47
%49 = fdiv float %48, %7
%50 = getelementptr inbounds float, float* %0, i64 2
%51 = load float, float* %50
%52 = fsub float %51, %47
%53 = tail call float @llvm.fmuladd.f32(float %49, float %24, float %52)
%54 = fdiv float %53, %22
%55 = fmul float %19, %3
%56 = fmul float %20, %3
%57 = fmul float %56, %32
%58 = tail call float @llvm.fmuladd.f32(float %55, float %28, float %57)
%59 = fadd float %25, %58
store float %59, float* %5
%60 = fmul float %56, %43
%61 = tail call float @llvm.fmuladd.f32(float %55, float %38, float %60)
%62 = load float, float* %33
%63 = fadd float %62, %61
%64 = getelementptr inbounds float, float* %5, i64 1
store float %63, float* %64
%65 = fmul float %56, %54
%66 = tail call float @llvm.fmuladd.f32(float %55, float %49, float %65)
%67 = load float, float* %44
%68 = fadd float %67, %66
%69 = getelementptr inbounds float, float* %5, i64 2
store float %68, float* %69
ret void
}