#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 pow(float, double);
void campo(float *b[3], float pos[3], float rt) {
  float b0;
  float cste;
  b0 = 3 * pow(10.0, -5.0);
  cste = -b0 * pow(rt, 3.0) /
         pow(pow(pos[0], 2.0) + pow(pos[1], 2.0) + pow(pos[2], 2.0), 5.0 / 2.0);
  *b[0] = cste * 3.0 * pos[0] * pos[2];
  *b[1] = cste * 3.0 * pos[1] * pos[2];
  *b[2] = cste * (2.0 * pow(pos[2], 2.0) - pow(pos[0], 2.0) - pow(pos[1], 2.0));
}


x86 assembly (clang, -O0):
<campo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  0xef3(%rip),%xmm0
movsd  0xee3(%rip),%xmm1
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xec3(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  -0x14(%rbp),%xmm0
movsd  0xe8e(%rip),%xmm1
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movsd  0xe60(%rip),%xmm1
call   1030 <pow@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movsd  0xe45(%rip),%xmm1
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movsd  0xe1e(%rip),%xmm1
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  0xe11(%rip),%xmm1
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdde(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd99(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movsd  0xd3c(%rip),%xmm1
call   1030 <pow@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movsd  0xd22(%rip),%xmm1
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movsd  0xce0(%rip),%xmm1
call   1030 <pow@plt>
movsd  -0x30(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x28(%rbp),%xmm0
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<campo>:
push   %r14
push   %rbx
sub    $0x18,%rsp
movss  %xmm0,0x10(%rsp)
mov    %rsi,%rbx
mov    %rdi,%r14
movss  0xed5(%rip),%xmm0
movsd  0xed5(%rip),%xmm1
call   1030 <pow@plt>
movsd  0xed0(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
xorps  0xee1(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
movss  0x10(%rsp),%xmm0
call   1030 <pow@plt>
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movss  (%rbx),%xmm0
movsd  0xe9c(%rip),%xmm1
call   1030 <pow@plt>
movsd  %xmm0,0x8(%rsp)
movss  0x4(%rbx),%xmm0
movsd  0xe84(%rip),%xmm1
call   1030 <pow@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movss  0x8(%rbx),%xmm0
movsd  0xe66(%rip),%xmm1
call   1030 <pow@plt>
addsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  0xe57(%rip),%xmm1
call   1030 <pow@plt>
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0xe1f(%rip),%xmm2
mulsd  %xmm0,%xmm2
movss  (%rbx),%xmm0
movss  0x8(%rbx),%xmm1
cvtss2sd %xmm0,%xmm0
mulsd  %xmm2,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    (%r14),%rax
movss  %xmm0,(%rax)
movss  0x4(%rbx),%xmm0
movss  0x8(%rbx),%xmm1
cvtss2sd %xmm0,%xmm0
mulsd  %xmm2,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    0x8(%r14),%rax
movss  %xmm0,(%rax)
movss  0x8(%rbx),%xmm0
movsd  0xdc6(%rip),%xmm1
call   1030 <pow@plt>
movsd  %xmm0,0x10(%rsp)
movss  (%rbx),%xmm0
movsd  0xdaf(%rip),%xmm1
call   1030 <pow@plt>
movsd  0x10(%rsp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movss  0x4(%rbx),%xmm0
movsd  0xd89(%rip),%xmm1
call   1030 <pow@plt>
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    0x10(%r14),%rax
movss  %xmm0,(%rax)
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @campo(float** %0, float* %1, float %2) {
%4 = alloca float**
%5 = alloca float*
%6 = alloca float
%7 = alloca float
%8 = alloca float
store float** %0, float*** %4
store float* %1, float** %5
store float %2, float* %6
%9 = call double @pow(float 1.000000e+01, double -5.000000e+00)
%10 = fmul double 3.000000e+00, %9
%11 = fptrunc double %10 to float
store float %11, float* %7
%12 = load float, float* %7
%13 = fneg float %12
%14 = fpext float %13 to double
%15 = load float, float* %6
%16 = call double @pow(float %15, double 3.000000e+00)
%17 = fmul double %14, %16
%18 = load float*, float** %5
%19 = getelementptr inbounds float, float* %18, i64 0
%20 = load float, float* %19
%21 = call double @pow(float %20, double 2.000000e+00)
%22 = load float*, float** %5
%23 = getelementptr inbounds float, float* %22, i64 1
%24 = load float, float* %23
%25 = call double @pow(float %24, double 2.000000e+00)
%26 = fadd double %21, %25
%27 = load float*, float** %5
%28 = getelementptr inbounds float, float* %27, i64 2
%29 = load float, float* %28
%30 = call double @pow(float %29, double 2.000000e+00)
%31 = fadd double %26, %30
%32 = fptrunc double %31 to float
%33 = call double @pow(float %32, double 2.500000e+00)
%34 = fdiv double %17, %33
%35 = fptrunc double %34 to float
store float %35, float* %8
%36 = load float, float* %8
%37 = fpext float %36 to double
%38 = fmul double %37, 3.000000e+00
%39 = load float*, float** %5
%40 = getelementptr inbounds float, float* %39, i64 0
%41 = load float, float* %40
%42 = fpext float %41 to double
%43 = fmul double %38, %42
%44 = load float*, float** %5
%45 = getelementptr inbounds float, float* %44, i64 2
%46 = load float, float* %45
%47 = fpext float %46 to double
%48 = fmul double %43, %47
%49 = fptrunc double %48 to float
%50 = load float**, float*** %4
%51 = getelementptr inbounds float*, float** %50, i64 0
%52 = load float*, float** %51
store float %49, float* %52
%53 = load float, float* %8
%54 = fpext float %53 to double
%55 = fmul double %54, 3.000000e+00
%56 = load float*, float** %5
%57 = getelementptr inbounds float, float* %56, i64 1
%58 = load float, float* %57
%59 = fpext float %58 to double
%60 = fmul double %55, %59
%61 = load float*, float** %5
%62 = getelementptr inbounds float, float* %61, i64 2
%63 = load float, float* %62
%64 = fpext float %63 to double
%65 = fmul double %60, %64
%66 = fptrunc double %65 to float
%67 = load float**, float*** %4
%68 = getelementptr inbounds float*, float** %67, i64 1
%69 = load float*, float** %68
store float %66, float* %69
%70 = load float, float* %8
%71 = fpext float %70 to double
%72 = load float*, float** %5
%73 = getelementptr inbounds float, float* %72, i64 2
%74 = load float, float* %73
%75 = call double @pow(float %74, double 2.000000e+00)
%76 = load float*, float** %5
%77 = getelementptr inbounds float, float* %76, i64 0
%78 = load float, float* %77
%79 = call double @pow(float %78, double 2.000000e+00)
%80 = fneg double %79
%81 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %75, double %80)
%82 = load float*, float** %5
%83 = getelementptr inbounds float, float* %82, i64 1
%84 = load float, float* %83
%85 = call double @pow(float %84, double 2.000000e+00)
%86 = fsub double %81, %85
%87 = fmul double %71, %86
%88 = fptrunc double %87 to float
%89 = load float**, float*** %4
%90 = getelementptr inbounds float*, float** %89, i64 2
%91 = load float*, float** %90
store float %88, float* %91
ret void
}

LLVM IR (-O2):
define void @campo(float** nocapture %0, float* nocapture %1, float %2) {
%4 = tail call double @pow(float 1.000000e+01, double -5.000000e+00)
%5 = fmul double %4, 3.000000e+00
%6 = fptrunc double %5 to float
%7 = fneg float %6
%8 = fpext float %7 to double
%9 = tail call double @pow(float %2, double 3.000000e+00)
%10 = fmul double %9, %8
%11 = load float, float* %1
%12 = tail call double @pow(float %11, double 2.000000e+00)
%13 = getelementptr inbounds float, float* %1, i64 1
%14 = load float, float* %13
%15 = tail call double @pow(float %14, double 2.000000e+00)
%16 = fadd double %12, %15
%17 = getelementptr inbounds float, float* %1, i64 2
%18 = load float, float* %17
%19 = tail call double @pow(float %18, double 2.000000e+00)
%20 = fadd double %16, %19
%21 = fptrunc double %20 to float
%22 = tail call double @pow(float %21, double 2.500000e+00)
%23 = fdiv double %10, %22
%24 = fptrunc double %23 to float
%25 = fpext float %24 to double
%26 = fmul double %25, 3.000000e+00
%27 = load float, float* %1
%28 = fpext float %27 to double
%29 = fmul double %26, %28
%30 = load float, float* %17
%31 = fpext float %30 to double
%32 = fmul double %29, %31
%33 = fptrunc double %32 to float
%34 = load float*, float** %0
store float %33, float* %34
%35 = load float, float* %13
%36 = fpext float %35 to double
%37 = fmul double %26, %36
%38 = load float, float* %17
%39 = fpext float %38 to double
%40 = fmul double %37, %39
%41 = fptrunc double %40 to float
%42 = getelementptr inbounds float*, float** %0, i64 1
%43 = load float*, float** %42
store float %41, float* %43
%44 = load float, float* %17
%45 = tail call double @pow(float %44, double 2.000000e+00)
%46 = load float, float* %1
%47 = tail call double @pow(float %46, double 2.000000e+00)
%48 = fneg double %47
%49 = tail call double @llvm.fmuladd.f64(double %45, double 2.000000e+00, double %48)
%50 = load float, float* %13
%51 = tail call double @pow(float %50, double 2.000000e+00)
%52 = fsub double %49, %51
%53 = fmul double %52, %25
%54 = fptrunc double %53 to float
%55 = getelementptr inbounds float*, float** %0, i64 2
%56 = load float*, float** %55
store float %54, float* %56
ret void
}