#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 */
scalar_t__ expf(int);
int roundfloat(int);
int sqrtf(int);
void computeIDSI(const unsigned char img[480][640], int x, int y,
                 float idsi[10][10]) {
  int d, i;
  const float k_dist = -1.f / (2.f * 0.4 * 0.4);
  const float k_inten = -1.f / (2.f * 20 * 20);
  for (d = 0; d < 10; d++) {
    for (i = 0; i < 10; i++) {
      idsi[d][i] = 0.f;
    }
  }
  unsigned char pixel = img[y][x];
  int dx, dy;
  int dxmin = (x < 20) ? -x : -20;
  int dxmax = (x + 20 >= 640) ? 640 - 1 - x : 20;
  int dymin = (y < 20) ? -y : -20;
  int dymax = (y + 20 >= 480) ? 480 - 1 - y : 20;
  for (dy = dymin; dy <= dymax; dy++) {
    for (dx = dxmin; dx <= dxmax; dx++) {
      i = img[y + dy][x + dx];
      int di_sq = i - pixel;
      di_sq *= di_sq;
      int dd_sq = dx * dx + dy * dy;
      i = roundfloat((float)i * ((10 - 1) / 255.f));
      d = roundfloat(sqrtf(dd_sq) * ((10 - 1) / (20 * 1.4142135623730951f)));
      idsi[d][i] += expf(dd_sq * k_dist + di_sq * k_inten);
    }
  }
  float min = 20 * 20, max = 0.f;
  for (d = 0; d < 10; d++) {
    for (i = 0; i < 10; i++) {
      float f = idsi[d][i];
      if (f < min)
        min = f;
      if (f > max)
        max = f;
    }
  }
  float k = (max == min) ? 1.f : 1.f / (max - min);
  for (d = 0; d < 10; d++) {
    for (i = 0; i < 10; i++) {
      idsi[d][i] = (idsi[d][i] - min) * k;
    }
  }
}


x86 assembly (clang, -O0):
<computeIDSI>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movss  0xeb6(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xea5(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    11be <computeIDSI+0x8e>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    11ab <computeIDSI+0x7b>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1178 <computeIDSI+0x48>
jmp    11b0 <computeIDSI+0x80>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1167 <computeIDSI+0x37>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   $0x280,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x29(%rbp)
cmpl   $0x14,-0xc(%rbp)
jge    11f1 <computeIDSI+0xc1>
xor    %eax,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    11fe <computeIDSI+0xce>
mov    $0xffffffec,%eax
mov    %eax,-0x60(%rbp)
jmp    11fe <computeIDSI+0xce>
mov    -0x60(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
add    $0x14,%eax
cmp    $0x280,%eax
jl     1225 <computeIDSI+0xf5>
mov    $0x27f,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1232 <computeIDSI+0x102>
mov    $0x14,%eax
mov    %eax,-0x64(%rbp)
jmp    1232 <computeIDSI+0x102>
mov    -0x64(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x14,-0x10(%rbp)
jge    124f <computeIDSI+0x11f>
xor    %eax,%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    125c <computeIDSI+0x12c>
mov    $0xffffffec,%eax
mov    %eax,-0x68(%rbp)
jmp    125c <computeIDSI+0x12c>
mov    -0x68(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%eax
add    $0x14,%eax
cmp    $0x1e0,%eax
jl     1283 <computeIDSI+0x153>
mov    $0x1df,%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1290 <computeIDSI+0x160>
mov    $0x14,%eax
mov    %eax,-0x6c(%rbp)
jmp    1290 <computeIDSI+0x160>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     13bd <computeIDSI+0x28d>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     13aa <computeIDSI+0x27a>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x280,%rcx,%rcx
add    %rcx,%rax
mov    -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
movzbl -0x29(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
imul   -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cvtsi2ssl -0x20(%rbp),%xmm0
movss  0xcfd(%rip),%xmm1
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1030 <roundfloat@plt>
mov    %eax,-0x20(%rbp)
mov    -0x4c(%rbp),%edi
call   1050 <sqrtf@plt>
cvtsi2ss %eax,%xmm0
movss  0xcd5(%rip),%xmm1
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1030 <roundfloat@plt>
mov    %eax,-0x1c(%rbp)
cvtsi2ssl -0x4c(%rbp),%xmm0
cvtsi2ssl -0x48(%rbp),%xmm1
movss  0xca3(%rip),%xmm2
mulss  %xmm2,%xmm1
movss  0xc9b(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1040 <expf@plt>
cvtsi2ss %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ae <computeIDSI+0x17e>
jmp    13af <computeIDSI+0x27f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    129c <computeIDSI+0x16c>
movss  0xc43(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    146d <computeIDSI+0x33d>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    145a <computeIDSI+0x32a>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    142e <computeIDSI+0x2fe>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x58(%rbp),%xmm0
ucomiss -0x54(%rbp),%xmm0
jbe    1447 <computeIDSI+0x317>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    144c <computeIDSI+0x31c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13ea <computeIDSI+0x2ba>
jmp    145f <computeIDSI+0x32f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13d9 <computeIDSI+0x2a9>
movss  -0x54(%rbp),%xmm0
ucomiss -0x50(%rbp),%xmm0
jne    1494 <computeIDSI+0x364>
jp     1494 <computeIDSI+0x364>
movss  0xb82(%rip),%xmm0
movss  %xmm0,-0x70(%rbp)
jmp    14af <computeIDSI+0x37f>
movss  -0x54(%rbp),%xmm1
subss  -0x50(%rbp),%xmm1
movss  0xb66(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    1536 <computeIDSI+0x406>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1523 <computeIDSI+0x3f3>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x50(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14d1 <computeIDSI+0x3a1>
jmp    1528 <computeIDSI+0x3f8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14c0 <computeIDSI+0x390>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeIDSI>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%rbx
mov    %edx,%r15d
mov    %esi,%ebp
mov    %rdi,%r14
mov    $0x190,%edx
mov    %rcx,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    %ebp,%eax
neg    %eax
cmp    $0x14,%ebp
mov    $0xffffffec,%ecx
cmovge %ecx,%eax
mov    %eax,0xc(%rsp)
mov    $0x27f,%eax
sub    %ebp,%eax
cmp    $0x26c,%ebp
mov    $0x14,%edx
cmovl  %edx,%eax
mov    %eax,0x8(%rsp)
mov    %r15d,%eax
neg    %eax
cmp    $0x14,%r15d
cmovge %ecx,%eax
mov    $0x1df,%ecx
sub    %r15d,%ecx
cmp    $0x1cc,%r15d
cmovl  %edx,%ecx
cmp    %ecx,%eax
jle    12a5 <computeIDSI+0x165>
movss  0xe4e(%rip),%xmm0
xorps  %xmm2,%xmm2
mov    $0x24,%eax
nopw   0x0(%rax,%rax,1)
movss  -0x24(%rbx,%rax,1),%xmm1
movss  -0x20(%rbx,%rax,1),%xmm3
movaps %xmm1,%xmm4
minss  %xmm0,%xmm4
maxss  %xmm2,%xmm1
movaps %xmm3,%xmm0
minss  %xmm4,%xmm0
maxss  %xmm1,%xmm3
movss  -0x1c(%rbx,%rax,1),%xmm1
movaps %xmm1,%xmm2
minss  %xmm0,%xmm2
maxss  %xmm3,%xmm1
movss  -0x18(%rbx,%rax,1),%xmm0
movaps %xmm0,%xmm3
minss  %xmm2,%xmm3
maxss  %xmm1,%xmm0
movss  -0x14(%rbx,%rax,1),%xmm1
movaps %xmm1,%xmm2
minss  %xmm3,%xmm2
maxss  %xmm0,%xmm1
movss  -0x10(%rbx,%rax,1),%xmm0
movaps %xmm0,%xmm3
minss  %xmm2,%xmm3
maxss  %xmm1,%xmm0
movss  -0xc(%rbx,%rax,1),%xmm1
movaps %xmm1,%xmm2
minss  %xmm3,%xmm2
maxss  %xmm0,%xmm1
movss  -0x8(%rbx,%rax,1),%xmm0
movaps %xmm0,%xmm3
minss  %xmm2,%xmm3
maxss  %xmm1,%xmm0
movss  -0x4(%rbx,%rax,1),%xmm1
movaps %xmm1,%xmm4
minss  %xmm3,%xmm4
maxss  %xmm0,%xmm1
movss  (%rbx,%rax,1),%xmm2
movaps %xmm2,%xmm0
minss  %xmm4,%xmm0
maxss  %xmm1,%xmm2
add    $0x28,%rax
cmp    $0x1b4,%rax
jne    11d0 <computeIDSI+0x90>
ucomiss %xmm0,%xmm2
jne    1432 <computeIDSI+0x2f2>
jp     1432 <computeIDSI+0x2f2>
movss  0xd74(%rip),%xmm1
jmp    1442 <computeIDSI+0x302>
movslq %r15d,%rdx
movslq %ebp,%rbp
lea    (%rdx,%rdx,4),%rdi
shl    $0x7,%rdi
add    %r14,%rdi
movzbl 0x0(%rbp,%rdi,1),%edi
movslq 0xc(%rsp),%r8
movslq 0x8(%rsp),%rsi
movslq %eax,%r9
movslq %ecx,%rax
mov    %rax,0x30(%rsp)
mov    %r9,0x10(%rsp)
add    %r9,%rdx
mov    %r8,0x28(%rsp)
add    %r8,%rbp
lea    (%rdx,%rdx,4),%rax
shl    $0x7,%rax
add    %r14,%rax
add    %rbp,%rax
mov    %rax,0x20(%rsp)
movss  0xd05(%rip),%xmm1
mov    %edi,0x18(%rsp)
mov    %rsi,0x38(%rsp)
jmp    1332 <computeIDSI+0x1f2>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
lea    0x1(%rcx),%rax
addq   $0x280,0x20(%rsp)
cmp    0x30(%rsp),%rcx
mov    %rax,0x10(%rsp)
jge    11ba <computeIDSI+0x7a>
mov    0x8(%rsp),%eax
cmp    %eax,0xc(%rsp)
jg     1310 <computeIDSI+0x1d0>
mov    0x10(%rsp),%rax
imul   %rax,%rax
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%r15
mov    0x28(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r15),%r13d
xorps  %xmm0,%xmm0
cvtsi2ss %r13d,%xmm0
mov    %rbx,%r14
sub    %edi,%r13d
imul   %r13d,%r13d
mov    %r12d,%eax
imul   %eax,%eax
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,1),%ebx
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1030 <roundfloat@plt>
mov    %eax,0x1c(%rsp)
mov    %ebx,%edi
call   1060 <sqrtf@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0xc59(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1030 <roundfloat@plt>
mov    %eax,%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %r13d,%xmm1
mov    %r14,%rbx
mulss  0xc38(%rip),%xmm1
mulss  0xc34(%rip),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1040 <expf@plt>
movss  0xc13(%rip),%xmm1
mov    0x38(%rsp),%rsi
mov    0x18(%rsp),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movslq %ebp,%rax
movslq 0x1c(%rsp),%rcx
lea    (%rax,%rax,4),%rax
lea    (%r14,%rax,8),%rax
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
lea    0x1(%r12),%rax
add    $0x1,%r15
cmp    %rsi,%r12
mov    %rax,%r12
jl     1360 <computeIDSI+0x220>
jmp    1310 <computeIDSI+0x1d0>
subss  %xmm0,%xmm2
movss  0xbd6(%rip),%xmm1
divss  %xmm2,%xmm1
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
mov    $0x24,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x24(%rbx,%rax,1),%xmm4
movups -0x14(%rbx,%rax,1),%xmm5
subps  %xmm3,%xmm4
mulps  %xmm2,%xmm4
movups %xmm4,-0x24(%rbx,%rax,1)
subps  %xmm3,%xmm5
mulps  %xmm2,%xmm5
movups %xmm5,-0x14(%rbx,%rax,1)
movss  -0x4(%rbx,%rax,1),%xmm4
subss  %xmm0,%xmm4
mulss  %xmm1,%xmm4
movss  %xmm4,-0x4(%rbx,%rax,1)
movss  (%rbx,%rax,1),%xmm4
subss  %xmm0,%xmm4
mulss  %xmm1,%xmm4
movss  %xmm4,(%rbx,%rax,1)
add    $0x28,%rax
cmp    $0x1b4,%rax
jne    1460 <computeIDSI+0x320>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @computeIDSI([640 x i8]* %0, i32 %1, i32 %2, [10 x float]* %3) {
%5 = alloca [640 x i8]*
%6 = alloca i32
%7 = alloca i32
%8 = alloca [10 x float]*
%9 = alloca i32
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca i8
%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 float
%23 = alloca float
%24 = alloca float
%25 = alloca float
store [640 x i8]* %0, [640 x i8]** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store [10 x float]* %3, [10 x float]** %8
store float -3.125000e+00, float* %11
store float 0xBF547AE140000000, float* %12
store i32 0, i32* %9
br label %26
26: ; preds = %45, %4
%27 = load i32, i32* %9
%28 = icmp slt i32 %27, 10
br i1 %28, label %29, label %48
29: ; preds = %26
store i32 0, i32* %10
br label %30
30: ; preds = %41, %29
%31 = load i32, i32* %10
%32 = icmp slt i32 %31, 10
br i1 %32, label %33, label %44
33: ; preds = %30
%34 = load [10 x float]*, [10 x float]** %8
%35 = load i32, i32* %9
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [10 x float], [10 x float]* %34, i64 %36
%38 = load i32, i32* %10
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [10 x float], [10 x float]* %37, i64 0, i64 %39
store float 0.000000e+00, float* %40
br label %41
41: ; preds = %33
%42 = load i32, i32* %10
%43 = add nsw i32 %42, 1
store i32 %43, i32* %10
br label %30
44: ; preds = %30
br label %45
45: ; preds = %44
%46 = load i32, i32* %9
%47 = add nsw i32 %46, 1
store i32 %47, i32* %9
br label %26
48: ; preds = %26
%49 = load [640 x i8]*, [640 x i8]** %5
%50 = load i32, i32* %7
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [640 x i8], [640 x i8]* %49, i64 %51
%53 = load i32, i32* %6
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [640 x i8], [640 x i8]* %52, i64 0, i64 %54
%56 = load i8, i8* %55
store i8 %56, i8* %13
%57 = load i32, i32* %6
%58 = icmp slt i32 %57, 20
br i1 %58, label %59, label %62
59: ; preds = %48
%60 = load i32, i32* %6
%61 = sub nsw i32 0, %60
br label %63
62: ; preds = %48
br label %63
63: ; preds = %62, %59
%64 = phi i32 [ %61, %59 ], [ -20, %62 ]
store i32 %64, i32* %16
%65 = load i32, i32* %6
%66 = add nsw i32 %65, 20
%67 = icmp sge i32 %66, 640
br i1 %67, label %68, label %71
68: ; preds = %63
%69 = load i32, i32* %6
%70 = sub nsw i32 639, %69
br label %72
71: ; preds = %63
br label %72
72: ; preds = %71, %68
%73 = phi i32 [ %70, %68 ], [ 20, %71 ]
store i32 %73, i32* %17
%74 = load i32, i32* %7
%75 = icmp slt i32 %74, 20
br i1 %75, label %76, label %79
76: ; preds = %72
%77 = load i32, i32* %7
%78 = sub nsw i32 0, %77
br label %80
79: ; preds = %72
br label %80
80: ; preds = %79, %76
%81 = phi i32 [ %78, %76 ], [ -20, %79 ]
store i32 %81, i32* %18
%82 = load i32, i32* %7
%83 = add nsw i32 %82, 20
%84 = icmp sge i32 %83, 480
br i1 %84, label %85, label %88
85: ; preds = %80
%86 = load i32, i32* %7
%87 = sub nsw i32 479, %86
br label %89
88: ; preds = %80
br label %89
89: ; preds = %88, %85
%90 = phi i32 [ %87, %85 ], [ 20, %88 ]
store i32 %90, i32* %19
%91 = load i32, i32* %18
store i32 %91, i32* %15
br label %92
92: ; preds = %163, %89
%93 = load i32, i32* %15
%94 = load i32, i32* %19
%95 = icmp sle i32 %93, %94
br i1 %95, label %96, label %166
96: ; preds = %92
%97 = load i32, i32* %16
store i32 %97, i32* %14
br label %98
98: ; preds = %159, %96
%99 = load i32, i32* %14
%100 = load i32, i32* %17
%101 = icmp sle i32 %99, %100
br i1 %101, label %102, label %162
102: ; preds = %98
%103 = load [640 x i8]*, [640 x i8]** %5
%104 = load i32, i32* %7
%105 = load i32, i32* %15
%106 = add nsw i32 %104, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [640 x i8], [640 x i8]* %103, i64 %107
%109 = load i32, i32* %6
%110 = load i32, i32* %14
%111 = add nsw i32 %109, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [640 x i8], [640 x i8]* %108, i64 0, i64 %112
%114 = load i8, i8* %113
%115 = zext i8 %114 to i32
store i32 %115, i32* %10
%116 = load i32, i32* %10
%117 = load i8, i8* %13
%118 = zext i8 %117 to i32
%119 = sub nsw i32 %116, %118
store i32 %119, i32* %20
%120 = load i32, i32* %20
%121 = load i32, i32* %20
%122 = mul nsw i32 %121, %120
store i32 %122, i32* %20
%123 = load i32, i32* %14
%124 = load i32, i32* %14
%125 = mul nsw i32 %123, %124
%126 = load i32, i32* %15
%127 = load i32, i32* %15
%128 = mul nsw i32 %126, %127
%129 = add nsw i32 %125, %128
store i32 %129, i32* %21
%130 = load i32, i32* %10
%131 = sitofp i32 %130 to float
%132 = fmul float %131, 0x3FA2121220000000
%133 = fptosi float %132 to i32
%134 = call i32 @roundfloat(i32 %133)
store i32 %134, i32* %10
%135 = load i32, i32* %21
%136 = call i32 @sqrtf(i32 %135)
%137 = sitofp i32 %136 to float
%138 = fmul float %137, 0x3FD45D5B60000000
%139 = fptosi float %138 to i32
%140 = call i32 @roundfloat(i32 %139)
store i32 %140, i32* %9
%141 = load i32, i32* %21
%142 = sitofp i32 %141 to float
%143 = load i32, i32* %20
%144 = sitofp i32 %143 to float
%145 = fmul float %144, 0xBF547AE140000000
%146 = call float @llvm.fmuladd.f32(float %142, float -3.125000e+00, float %145)
%147 = fptosi float %146 to i32
%148 = call i64 @expf(i32 %147)
%149 = sitofp i64 %148 to float
%150 = load [10 x float]*, [10 x float]** %8
%151 = load i32, i32* %9
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [10 x float], [10 x float]* %150, i64 %152
%154 = load i32, i32* %10
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [10 x float], [10 x float]* %153, i64 0, i64 %155
%157 = load float, float* %156
%158 = fadd float %157, %149
store float %158, float* %156
br label %159
159: ; preds = %102
%160 = load i32, i32* %14
%161 = add nsw i32 %160, 1
store i32 %161, i32* %14
br label %98
162: ; preds = %98
br label %163
163: ; preds = %162
%164 = load i32, i32* %15
%165 = add nsw i32 %164, 1
store i32 %165, i32* %15
br label %92
166: ; preds = %92
store float 4.000000e+02, float* %22
store float 0.000000e+00, float* %23
store i32 0, i32* %9
br label %167
167: ; preds = %199, %166
%168 = load i32, i32* %9
%169 = icmp slt i32 %168, 10
br i1 %169, label %170, label %202
170: ; preds = %167
store i32 0, i32* %10
br label %171
171: ; preds = %195, %170
%172 = load i32, i32* %10
%173 = icmp slt i32 %172, 10
br i1 %173, label %174, label %198
174: ; preds = %171
%175 = load [10 x float]*, [10 x float]** %8
%176 = load i32, i32* %9
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [10 x float], [10 x float]* %175, i64 %177
%179 = load i32, i32* %10
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [10 x float], [10 x float]* %178, i64 0, i64 %180
%182 = load float, float* %181
store float %182, float* %24
%183 = load float, float* %24
%184 = load float, float* %22
%185 = fcmp olt float %183, %184
br i1 %185, label %186, label %188
186: ; preds = %174
%187 = load float, float* %24
store float %187, float* %22
br label %188
188: ; preds = %186, %174
%189 = load float, float* %24
%190 = load float, float* %23
%191 = fcmp ogt float %189, %190
br i1 %191, label %192, label %194
192: ; preds = %188
%193 = load float, float* %24
store float %193, float* %23
br label %194
194: ; preds = %192, %188
br label %195
195: ; preds = %194
%196 = load i32, i32* %10
%197 = add nsw i32 %196, 1
store i32 %197, i32* %10
br label %171
198: ; preds = %171
br label %199
199: ; preds = %198
%200 = load i32, i32* %9
%201 = add nsw i32 %200, 1
store i32 %201, i32* %9
br label %167
202: ; preds = %167
%203 = load float, float* %23
%204 = load float, float* %22
%205 = fcmp oeq float %203, %204
br i1 %205, label %206, label %207
206: ; preds = %202
br label %212
207: ; preds = %202
%208 = load float, float* %23
%209 = load float, float* %22
%210 = fsub float %208, %209
%211 = fdiv float 1.000000e+00, %210
br label %212
212: ; preds = %207, %206
%213 = phi float [ 1.000000e+00, %206 ], [ %211, %207 ]
store float %213, float* %25
store i32 0, i32* %9
br label %214
214: ; preds = %245, %212
%215 = load i32, i32* %9
%216 = icmp slt i32 %215, 10
br i1 %216, label %217, label %248
217: ; preds = %214
store i32 0, i32* %10
br label %218
218: ; preds = %241, %217
%219 = load i32, i32* %10
%220 = icmp slt i32 %219, 10
br i1 %220, label %221, label %244
221: ; preds = %218
%222 = load [10 x float]*, [10 x float]** %8
%223 = load i32, i32* %9
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [10 x float], [10 x float]* %222, i64 %224
%226 = load i32, i32* %10
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [10 x float], [10 x float]* %225, i64 0, i64 %227
%229 = load float, float* %228
%230 = load float, float* %22
%231 = fsub float %229, %230
%232 = load float, float* %25
%233 = fmul float %231, %232
%234 = load [10 x float]*, [10 x float]** %8
%235 = load i32, i32* %9
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [10 x float], [10 x float]* %234, i64 %236
%238 = load i32, i32* %10
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds [10 x float], [10 x float]* %237, i64 0, i64 %239
store float %233, float* %240
br label %241
241: ; preds = %221
%242 = load i32, i32* %10
%243 = add nsw i32 %242, 1
store i32 %243, i32* %10
br label %218
244: ; preds = %218
br label %245
245: ; preds = %244
%246 = load i32, i32* %9
%247 = add nsw i32 %246, 1
store i32 %247, i32* %9
br label %214
248: ; preds = %214
ret void
}

LLVM IR (-O2):
define void @computeIDSI([640 x i8]* nocapture %0, i32 %1, i32 %2, [10 x float]* nocapture %3) {
%5 = bitcast [10 x float]* %3 to i8*
%6 = icmp slt i32 %1, 20
%7 = sub nsw i32 0, %1
%8 = select i1 %6, i32 %7, i32 -20
%9 = icmp sgt i32 %1, 619
%10 = sub nsw i32 639, %1
%11 = select i1 %9, i32 %10, i32 20
%12 = icmp slt i32 %2, 20
%13 = sub nsw i32 0, %2
%14 = select i1 %12, i32 %13, i32 -20
%15 = icmp sgt i32 %2, 459
%16 = sub nsw i32 479, %2
%17 = select i1 %15, i32 %16, i32 20
%18 = icmp sgt i32 %14, %17
br i1 %18, label %72, label %19
19: ; preds = %4
%20 = sext i32 %2 to i64
%21 = sext i32 %1 to i64
%22 = getelementptr inbounds [640 x i8], [640 x i8]* %0, i64 %20, i64 %21
%23 = load i8, i8* %22
%24 = icmp sgt i32 %8, %11
%25 = zext i8 %23 to i32
%26 = sext i32 %8 to i64
%27 = sext i32 %11 to i64
%28 = sext i32 %14 to i64
%29 = sext i32 %17 to i64
br label %30
30: ; preds = %19, %69
%31 = phi i64 [ %28, %19 ], [ %70, %69 ]
br i1 %24, label %69, label %32
32: ; preds = %30
%33 = add nsw i64 %31, %20
%34 = mul nsw i64 %31, %31
br label %35
35: ; preds = %32, %35
%36 = phi i64 [ %26, %32 ], [ %67, %35 ]
%37 = add nsw i64 %36, %21
%38 = getelementptr inbounds [640 x i8], [640 x i8]* %0, i64 %33, i64 %37
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = sub nsw i32 %40, %25
%42 = mul nsw i32 %41, %41
%43 = mul nsw i64 %36, %36
%44 = add nuw nsw i64 %43, %34
%45 = uitofp i8 %39 to float
%46 = fmul float %45, 0x3FA2121220000000
%47 = fptosi float %46 to i32
%48 = tail call i32 @roundfloat(i32 %47)
%49 = trunc i64 %44 to i32
%50 = tail call i32 @sqrtf(i32 %49)
%51 = sitofp i32 %50 to float
%52 = fmul float %51, 0x3FD45D5B60000000
%53 = fptosi float %52 to i32
%54 = tail call i32 @roundfloat(i32 %53)
%55 = sitofp i32 %49 to float
%56 = sitofp i32 %42 to float
%57 = fmul float %56, 0xBF547AE140000000
%58 = tail call float @llvm.fmuladd.f32(float %55, float -3.125000e+00, float %57)
%59 = fptosi float %58 to i32
%60 = tail call i64 @expf(i32 %59)
%61 = sitofp i64 %60 to float
%62 = sext i32 %54 to i64
%63 = sext i32 %48 to i64
%64 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %62, i64 %63
%65 = load float, float* %64
%66 = fadd float %65, %61
store float %66, float* %64
%67 = add nsw i64 %36, 1
%68 = icmp slt i64 %36, %27
br i1 %68, label %35, label %69
69: ; preds = %35, %30
%70 = add nsw i64 %31, 1
%71 = icmp slt i64 %31, %29
br i1 %71, label %30, label %72
72: ; preds = %69, %4
br label %73
73: ; preds = %72, %73
%74 = phi i64 [ %137, %73 ], [ 0, %72 ]
%75 = phi float [ %136, %73 ], [ 0.000000e+00, %72 ]
%76 = phi float [ %134, %73 ], [ 4.000000e+02, %72 ]
%77 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 0
%78 = load float, float* %77
%79 = fcmp olt float %78, %76
%80 = select i1 %79, float %78, float %76
%81 = fcmp ogt float %78, %75
%82 = select i1 %81, float %78, float %75
%83 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 1
%84 = load float, float* %83
%85 = fcmp olt float %84, %80
%86 = select i1 %85, float %84, float %80
%87 = fcmp ogt float %84, %82
%88 = select i1 %87, float %84, float %82
%89 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 2
%90 = load float, float* %89
%91 = fcmp olt float %90, %86
%92 = select i1 %91, float %90, float %86
%93 = fcmp ogt float %90, %88
%94 = select i1 %93, float %90, float %88
%95 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 3
%96 = load float, float* %95
%97 = fcmp olt float %96, %92
%98 = select i1 %97, float %96, float %92
%99 = fcmp ogt float %96, %94
%100 = select i1 %99, float %96, float %94
%101 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 4
%102 = load float, float* %101
%103 = fcmp olt float %102, %98
%104 = select i1 %103, float %102, float %98
%105 = fcmp ogt float %102, %100
%106 = select i1 %105, float %102, float %100
%107 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 5
%108 = load float, float* %107
%109 = fcmp olt float %108, %104
%110 = select i1 %109, float %108, float %104
%111 = fcmp ogt float %108, %106
%112 = select i1 %111, float %108, float %106
%113 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 6
%114 = load float, float* %113
%115 = fcmp olt float %114, %110
%116 = select i1 %115, float %114, float %110
%117 = fcmp ogt float %114, %112
%118 = select i1 %117, float %114, float %112
%119 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 7
%120 = load float, float* %119
%121 = fcmp olt float %120, %116
%122 = select i1 %121, float %120, float %116
%123 = fcmp ogt float %120, %118
%124 = select i1 %123, float %120, float %118
%125 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 8
%126 = load float, float* %125
%127 = fcmp olt float %126, %122
%128 = select i1 %127, float %126, float %122
%129 = fcmp ogt float %126, %124
%130 = select i1 %129, float %126, float %124
%131 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %74, i64 9
%132 = load float, float* %131
%133 = fcmp olt float %132, %128
%134 = select i1 %133, float %132, float %128
%135 = fcmp ogt float %132, %130
%136 = select i1 %135, float %132, float %130
%137 = add nuw nsw i64 %74, 1
%138 = icmp eq i64 %137, 10
br i1 %138, label %139, label %73
139: ; preds = %73
%140 = fcmp oeq float %136, %134
br i1 %140, label %144, label %141
141: ; preds = %139
%142 = fsub float %136, %134
%143 = fdiv float 1.000000e+00, %142
br label %144
144: ; preds = %139, %141
%145 = phi float [ %143, %141 ], [ 1.000000e+00, %139 ]
%146 = insertelement <4 x float> poison, float %145, i64 0
%147 = shufflevector <4 x float> %146, <4 x float> poison, <4 x i32> zeroinitializer
%148 = insertelement <4 x float> poison, float %134, i64 0
%149 = shufflevector <4 x float> %148, <4 x float> poison, <4 x i32> zeroinitializer
%150 = insertelement <4 x float> poison, float %145, i64 0
%151 = shufflevector <4 x float> %150, <4 x float> poison, <4 x i32> zeroinitializer
%152 = insertelement <4 x float> poison, float %134, i64 0
%153 = shufflevector <4 x float> %152, <4 x float> poison, <4 x i32> zeroinitializer
br label %154
154: ; preds = %144, %154
%155 = phi i64 [ 0, %144 ], [ %176, %154 ]
%156 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %155, i64 0
%157 = bitcast float* %156 to <4 x float>*
%158 = load <4 x float>, <4 x float>* %157
%159 = fsub <4 x float> %158, %149
%160 = fmul <4 x float> %147, %159
%161 = bitcast float* %156 to <4 x float>*
store <4 x float> %160, <4 x float>* %161
%162 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %155, i64 4
%163 = bitcast float* %162 to <4 x float>*
%164 = load <4 x float>, <4 x float>* %163
%165 = fsub <4 x float> %164, %153
%166 = fmul <4 x float> %151, %165
%167 = bitcast float* %162 to <4 x float>*
store <4 x float> %166, <4 x float>* %167
%168 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %155, i64 8
%169 = load float, float* %168
%170 = fsub float %169, %134
%171 = fmul float %145, %170
store float %171, float* %168
%172 = getelementptr inbounds [10 x float], [10 x float]* %3, i64 %155, i64 9
%173 = load float, float* %172
%174 = fsub float %173, %134
%175 = fmul float %145, %174
store float %175, float* %172
%176 = add nuw nsw i64 %155, 1
%177 = icmp eq i64 %176, 10
br i1 %177, label %178, label %154
178: ; preds = %154
ret void
}