void canny_get_thresholds(unsigned int histogram[], float *meanDark,
                          float *meanLight) {
  float minVariance = 999999.0f;
  float currMeanDark = 0.0f;
  float currMeanLight = 0.0f;
  float varianceDark = 0.0f;
  float varianceLight = 0.0f;
  float darkHits = 0.0f;
  float lightHits = 0.0f;
  float histogramSquaredMagnitude[256] = {0};
  int h = 0;
  int bucket = 0;
  float magnitudeSqr = 0.0f;
  float variance = 0.0f;
  float divisor = 0.0f;
  unsigned int i;
  int greyLevel;
  *meanDark = 0;
  *meanLight = 0;
  for (i = 0; i < 256; i++) {
    histogramSquaredMagnitude[i] = histogram[i] * histogram[i];
  }
  for (greyLevel = 255; greyLevel >= 0; greyLevel--) {
    darkHits = 0;
    lightHits = 0;
    currMeanDark = 0;
    currMeanLight = 0;
    varianceDark = 0;
    varianceLight = 0;
    bucket = (int)greyLevel;
    for (h = 255; h >= 0; h--) {
      magnitudeSqr = histogramSquaredMagnitude[h];
      if (h < bucket) {
        currMeanDark += h * magnitudeSqr;
        varianceDark += (bucket - h) * magnitudeSqr;
        darkHits += magnitudeSqr;
      } else {
        currMeanLight += h * magnitudeSqr;
        varianceLight += (bucket - h) * magnitudeSqr;
        lightHits += magnitudeSqr;
      }
    }
    if (darkHits > 0) {
      divisor = darkHits * 256;
      currMeanDark = (currMeanDark * 255) / divisor;
      varianceDark = (varianceDark * 255) / divisor;
    }
    if (lightHits > 0) {
      divisor = lightHits * 256;
      currMeanLight = (currMeanLight * 255) / divisor;
      varianceLight = (varianceLight * 255) / divisor;
    }
    variance = varianceDark + varianceLight;
    if (variance < 0) {
      variance = -variance;
    }
    if (variance < minVariance) {
      minVariance = variance;
      *meanDark = currMeanDark;
      *meanLight = currMeanLight;
    }
    if ((int)(variance * 1000) == (int)(minVariance * 1000)) {
      *meanLight = currMeanLight;
    }
  }
}


x86 assembly (clang, -O0):
<canny_get_thresholds>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  0xed1(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
lea    -0x440(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1030 <memset@plt>
movl   $0x0,-0x444(%rbp)
movl   $0x0,-0x448(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x450(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x454(%rbp)
ff
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x0,-0x458(%rbp)
cmpl   $0x100,-0x458(%rbp)
jae    1214 <canny_get_thresholds+0x104>
mov    -0x8(%rbp),%rax
mov    -0x458(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
imul   %eax,%eax
cvtsi2ss %rax,%xmm0
mov    -0x458(%rbp),%eax
movss  %xmm0,-0x440(%rbp,%rax,4)
ff ff
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    11cc <canny_get_thresholds+0xbc>
movl   $0xff,-0x45c(%rbp)
cmpl   $0x0,-0x45c(%rbp)
jl     1505 <canny_get_thresholds+0x3f5>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x45c(%rbp),%eax
mov    %eax,-0x448(%rbp)
movl   $0xff,-0x444(%rbp)
cmpl   $0x0,-0x444(%rbp)
jl     1382 <canny_get_thresholds+0x272>
movslq -0x444(%rbp),%rax
movss  -0x440(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x44c(%rbp)
ff
mov    -0x444(%rbp),%eax
cmp    -0x448(%rbp),%eax
jge    130b <canny_get_thresholds+0x1fb>
cvtsi2ssl -0x444(%rbp),%xmm0
ff
movss  -0x44c(%rbp),%xmm2
ff
movss  -0x20(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x448(%rbp),%eax
sub    -0x444(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  -0x44c(%rbp),%xmm2
ff
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x44c(%rbp),%xmm0
ff
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    1369 <canny_get_thresholds+0x259>
cvtsi2ssl -0x444(%rbp),%xmm0
ff
movss  -0x44c(%rbp),%xmm2
ff
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x448(%rbp),%eax
sub    -0x444(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  -0x44c(%rbp),%xmm2
ff
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x44c(%rbp),%xmm0
ff
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    136e <canny_get_thresholds+0x25e>
mov    -0x444(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x444(%rbp)
jmp    1271 <canny_get_thresholds+0x161>
movss  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    13dc <canny_get_thresholds+0x2cc>
movss  0xc6d(%rip),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x454(%rbp)
ff
movss  0xc54(%rip),%xmm0
mulss  -0x20(%rbp),%xmm0
divss  -0x454(%rbp),%xmm0
ff
movss  %xmm0,-0x20(%rbp)
movss  0xc3a(%rip),%xmm0
mulss  -0x28(%rbp),%xmm0
divss  -0x454(%rbp),%xmm0
ff
movss  %xmm0,-0x28(%rbp)
movss  -0x34(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1436 <canny_get_thresholds+0x326>
movss  0xc13(%rip),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x454(%rbp)
ff
movss  0xbfa(%rip),%xmm0
mulss  -0x24(%rbp),%xmm0
divss  -0x454(%rbp),%xmm0
ff
movss  %xmm0,-0x24(%rbp)
movss  0xbe0(%rip),%xmm0
mulss  -0x2c(%rbp),%xmm0
divss  -0x454(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
movss  -0x28(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x450(%rbp)
ff
xorps  %xmm0,%xmm0
ucomiss -0x450(%rbp),%xmm0
jbe    1475 <canny_get_thresholds+0x365>
movss  -0x450(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x450(%rbp)
ff
movss  -0x450(%rbp),%xmm1
ff
movss  -0x1c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    14b2 <canny_get_thresholds+0x3a2>
movss  -0x450(%rbp),%xmm0
ff
movss  %xmm0,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  0xb52(%rip),%xmm0
mulss  -0x450(%rbp),%xmm0
ff
cvttss2si %xmm0,%eax
movss  0xb3e(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
cvttss2si %xmm0,%ecx
cmp    %ecx,%eax
jne    14ec <canny_get_thresholds+0x3dc>
movss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
jmp    14f1 <canny_get_thresholds+0x3e1>
mov    -0x45c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x45c(%rbp)
jmp    121e <canny_get_thresholds+0x10e>
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<canny_get_thresholds>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x408,%rsp
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%r12
mov    %rsp,%rdi
xor    %ebx,%ebx
mov    $0x400,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,(%r14)
movl   $0x0,(%r15)
movdqa 0xeb2(%rip),%xmm0
movdqa 0xeba(%rip),%xmm1
movdqa 0xec2(%rip),%xmm2
movaps 0xecb(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%r12,%rbx,4),%xmm4
movdqu 0x10(%r12,%rbx,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm4,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm6,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm4
pshufd $0xf5,%xmm5,%xmm6
pmuludq %xmm5,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pmuludq %xmm6,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm5
movdqa %xmm4,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm4
por    %xmm2,%xmm4
subps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movdqa %xmm5,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm5
por    %xmm2,%xmm5
subps  %xmm3,%xmm5
addps  %xmm6,%xmm5
movaps %xmm4,(%rsp,%rbx,4)
movaps %xmm5,0x10(%rsp,%rbx,4)
movdqu 0x20(%r12,%rbx,4),%xmm4
movdqu 0x30(%r12,%rbx,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm4,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm6,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm4
pshufd $0xf5,%xmm5,%xmm6
pmuludq %xmm5,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pmuludq %xmm6,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm5
movdqa %xmm4,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm4
por    %xmm2,%xmm4
subps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movdqa %xmm5,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm5
por    %xmm2,%xmm5
subps  %xmm3,%xmm5
addps  %xmm6,%xmm5
movaps %xmm4,0x20(%rsp,%rbx,4)
movaps %xmm5,0x30(%rsp,%rbx,4)
add    $0x10,%rbx
cmp    $0x100,%rbx
jne    1170 <canny_get_thresholds+0x60>
movss  0xde1(%rip),%xmm3
mov    $0xff,%eax
xor    %ecx,%ecx
xorps  %xmm12,%xmm12
movss  0xdd1(%rip),%xmm8
movaps 0xd95(%rip),%xmm9
movaps 0xd9d(%rip),%xmm10
movaps 0xda5(%rip),%xmm11
jmp    12cd <canny_get_thresholds+0x1bd>
nopl   (%rax)
add    $0xffffffff,%ecx
sub    $0x1,%rax
jb     13cc <canny_get_thresholds+0x2bc>
xorps  %xmm6,%xmm6
mov    %ecx,%edx
mov    $0xff,%esi
pxor   %xmm1,%xmm1
pxor   %xmm2,%xmm2
xorps  %xmm7,%xmm7
jmp    1307 <canny_get_thresholds+0x1f7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addss  %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm4
mulps  %xmm5,%xmm4
addps  %xmm4,%xmm6
add    $0x1,%edx
add    $0xffffffffffffffff,%rsi
jae    1340 <canny_get_thresholds+0x230>
movss  (%rsp,%rsi,4),%xmm4
xorps  %xmm5,%xmm5
cvtsi2ss %esi,%xmm5
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
unpcklps %xmm0,%xmm5
cmp    %rsi,%rax
jbe    12f0 <canny_get_thresholds+0x1e0>
addss  %xmm4,%xmm2
shufps $0x0,%xmm4,%xmm4
mulps  %xmm5,%xmm4
addps  %xmm4,%xmm7
jmp    12fe <canny_get_thresholds+0x1ee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomiss %xmm12,%xmm2
jbe    1356 <canny_get_thresholds+0x246>
mulss  %xmm8,%xmm2
mulps  %xmm9,%xmm7
shufps $0x0,%xmm2,%xmm2
divps  %xmm2,%xmm7
ucomiss %xmm12,%xmm1
jbe    136c <canny_get_thresholds+0x25c>
mulss  %xmm8,%xmm1
mulps  %xmm9,%xmm6
shufps $0x0,%xmm1,%xmm1
divps  %xmm1,%xmm6
movaps %xmm7,%xmm0
addps  %xmm6,%xmm0
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,%xmm2
xorps  %xmm10,%xmm2
movaps %xmm0,%xmm1
cmpltss %xmm12,%xmm1
andps  %xmm1,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
ucomiss %xmm1,%xmm3
jbe    13a1 <canny_get_thresholds+0x291>
movss  %xmm7,(%r14)
movss  %xmm6,(%r15)
movaps %xmm1,%xmm3
unpcklps %xmm3,%xmm1
mulps  %xmm11,%xmm1
cvttps2dq %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
pcmpeqd %xmm0,%xmm1
movd   %xmm1,%edx
test   $0x1,%dl
je     12c0 <canny_get_thresholds+0x1b0>
movss  %xmm6,(%r15)
jmp    12c0 <canny_get_thresholds+0x1b0>
add    $0x408,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @canny_get_thresholds(i32* %0, float* %1, float* %2) {
%4 = alloca i32*
%5 = alloca float*
%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 [256 x float]
%15 = alloca i32
%16 = alloca i32
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca i32
%21 = alloca i32
store i32* %0, i32** %4
store float* %1, float** %5
store float* %2, float** %6
store float 9.999990e+05, float* %7
store float 0.000000e+00, float* %8
store float 0.000000e+00, float* %9
store float 0.000000e+00, float* %10
store float 0.000000e+00, float* %11
store float 0.000000e+00, float* %12
store float 0.000000e+00, float* %13
%22 = bitcast [256 x float]* %14 to i8*
store i32 0, i32* %15
store i32 0, i32* %16
store float 0.000000e+00, float* %17
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %19
%23 = load float*, float** %5
store float 0.000000e+00, float* %23
%24 = load float*, float** %6
store float 0.000000e+00, float* %24
store i32 0, i32* %20
br label %25
25: ; preds = %44, %3
%26 = load i32, i32* %20
%27 = icmp ult i32 %26, 256
br i1 %27, label %28, label %47
28: ; preds = %25
%29 = load i32*, i32** %4
%30 = load i32, i32* %20
%31 = zext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
%33 = load i32, i32* %32
%34 = load i32*, i32** %4
%35 = load i32, i32* %20
%36 = zext i32 %35 to i64
%37 = getelementptr inbounds i32, i32* %34, i64 %36
%38 = load i32, i32* %37
%39 = mul i32 %33, %38
%40 = uitofp i32 %39 to float
%41 = load i32, i32* %20
%42 = zext i32 %41 to i64
%43 = getelementptr inbounds [256 x float], [256 x float]* %14, i64 0, i64 %42
store float %40, float* %43
br label %44
44: ; preds = %28
%45 = load i32, i32* %20
%46 = add i32 %45, 1
store i32 %46, i32* %20
br label %25
47: ; preds = %25
store i32 255, i32* %21
br label %48
48: ; preds = %159, %47
%49 = load i32, i32* %21
%50 = icmp sge i32 %49, 0
br i1 %50, label %51, label %162
51: ; preds = %48
store float 0.000000e+00, float* %12
store float 0.000000e+00, float* %13
store float 0.000000e+00, float* %8
store float 0.000000e+00, float* %9
store float 0.000000e+00, float* %10
store float 0.000000e+00, float* %11
%52 = load i32, i32* %21
store i32 %52, i32* %16
store i32 255, i32* %15
br label %53
53: ; preds = %97, %51
%54 = load i32, i32* %15
%55 = icmp sge i32 %54, 0
br i1 %55, label %56, label %100
56: ; preds = %53
%57 = load i32, i32* %15
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [256 x float], [256 x float]* %14, i64 0, i64 %58
%60 = load float, float* %59
store float %60, float* %17
%61 = load i32, i32* %15
%62 = load i32, i32* %16
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %80
64: ; preds = %56
%65 = load i32, i32* %15
%66 = sitofp i32 %65 to float
%67 = load float, float* %17
%68 = load float, float* %8
%69 = call float @llvm.fmuladd.f32(float %66, float %67, float %68)
store float %69, float* %8
%70 = load i32, i32* %16
%71 = load i32, i32* %15
%72 = sub nsw i32 %70, %71
%73 = sitofp i32 %72 to float
%74 = load float, float* %17
%75 = load float, float* %10
%76 = call float @llvm.fmuladd.f32(float %73, float %74, float %75)
store float %76, float* %10
%77 = load float, float* %17
%78 = load float, float* %12
%79 = fadd float %78, %77
store float %79, float* %12
br label %96
80: ; preds = %56
%81 = load i32, i32* %15
%82 = sitofp i32 %81 to float
%83 = load float, float* %17
%84 = load float, float* %9
%85 = call float @llvm.fmuladd.f32(float %82, float %83, float %84)
store float %85, float* %9
%86 = load i32, i32* %16
%87 = load i32, i32* %15
%88 = sub nsw i32 %86, %87
%89 = sitofp i32 %88 to float
%90 = load float, float* %17
%91 = load float, float* %11
%92 = call float @llvm.fmuladd.f32(float %89, float %90, float %91)
store float %92, float* %11
%93 = load float, float* %17
%94 = load float, float* %13
%95 = fadd float %94, %93
store float %95, float* %13
br label %96
96: ; preds = %80, %64
br label %97
97: ; preds = %96
%98 = load i32, i32* %15
%99 = add nsw i32 %98, -1
store i32 %99, i32* %15
br label %53
100: ; preds = %53
%101 = load float, float* %12
%102 = fcmp ogt float %101, 0.000000e+00
br i1 %102, label %103, label %114
103: ; preds = %100
%104 = load float, float* %12
%105 = fmul float %104, 2.560000e+02
store float %105, float* %19
%106 = load float, float* %8
%107 = fmul float %106, 2.550000e+02
%108 = load float, float* %19
%109 = fdiv float %107, %108
store float %109, float* %8
%110 = load float, float* %10
%111 = fmul float %110, 2.550000e+02
%112 = load float, float* %19
%113 = fdiv float %111, %112
store float %113, float* %10
br label %114
114: ; preds = %103, %100
%115 = load float, float* %13
%116 = fcmp ogt float %115, 0.000000e+00
br i1 %116, label %117, label %128
117: ; preds = %114
%118 = load float, float* %13
%119 = fmul float %118, 2.560000e+02
store float %119, float* %19
%120 = load float, float* %9
%121 = fmul float %120, 2.550000e+02
%122 = load float, float* %19
%123 = fdiv float %121, %122
store float %123, float* %9
%124 = load float, float* %11
%125 = fmul float %124, 2.550000e+02
%126 = load float, float* %19
%127 = fdiv float %125, %126
store float %127, float* %11
br label %128
128: ; preds = %117, %114
%129 = load float, float* %10
%130 = load float, float* %11
%131 = fadd float %129, %130
store float %131, float* %18
%132 = load float, float* %18
%133 = fcmp olt float %132, 0.000000e+00
br i1 %133, label %134, label %137
134: ; preds = %128
%135 = load float, float* %18
%136 = fneg float %135
store float %136, float* %18
br label %137
137: ; preds = %134, %128
%138 = load float, float* %18
%139 = load float, float* %7
%140 = fcmp olt float %138, %139
br i1 %140, label %141, label %147
141: ; preds = %137
%142 = load float, float* %18
store float %142, float* %7
%143 = load float, float* %8
%144 = load float*, float** %5
store float %143, float* %144
%145 = load float, float* %9
%146 = load float*, float** %6
store float %145, float* %146
br label %147
147: ; preds = %141, %137
%148 = load float, float* %18
%149 = fmul float %148, 1.000000e+03
%150 = fptosi float %149 to i32
%151 = load float, float* %7
%152 = fmul float %151, 1.000000e+03
%153 = fptosi float %152 to i32
%154 = icmp eq i32 %150, %153
br i1 %154, label %155, label %158
155: ; preds = %147
%156 = load float, float* %9
%157 = load float*, float** %6
store float %156, float* %157
br label %158
158: ; preds = %155, %147
br label %159
159: ; preds = %158
%160 = load i32, i32* %21
%161 = add nsw i32 %160, -1
store i32 %161, i32* %21
br label %48
162: ; preds = %48
ret void
}

LLVM IR (-O2):
define void @canny_get_thresholds(i32* nocapture %0, float* nocapture writeonly %1, float* nocapture writeonly %2) {
%4 = alloca [256 x float]
%5 = bitcast [256 x float]* %4 to i8*
store float 0.000000e+00, float* %1
store float 0.000000e+00, float* %2
br label %6
6: ; preds = %6, %3
%7 = phi i64 [ 0, %3 ], [ %37, %6 ]
%8 = getelementptr inbounds i32, i32* %0, i64 %7
%9 = bitcast i32* %8 to <4 x i32>*
%10 = load <4 x i32>, <4 x i32>* %9
%11 = getelementptr inbounds i32, i32* %8, i64 4
%12 = bitcast i32* %11 to <4 x i32>*
%13 = load <4 x i32>, <4 x i32>* %12
%14 = mul <4 x i32> %10, %10
%15 = mul <4 x i32> %13, %13
%16 = uitofp <4 x i32> %14 to <4 x float>
%17 = uitofp <4 x i32> %15 to <4 x float>
%18 = getelementptr inbounds [256 x float], [256 x float]* %4, i64 0, i64 %7
%19 = bitcast float* %18 to <4 x float>*
store <4 x float> %16, <4 x float>* %19
%20 = getelementptr inbounds float, float* %18, i64 4
%21 = bitcast float* %20 to <4 x float>*
store <4 x float> %17, <4 x float>* %21
%22 = or i64 %7, 8
%23 = getelementptr inbounds i32, i32* %0, i64 %22
%24 = bitcast i32* %23 to <4 x i32>*
%25 = load <4 x i32>, <4 x i32>* %24
%26 = getelementptr inbounds i32, i32* %23, i64 4
%27 = bitcast i32* %26 to <4 x i32>*
%28 = load <4 x i32>, <4 x i32>* %27
%29 = mul <4 x i32> %25, %25
%30 = mul <4 x i32> %28, %28
%31 = uitofp <4 x i32> %29 to <4 x float>
%32 = uitofp <4 x i32> %30 to <4 x float>
%33 = getelementptr inbounds [256 x float], [256 x float]* %4, i64 0, i64 %22
%34 = bitcast float* %33 to <4 x float>*
store <4 x float> %31, <4 x float>* %34
%35 = getelementptr inbounds float, float* %33, i64 4
%36 = bitcast float* %35 to <4 x float>*
store <4 x float> %32, <4 x float>* %36
%37 = add nuw nsw i64 %7, 16
%38 = icmp eq i64 %37, 256
br i1 %38, label %39, label %6
39: ; preds = %6, %119
%40 = phi i64 [ %120, %119 ], [ 255, %6 ]
%41 = phi float [ %109, %119 ], [ 9.999990e+05, %6 ]
br label %42
42: ; preds = %39, %73
%43 = phi i64 [ 255, %39 ], [ %78, %73 ]
%44 = phi float [ 0.000000e+00, %39 ], [ %75, %73 ]
%45 = phi float [ 0.000000e+00, %39 ], [ %74, %73 ]
%46 = phi <2 x float> [ zeroinitializer, %39 ], [ %76, %73 ]
%47 = phi <2 x float> [ zeroinitializer, %39 ], [ %77, %73 ]
%48 = getelementptr inbounds [256 x float], [256 x float]* %4, i64 0, i64 %43
%49 = load float, float* %48
%50 = icmp ugt i64 %40, %43
%51 = trunc i64 %43 to i32
%52 = sitofp i32 %51 to float
br i1 %50, label %53, label %63
53: ; preds = %42
%54 = sub nsw i64 %40, %43
%55 = trunc i64 %54 to i32
%56 = sitofp i32 %55 to float
%57 = insertelement <2 x float> poison, float %52, i64 0
%58 = insertelement <2 x float> %57, float %56, i64 1
%59 = insertelement <2 x float> poison, float %49, i64 0
%60 = shufflevector <2 x float> %59, <2 x float> poison, <2 x i32> zeroinitializer
%61 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %58, <2 x float> %60, <2 x float> %47)
%62 = fadd float %45, %49
br label %73
63: ; preds = %42
%64 = sub nsw i64 %40, %43
%65 = trunc i64 %64 to i32
%66 = sitofp i32 %65 to float
%67 = insertelement <2 x float> poison, float %52, i64 0
%68 = insertelement <2 x float> %67, float %66, i64 1
%69 = insertelement <2 x float> poison, float %49, i64 0
%70 = shufflevector <2 x float> %69, <2 x float> poison, <2 x i32> zeroinitializer
%71 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %68, <2 x float> %70, <2 x float> %46)
%72 = fadd float %44, %49
br label %73
73: ; preds = %53, %63
%74 = phi float [ %62, %53 ], [ %45, %63 ]
%75 = phi float [ %44, %53 ], [ %72, %63 ]
%76 = phi <2 x float> [ %46, %53 ], [ %71, %63 ]
%77 = phi <2 x float> [ %61, %53 ], [ %47, %63 ]
%78 = add nsw i64 %43, -1
%79 = icmp eq i64 %43, 0
br i1 %79, label %80, label %42
80: ; preds = %73
%81 = fcmp ogt float %74, 0.000000e+00
br i1 %81, label %82, label %88
82: ; preds = %80
%83 = fmul float %74, 2.560000e+02
%84 = fmul <2 x float> %77, <float 2.550000e+02, float 2.550000e+02>
%85 = insertelement <2 x float> poison, float %83, i64 0
%86 = shufflevector <2 x float> %85, <2 x float> poison, <2 x i32> zeroinitializer
%87 = fdiv <2 x float> %84, %86
br label %88
88: ; preds = %82, %80
%89 = phi <2 x float> [ %87, %82 ], [ %77, %80 ]
%90 = fcmp ogt float %75, 0.000000e+00
br i1 %90, label %91, label %97
91: ; preds = %88
%92 = fmul float %75, 2.560000e+02
%93 = fmul <2 x float> %76, <float 2.550000e+02, float 2.550000e+02>
%94 = insertelement <2 x float> poison, float %92, i64 0
%95 = shufflevector <2 x float> %94, <2 x float> poison, <2 x i32> zeroinitializer
%96 = fdiv <2 x float> %93, %95
br label %97
97: ; preds = %91, %88
%98 = phi <2 x float> [ %96, %91 ], [ %76, %88 ]
%99 = fadd <2 x float> %89, %98
%100 = extractelement <2 x float> %99, i64 1
%101 = fcmp olt float %100, 0.000000e+00
%102 = fneg float %100
%103 = select i1 %101, float %102, float %100
%104 = fcmp olt float %103, %41
br i1 %104, label %105, label %108
105: ; preds = %97
%106 = extractelement <2 x float> %89, i64 0
store float %106, float* %1
%107 = extractelement <2 x float> %98, i64 0
store float %107, float* %2
br label %108
108: ; preds = %105, %97
%109 = phi float [ %103, %105 ], [ %41, %97 ]
%110 = insertelement <2 x float> poison, float %103, i64 0
%111 = insertelement <2 x float> %110, float %109, i64 1
%112 = fmul <2 x float> %111, <float 1.000000e+03, float 1.000000e+03>
%113 = fptosi <2 x float> %112 to <2 x i32>
%114 = shufflevector <2 x i32> %113, <2 x i32> poison, <2 x i32> <i32 1, i32 undef>
%115 = icmp eq <2 x i32> %114, %113
%116 = extractelement <2 x i1> %115, i64 0
br i1 %116, label %117, label %119
117: ; preds = %108
%118 = extractelement <2 x float> %98, i64 0
store float %118, float* %2
br label %119
119: ; preds = %108, %117
%120 = add nsw i64 %40, -1
%121 = icmp eq i64 %40, 0
br i1 %121, label %122, label %39
122: ; preds = %119
ret void
}