#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 sqrtf(double);
float find_dist(int r1, int g1, int b1, int x1, int y1, int r2, int g2, int b2,
                int x2, int y2, float max_space_dist, float dist_weight) {
  float max_color_dist = sqrtf(255 * 255 * 3);
  int dr = r1 - r2;
  int dg = g1 - g2;
  int db = b1 - b2;
  float color_dist = sqrtf(dr * dr + dg * dg + db * db) / max_color_dist;
  int dx = x1 - x2;
  int dy = y1 - y2;
  float space_dist = sqrtf(dx * dx + dy * dy) / max_space_dist;
  return sqrtf((1.0 - dist_weight) * color_dist * color_dist +
               dist_weight * space_dist * space_dist);
}


x86 assembly (clang, -O0):
<find_dist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9d,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
movsd  0xebe(%rip),%xmm0
call   1030 <sqrtf@plt>
movss  %xmm0,-0x24(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
sub    0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
sub    0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
mov    -0x30(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   1030 <sqrtf@plt>
divss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%eax
sub    0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm0
call   1030 <sqrtf@plt>
divss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe1f(%rip),%xmm0
subsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrtf@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_dist>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movss  %xmm1,0x14(%rsp)
movss  %xmm0,0x10(%rsp)
mov    %r9d,%r14d
mov    %r8d,%r12d
mov    %ecx,%r15d
mov    %edx,%ebp
mov    %esi,%ebx
mov    %edi,%r13d
movsd  0xebe(%rip),%xmm0
call   1030 <sqrtf@plt>
movss  %xmm0,0xc(%rsp)
sub    0x50(%rsp),%ebx
sub    0x58(%rsp),%ebp
sub    %r14d,%r13d
imul   %r13d,%r13d
imul   %ebx,%ebx
add    %r13d,%ebx
imul   %ebp,%ebp
add    %ebx,%ebp
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
call   1030 <sqrtf@plt>
sub    0x60(%rsp),%r15d
divss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
sub    0x68(%rsp),%r12d
imul   %r15d,%r15d
imul   %r12d,%r12d
add    %r15d,%r12d
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
call   1030 <sqrtf@plt>
divss  0x10(%rsp),%xmm0
movss  0x14(%rsp),%xmm3
cvtss2sd %xmm3,%xmm2
movsd  0xe4f(%rip),%xmm1
subsd  %xmm2,%xmm1
movss  0xc(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
mulss  %xmm0,%xmm3
mulss  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <sqrtf@plt>

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

LLVM IR (-O2):
define float @find_dist(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, float %10, float %11) {
%13 = tail call float @sqrtf(double 1.950750e+05)
%14 = sub nsw i32 %0, %5
%15 = sub nsw i32 %1, %6
%16 = sub nsw i32 %2, %7
%17 = mul nsw i32 %14, %14
%18 = mul nsw i32 %15, %15
%19 = add nuw nsw i32 %18, %17
%20 = mul nsw i32 %16, %16
%21 = add nuw nsw i32 %19, %20
%22 = sitofp i32 %21 to double
%23 = tail call float @sqrtf(double %22)
%24 = fdiv float %23, %13
%25 = sub nsw i32 %3, %8
%26 = sub nsw i32 %4, %9
%27 = mul nsw i32 %25, %25
%28 = mul nsw i32 %26, %26
%29 = add nuw nsw i32 %28, %27
%30 = sitofp i32 %29 to double
%31 = tail call float @sqrtf(double %30)
%32 = fdiv float %31, %10
%33 = fpext float %11 to double
%34 = fsub double 1.000000e+00, %33
%35 = fpext float %24 to double
%36 = fmul double %34, %35
%37 = fmul float %32, %11
%38 = fmul float %32, %37
%39 = fpext float %38 to double
%40 = tail call double @llvm.fmuladd.f64(double %36, double %35, double %39)
%41 = tail call float @sqrtf(double %40)
ret float %41
}