#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 */
typedef int /*<<< orphan*/ B;
typedef int /*<<< orphan*/ A;

/* Variables and functions */
int ceil(double);
int floor(double);
double log(int);
int /*<<< orphan*/ memset(double *, int /*<<< orphan*/, int);
double c_update(unsigned char *imgA, unsigned char *imgB, double *U, int n) {
  double H[256][256];
  int i, j;
  double x, y;
  for (i = 0; i < 256; i++)
    for (j = 0; j < 256; j++)
      H[i][j] = 0;
  for (i = 0; i < n * n; i++) {
    H[imgA[i]][imgB[i]] += 1;
  }
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      x = U[0] * i + U[1] * j + U[2];
      y = U[3] * i + U[4] * j + U[5];
      double dx = x - floor(x);
      double dy = y - floor(y);
      if (x <= 0 || x >= n - 1 || y <= 0 || y >= n - 1) {
        H[imgA[0]][imgA[0]] += 1;
      } else {
        H[imgA[(int)(floor(x) * n + floor(y))]][imgB[i * n + j]] +=
            (1 - dx) * (1 - dy);
        H[imgA[(int)(floor(x) * n + ceil(y))]][imgB[i * n + j]] +=
            dx * (1 - dy);
        H[imgA[(int)(ceil(x) * n + floor(y))]][imgB[i * n + j]] +=
            (1 - dx) * dy;
        H[imgA[(int)(ceil(x) * n + ceil(y))]][imgB[i * n + j]] += dx * dy;
      }
    }
  double tot = 0;
  for (i = 0; i < 256; i++)
    for (j = 0; j < 256; j++)
      tot += H[i][j];
  double A[256], B[256];
  double HAB = 0, HA = 0, HB = 0;
  memset(A, 0, sizeof(A));
  memset(B, 0, sizeof(B));
  for (i = 0; i < 256; i++)
    for (j = 0; j < 256; j++) {
      H[i][j] /= tot;
      A[i] += H[i][j];
      B[j] += H[i][j];
      if (H[i][j] > 1e-7)
        HAB += -H[i][j] * (log(H[i][j]) / log(2));
      else
        HAB += 0;
    }
  for (i = 0; i < 256; i++) {
    if (A[i] > 1e-7)
      HA += -A[i] * (log(A[i]) / log(2));
    else
      HA += 0;
    if (B[i] > 1e-7)
      HB += -B[i] * (log(B[i]) / log(2));
    else
      HB += 0;
  }
  return HAB - HA - HB;
}


x86 assembly (clang, -O0):
<c_update>:
push   %rbp
mov    %rsp,%rbp
sub    $0x81130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x80024(%rbp)
cmpl   $0x100,-0x80024(%rbp)
jge    11df <c_update+0x9f>
movl   $0x0,-0x80028(%rbp)
cmpl   $0x100,-0x80028(%rbp)
jge    11c6 <c_update+0x86>
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80028(%rbp)
jmp    117e <c_update+0x3e>
jmp    11cb <c_update+0x8b>
mov    -0x80024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80024(%rbp)
jmp    1164 <c_update+0x24>
movl   $0x0,-0x80024(%rbp)
mov    -0x80024(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1252 <c_update+0x112>
mov    -0x8(%rbp),%rax
movslq -0x80024(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,%ecx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
movslq -0x80024(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
movsd  0xdd4(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80024(%rbp)
jmp    11e9 <c_update+0xa9>
movl   $0x0,-0x80024(%rbp)
mov    -0x80024(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    171c <c_update+0x5dc>
movl   $0x0,-0x80028(%rbp)
mov    -0x80028(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1703 <c_update+0x5c3>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
cvtsi2sdl -0x80024(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
cvtsi2sdl -0x80028(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x80030(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
cvtsi2sdl -0x80024(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm1
cvtsi2sdl -0x80028(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
addsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x80038(%rbp)
movsd  -0x80030(%rbp),%xmm0
ff
movsd  %xmm0,-0x81078(%rbp)
ff
movsd  -0x80030(%rbp),%xmm0
ff
call   1060 <floor@plt>
movsd  -0x81078(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80040(%rbp)
ff
movsd  -0x80038(%rbp),%xmm0
ff
movsd  %xmm0,-0x81070(%rbp)
ff
movsd  -0x80038(%rbp),%xmm0
ff
call   1060 <floor@plt>
movsd  -0x81070(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80048(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x80030(%rbp),%xmm0
ff
jae    13c5 <c_update+0x285>
movsd  -0x80030(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jae    13c5 <c_update+0x285>
xorps  %xmm0,%xmm0
ucomisd -0x80038(%rbp),%xmm0
ff
jae    13c5 <c_update+0x285>
movsd  -0x80038(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
ucomisd %xmm1,%xmm0
jb     13fa <c_update+0x2ba>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
movsd  0xc1d(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ea <c_update+0x5aa>
movsd  0xc06(%rip),%xmm0
subsd  -0x80040(%rbp),%xmm0
ff
movsd  %xmm0,-0x810f0(%rbp)
ff
movsd  0xbee(%rip),%xmm0
subsd  -0x80048(%rbp),%xmm0
ff
movsd  %xmm0,-0x810e8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0x810e0(%rbp)
movsd  -0x80030(%rbp),%xmm0
ff
call   1060 <floor@plt>
imul   -0x1c(%rbp),%eax
mov    %eax,-0x810f4(%rbp)
movsd  -0x80038(%rbp),%xmm0
ff
call   1060 <floor@plt>
mov    -0x810f4(%rbp),%ecx
movsd  -0x810f0(%rbp),%xmm0
ff
movsd  -0x810e8(%rbp),%xmm2
ff
mov    %eax,%edx
mov    -0x810e0(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,%ecx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x80024(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    -0x80028(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80040(%rbp),%xmm0
ff
movsd  %xmm0,-0x810d0(%rbp)
ff
movsd  0xb32(%rip),%xmm0
subsd  -0x80048(%rbp),%xmm0
ff
movsd  %xmm0,-0x810c8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0x810c0(%rbp)
movsd  -0x80030(%rbp),%xmm0
ff
call   1060 <floor@plt>
imul   -0x1c(%rbp),%eax
mov    %eax,-0x810d4(%rbp)
movsd  -0x80038(%rbp),%xmm0
ff
call   1030 <ceil@plt>
mov    -0x810d4(%rbp),%ecx
movsd  -0x810d0(%rbp),%xmm0
ff
movsd  -0x810c8(%rbp),%xmm2
ff
mov    %eax,%edx
mov    -0x810c0(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,%ecx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x80024(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    -0x80028(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xa86(%rip),%xmm0
subsd  -0x80040(%rbp),%xmm0
ff
movsd  %xmm0,-0x810b0(%rbp)
ff
movsd  -0x80048(%rbp),%xmm0
ff
movsd  %xmm0,-0x810a8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0x810a0(%rbp)
movsd  -0x80030(%rbp),%xmm0
ff
call   1030 <ceil@plt>
imul   -0x1c(%rbp),%eax
mov    %eax,-0x810b4(%rbp)
movsd  -0x80038(%rbp),%xmm0
ff
call   1060 <floor@plt>
mov    -0x810b4(%rbp),%ecx
movsd  -0x810b0(%rbp),%xmm0
ff
movsd  -0x810a8(%rbp),%xmm2
ff
mov    %eax,%edx
mov    -0x810a0(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,%ecx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x80024(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    -0x80028(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80040(%rbp),%xmm0
ff
movsd  %xmm0,-0x81090(%rbp)
ff
movsd  -0x80048(%rbp),%xmm0
ff
movsd  %xmm0,-0x81088(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0x81080(%rbp)
movsd  -0x80030(%rbp),%xmm0
ff
call   1030 <ceil@plt>
imul   -0x1c(%rbp),%eax
mov    %eax,-0x81094(%rbp)
movsd  -0x80038(%rbp),%xmm0
ff
call   1030 <ceil@plt>
mov    -0x81094(%rbp),%ecx
movsd  -0x81090(%rbp),%xmm0
ff
movsd  -0x81088(%rbp),%xmm2
ff
mov    %eax,%edx
mov    -0x81080(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,%ecx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x80024(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    -0x80028(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16ef <c_update+0x5af>
mov    -0x80028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80028(%rbp)
jmp    1275 <c_update+0x135>
jmp    1708 <c_update+0x5c8>
mov    -0x80024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80024(%rbp)
jmp    125c <c_update+0x11c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80050(%rbp)
ff
movl   $0x0,-0x80024(%rbp)
cmpl   $0x100,-0x80024(%rbp)
jge    17b9 <c_update+0x679>
movl   $0x0,-0x80028(%rbp)
cmpl   $0x100,-0x80028(%rbp)
jge    17a0 <c_update+0x660>
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x80050(%rbp),%xmm0
ff
movsd  %xmm0,-0x80050(%rbp)
ff
mov    -0x80028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80028(%rbp)
jmp    174b <c_update+0x60b>
jmp    17a5 <c_update+0x665>
mov    -0x80024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80024(%rbp)
jmp    1731 <c_update+0x5f1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x81058(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x81060(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x81068(%rbp)
ff
lea    -0x80850(%rbp),%rdi
xor    %esi,%esi
mov    $0x800,%edx
call   1040 <memset@plt>
lea    -0x81050(%rbp),%rdi
xor    %esi,%esi
mov    $0x800,%edx
call   1040 <memset@plt>
movl   $0x0,-0x80024(%rbp)
cmpl   $0x100,-0x80024(%rbp)
jge    19fe <c_update+0x8be>
movl   $0x0,-0x80028(%rbp)
cmpl   $0x100,-0x80028(%rbp)
jge    19e5 <c_update+0x8a5>
movsd  -0x80050(%rbp),%xmm1
ff
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x80024(%rbp),%rax
addsd  -0x80850(%rbp,%rax,8),%xmm0
f7 ff
movsd  %xmm0,-0x80850(%rbp,%rax,8)
f7 ff
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x80028(%rbp),%rax
addsd  -0x81050(%rbp,%rax,8),%xmm0
f7 ff
movsd  %xmm0,-0x81050(%rbp,%rax,8)
f7 ff
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x6fd(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    19b9 <c_update+0x879>
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x81100(%rbp)
ff
movslq -0x80024(%rbp),%rcx
lea    -0x80020(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x80028(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%edi
call   1050 <log@plt>
movsd  %xmm0,-0x81108(%rbp)
ff
mov    $0x2,%edi
call   1050 <log@plt>
movsd  -0x81108(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x81100(%rbp),%xmm0
ff
divsd  %xmm1,%xmm2
movsd  -0x81058(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x81058(%rbp)
ff
jmp    19cc <c_update+0x88c>
xorps  %xmm0,%xmm0
addsd  -0x81058(%rbp),%xmm0
ff
movsd  %xmm0,-0x81058(%rbp)
ff
jmp    19d1 <c_update+0x891>
mov    -0x80028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80028(%rbp)
jmp    1824 <c_update+0x6e4>
jmp    19ea <c_update+0x8aa>
mov    -0x80024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80024(%rbp)
jmp    180a <c_update+0x6ca>
movl   $0x0,-0x80024(%rbp)
cmpl   $0x100,-0x80024(%rbp)
jge    1baf <c_update+0xa6f>
movslq -0x80024(%rbp),%rax
movsd  -0x80850(%rbp,%rax,8),%xmm0
f7 ff
movsd  0x5d0(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ac4 <c_update+0x984>
movslq -0x80024(%rbp),%rax
movsd  -0x80850(%rbp,%rax,8),%xmm0
f7 ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x81110(%rbp)
ff
movslq -0x80024(%rbp),%rax
cvttsd2si -0x80850(%rbp,%rax,8),%edi
f7 ff
call   1050 <log@plt>
movsd  %xmm0,-0x81118(%rbp)
ff
mov    $0x2,%edi
call   1050 <log@plt>
movsd  -0x81118(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x81110(%rbp),%xmm0
ff
divsd  %xmm1,%xmm2
movsd  -0x81060(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x81060(%rbp)
ff
jmp    1ad7 <c_update+0x997>
xorps  %xmm0,%xmm0
addsd  -0x81060(%rbp),%xmm0
ff
movsd  %xmm0,-0x81060(%rbp)
ff
movslq -0x80024(%rbp),%rax
movsd  -0x81050(%rbp,%rax,8),%xmm0
f7 ff
movsd  0x511(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1b83 <c_update+0xa43>
movslq -0x80024(%rbp),%rax
movsd  -0x81050(%rbp,%rax,8),%xmm0
f7 ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x81120(%rbp)
ff
movslq -0x80024(%rbp),%rax
cvttsd2si -0x81050(%rbp,%rax,8),%edi
f7 ff
call   1050 <log@plt>
movsd  %xmm0,-0x81128(%rbp)
ff
mov    $0x2,%edi
call   1050 <log@plt>
movsd  -0x81128(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x81120(%rbp),%xmm0
ff
divsd  %xmm1,%xmm2
movsd  -0x81068(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x81068(%rbp)
ff
jmp    1b96 <c_update+0xa56>
xorps  %xmm0,%xmm0
addsd  -0x81068(%rbp),%xmm0
ff
movsd  %xmm0,-0x81068(%rbp)
ff
jmp    1b9b <c_update+0xa5b>
mov    -0x80024(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80024(%rbp)
jmp    1a08 <c_update+0x8c8>
movsd  -0x81058(%rbp),%xmm0
ff
subsd  -0x81060(%rbp),%xmm0
ff
subsd  -0x81068(%rbp),%xmm0
ff
add    $0x81130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_update>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x81068,%rsp
mov    %ecx,%r14d
mov    %rdx,%rbx
mov    %rsi,%rbp
mov    %rdi,%r15
lea    0x1060(%rsp),%rdi
mov    $0x80000,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    %r14,%rax
mov    %r14,0x28(%rsp)
mov    %r14d,%ecx
imul   %r14d,%ecx
test   %ecx,%ecx
je     1233 <c_update+0xf3>
mov    %ecx,%eax
cmp    $0x1,%ecx
jne    1193 <c_update+0x53>
xor    %ecx,%ecx
jmp    1206 <c_update+0xc6>
mov    %eax,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
movsd  0xe5e(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r15,%rcx,1),%esi
movzbl 0x0(%rbp,%rcx,1),%edi
shl    $0xb,%rsi
add    %rsp,%rsi
add    $0x1060,%rsi
movsd  (%rsi,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
movzbl 0x1(%r15,%rcx,1),%esi
movzbl 0x1(%rbp,%rcx,1),%edi
shl    $0xb,%rsi
add    %rsp,%rsi
add    $0x1060,%rsi
movsd  (%rsi,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    11b0 <c_update+0x70>
test   $0x1,%al
je     1233 <c_update+0xf3>
movzbl (%r15,%rcx,1),%eax
movzbl 0x0(%rbp,%rcx,1),%ecx
shl    $0xb,%rax
add    %rsp,%rax
add    $0x1060,%rax
movsd  (%rax,%rcx,8),%xmm0
addsd  0xdd2(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0x28(%rsp)
jle    14fe <c_update+0x3be>
mov    0x28(%rsp),%rcx
lea    -0x1(%rcx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %ecx,%r14d
xor    %eax,%eax
mov    %r14,0x58(%rsp)
jmp    127a <c_update+0x13a>
nop
mov    0x50(%rsp),%rax
add    $0x1,%rax
mov    0x30(%rsp),%rbp
add    %r14,%rbp
cmp    %r14,%rax
je     14fe <c_update+0x3be>
mov    %rbp,0x30(%rsp)
mov    %rax,0x50(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %r12d,%r12d
jmp    12d0 <c_update+0x190>
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15),%eax
mov    %rax,%rcx
shl    $0xb,%rcx
add    %rsp,%rcx
add    $0x1060,%rcx
movsd  (%rcx,%rax,8),%xmm0
addsd  0xd3e(%rip),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%r12
cmp    %r12,%r14
je     1260 <c_update+0x120>
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movsd  0x8(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rbx),%xmm3
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
addsd  0x10(%rbx),%xmm3
movsd  %xmm3,0x10(%rsp)
mulsd  0x20(%rbx),%xmm0
movsd  0x18(%rbx),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  0x28(%rbx),%xmm1
movsd  %xmm1,(%rsp)
movapd %xmm3,%xmm0
call   1060 <floor@plt>
mov    %eax,%ebp
movsd  (%rsp),%xmm0
call   1060 <floor@plt>
movsd  (%rsp),%xmm2
movsd  0x10(%rsp),%xmm5
xorpd  %xmm0,%xmm0
ucomisd %xmm5,%xmm0
jae    12a0 <c_update+0x160>
ucomisd 0x8(%rsp),%xmm5
jae    12a0 <c_update+0x160>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
jae    12a0 <c_update+0x160>
ucomisd 0x8(%rsp),%xmm2
jae    12a0 <c_update+0x160>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movapd %xmm5,%xmm3
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
subsd  %xmm0,%xmm3
movsd  %xmm3,0x20(%rsp)
movapd %xmm2,%xmm4
subsd  %xmm1,%xmm4
movsd  %xmm4,0x48(%rsp)
movsd  0xc60(%rip),%xmm0
movapd %xmm0,%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,0x40(%rsp)
subsd  %xmm4,%xmm0
movsd  %xmm0,0x38(%rsp)
movapd %xmm5,%xmm0
call   1060 <floor@plt>
mov    %eax,%ebp
mov    0x28(%rsp),%r14
imul   %r14d,%ebp
movsd  (%rsp),%xmm0
call   1060 <floor@plt>
add    %ebp,%eax
cltq
movzbl (%r15,%rax,1),%eax
mov    0x30(%rsp),%r13
movzbl 0x0(%r13,%r12,1),%ecx
shl    $0xb,%rax
add    %rsp,%rax
add    $0x1060,%rax
movsd  0x40(%rsp),%xmm0
mulsd  0x38(%rsp),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x10(%rsp),%xmm0
call   1060 <floor@plt>
mov    %eax,%ebp
imul   %r14d,%ebp
movsd  (%rsp),%xmm0
call   1030 <ceil@plt>
add    %ebp,%eax
cltq
movzbl (%r15,%rax,1),%eax
movzbl 0x0(%r13,%r12,1),%ecx
shl    $0xb,%rax
add    %rsp,%rax
add    $0x1060,%rax
movsd  0x38(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x10(%rsp),%xmm0
call   1030 <ceil@plt>
mov    %eax,%ebp
imul   %r14d,%ebp
movsd  (%rsp),%xmm0
call   1060 <floor@plt>
add    %ebp,%eax
cltq
movzbl (%r15,%rax,1),%eax
movzbl 0x0(%r13,%r12,1),%ecx
shl    $0xb,%rax
add    %rsp,%rax
add    $0x1060,%rax
movsd  0x40(%rsp),%xmm0
mulsd  0x48(%rsp),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x10(%rsp),%xmm0
call   1030 <ceil@plt>
mov    %eax,%ebp
imul   %r14d,%ebp
mov    0x58(%rsp),%r14
movsd  (%rsp),%xmm0
call   1030 <ceil@plt>
add    %ebp,%eax
cltq
movzbl (%r15,%rax,1),%eax
movzbl 0x0(%r13,%r12,1),%ecx
shl    $0xb,%rax
add    %rsp,%rax
add    $0x1060,%rax
movsd  0x48(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12c7 <c_update+0x187>
lea    0x1078(%rsp),%rax
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
lea    0x1060(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  -0x18(%rax,%rdx,8),%xmm0
addsd  -0x10(%rax,%rdx,8),%xmm0
addsd  -0x8(%rax,%rdx,8),%xmm0
addsd  (%rax,%rdx,8),%xmm0
add    $0x4,%rdx
cmp    $0x100,%rdx
jne    1530 <c_update+0x3f0>
add    $0x1,%rcx
add    $0x800,%rax
cmp    $0x100,%rcx
jne    1520 <c_update+0x3e0>
lea    0x860(%rsp),%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    $0x800,%edx
movsd  %xmm0,0x8(%rsp)
call   1040 <memset@plt>
lea    0x60(%rsp),%rdi
xor    %esi,%esi
mov    $0x800,%edx
call   1040 <memset@plt>
movsd  0x8(%rsp),%xmm3
movsd  0xa66(%rip),%xmm2
xorpd  %xmm1,%xmm1
jmp    15c8 <c_update+0x488>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x800,%r14
cmp    $0x100,%rbx
je     1671 <c_update+0x531>
xor    %ebp,%ebp
jmp    15e5 <c_update+0x4a5>
nopl   0x0(%rax)
addsd  0xa38(%rip),%xmm1
add    $0x1,%rbp
cmp    $0x100,%rbp
je     15b0 <c_update+0x470>
movsd  (%r14,%rbp,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rbp,8)
movsd  0x860(%rsp,%rbx,8),%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,0x860(%rsp,%rbx,8)
movsd  0x60(%rsp,%rbp,8),%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,0x60(%rsp,%rbp,8)
ucomisd %xmm2,%xmm4
jbe    15d0 <c_update+0x490>
cvttsd2si %xmm4,%edi
movsd  %xmm1,(%rsp)
movsd  %xmm4,0x10(%rsp)
call   1050 <log@plt>
movsd  %xmm0,0x18(%rsp)
mov    $0x2,%edi
call   1050 <log@plt>
movsd  0x8(%rsp),%xmm3
movsd  0x9b5(%rip),%xmm2
movsd  (%rsp),%xmm1
movsd  0x18(%rsp),%xmm4
divsd  %xmm0,%xmm4
mulsd  0x10(%rsp),%xmm4
subsd  %xmm4,%xmm1
jmp    15d8 <c_update+0x498>
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
xorpd  %xmm4,%xmm4
movsd  %xmm1,(%rsp)
jmp    16b4 <c_update+0x574>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x10(%rsp),%xmm3
addsd  0x972(%rip),%xmm3
movsd  (%rsp),%xmm0
add    $0x1,%rbx
cmp    $0x100,%rbx
je     178a <c_update+0x64a>
movsd  0x860(%rsp,%rbx,8),%xmm0
ucomisd %xmm2,%xmm0
movsd  %xmm3,0x10(%rsp)
jbe    1720 <c_update+0x5e0>
cvttsd2si %xmm0,%edi
movsd  %xmm4,0x18(%rsp)
movsd  %xmm0,0x8(%rsp)
call   1050 <log@plt>
movsd  %xmm0,0x20(%rsp)
mov    $0x2,%edi
call   1050 <log@plt>
movsd  0x18(%rsp),%xmm4
movsd  0x90c(%rip),%xmm2
movsd  0x20(%rsp),%xmm1
divsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
subsd  %xmm1,%xmm4
jmp    1728 <c_update+0x5e8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  0x8e8(%rip),%xmm4
movsd  0x60(%rsp,%rbx,8),%xmm0
ucomisd %xmm2,%xmm0
jbe    1690 <c_update+0x550>
cvttsd2si %xmm0,%edi
movsd  %xmm4,0x18(%rsp)
movsd  %xmm0,0x8(%rsp)
call   1050 <log@plt>
movsd  %xmm0,0x20(%rsp)
mov    $0x2,%edi
call   1050 <log@plt>
movsd  0x18(%rsp),%xmm4
movsd  0x89d(%rip),%xmm2
movsd  0x20(%rsp),%xmm1
divsd  %xmm0,%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm1,%xmm3
jmp    169e <c_update+0x55e>
subsd  %xmm4,%xmm0
subsd  %xmm3,%xmm0
add    $0x81068,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @c_update(i8* %0, i8* %1, double* %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca double*
%8 = alloca i32
%9 = alloca [256 x [256 x double]]
%10 = alloca i32
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca [256 x double]
%18 = alloca [256 x double]
%19 = alloca double
%20 = alloca double
%21 = alloca double
store i8* %0, i8** %5
store i8* %1, i8** %6
store double* %2, double** %7
store i32 %3, i32* %8
store i32 0, i32* %10
br label %22
22: ; preds = %40, %4
%23 = load i32, i32* %10
%24 = icmp slt i32 %23, 256
br i1 %24, label %25, label %43
25: ; preds = %22
store i32 0, i32* %11
br label %26
26: ; preds = %36, %25
%27 = load i32, i32* %11
%28 = icmp slt i32 %27, 256
br i1 %28, label %29, label %39
29: ; preds = %26
%30 = load i32, i32* %10
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %31
%33 = load i32, i32* %11
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [256 x double], [256 x double]* %32, i64 0, i64 %34
store double 0.000000e+00, double* %35
br label %36
36: ; preds = %29
%37 = load i32, i32* %11
%38 = add nsw i32 %37, 1
store i32 %38, i32* %11
br label %26
39: ; preds = %26
br label %40
40: ; preds = %39
%41 = load i32, i32* %10
%42 = add nsw i32 %41, 1
store i32 %42, i32* %10
br label %22
43: ; preds = %22
store i32 0, i32* %10
br label %44
44: ; preds = %67, %43
%45 = load i32, i32* %10
%46 = load i32, i32* %8
%47 = load i32, i32* %8
%48 = mul nsw i32 %46, %47
%49 = icmp slt i32 %45, %48
br i1 %49, label %50, label %70
50: ; preds = %44
%51 = load i8*, i8** %5
%52 = load i32, i32* %10
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %51, i64 %53
%55 = load i8, i8* %54
%56 = zext i8 %55 to i64
%57 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %56
%58 = load i8*, i8** %6
%59 = load i32, i32* %10
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %58, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i64
%64 = getelementptr inbounds [256 x double], [256 x double]* %57, i64 0, i64 %63
%65 = load double, double* %64
%66 = fadd double %65, 1.000000e+00
store double %66, double* %64
br label %67
67: ; preds = %50
%68 = load i32, i32* %10
%69 = add nsw i32 %68, 1
store i32 %69, i32* %10
br label %44
70: ; preds = %44
store i32 0, i32* %10
br label %71
71: ; preds = %275, %70
%72 = load i32, i32* %10
%73 = load i32, i32* %8
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %278
75: ; preds = %71
store i32 0, i32* %11
br label %76
76: ; preds = %271, %75
%77 = load i32, i32* %11
%78 = load i32, i32* %8
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %274
80: ; preds = %76
%81 = load double*, double** %7
%82 = getelementptr inbounds double, double* %81, i64 0
%83 = load double, double* %82
%84 = load i32, i32* %10
%85 = sitofp i32 %84 to double
%86 = load double*, double** %7
%87 = getelementptr inbounds double, double* %86, i64 1
%88 = load double, double* %87
%89 = load i32, i32* %11
%90 = sitofp i32 %89 to double
%91 = fmul double %88, %90
%92 = call double @llvm.fmuladd.f64(double %83, double %85, double %91)
%93 = load double*, double** %7
%94 = getelementptr inbounds double, double* %93, i64 2
%95 = load double, double* %94
%96 = fadd double %92, %95
store double %96, double* %12
%97 = load double*, double** %7
%98 = getelementptr inbounds double, double* %97, i64 3
%99 = load double, double* %98
%100 = load i32, i32* %10
%101 = sitofp i32 %100 to double
%102 = load double*, double** %7
%103 = getelementptr inbounds double, double* %102, i64 4
%104 = load double, double* %103
%105 = load i32, i32* %11
%106 = sitofp i32 %105 to double
%107 = fmul double %104, %106
%108 = call double @llvm.fmuladd.f64(double %99, double %101, double %107)
%109 = load double*, double** %7
%110 = getelementptr inbounds double, double* %109, i64 5
%111 = load double, double* %110
%112 = fadd double %108, %111
store double %112, double* %13
%113 = load double, double* %12
%114 = load double, double* %12
%115 = call i32 @floor(double %114)
%116 = sitofp i32 %115 to double
%117 = fsub double %113, %116
store double %117, double* %14
%118 = load double, double* %13
%119 = load double, double* %13
%120 = call i32 @floor(double %119)
%121 = sitofp i32 %120 to double
%122 = fsub double %118, %121
store double %122, double* %15
%123 = load double, double* %12
%124 = fcmp ole double %123, 0.000000e+00
br i1 %124, label %140, label %125
125: ; preds = %80
%126 = load double, double* %12
%127 = load i32, i32* %8
%128 = sub nsw i32 %127, 1
%129 = sitofp i32 %128 to double
%130 = fcmp oge double %126, %129
br i1 %130, label %140, label %131
131: ; preds = %125
%132 = load double, double* %13
%133 = fcmp ole double %132, 0.000000e+00
br i1 %133, label %140, label %134
134: ; preds = %131
%135 = load double, double* %13
%136 = load i32, i32* %8
%137 = sub nsw i32 %136, 1
%138 = sitofp i32 %137 to double
%139 = fcmp oge double %135, %138
br i1 %139, label %140, label %153
140: ; preds = %134, %131, %125, %80
%141 = load i8*, i8** %5
%142 = getelementptr inbounds i8, i8* %141, i64 0
%143 = load i8, i8* %142
%144 = zext i8 %143 to i64
%145 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %144
%146 = load i8*, i8** %5
%147 = getelementptr inbounds i8, i8* %146, i64 0
%148 = load i8, i8* %147
%149 = zext i8 %148 to i64
%150 = getelementptr inbounds [256 x double], [256 x double]* %145, i64 0, i64 %149
%151 = load double, double* %150
%152 = fadd double %151, 1.000000e+00
store double %152, double* %150
br label %270
153: ; preds = %134
%154 = load double, double* %14
%155 = fsub double 1.000000e+00, %154
%156 = load double, double* %15
%157 = fsub double 1.000000e+00, %156
%158 = load i8*, i8** %5
%159 = load double, double* %12
%160 = call i32 @floor(double %159)
%161 = load i32, i32* %8
%162 = mul nsw i32 %160, %161
%163 = load double, double* %13
%164 = call i32 @floor(double %163)
%165 = add nsw i32 %162, %164
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %158, i64 %166
%168 = load i8, i8* %167
%169 = zext i8 %168 to i64
%170 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %169
%171 = load i8*, i8** %6
%172 = load i32, i32* %10
%173 = load i32, i32* %8
%174 = mul nsw i32 %172, %173
%175 = load i32, i32* %11
%176 = add nsw i32 %174, %175
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %171, i64 %177
%179 = load i8, i8* %178
%180 = zext i8 %179 to i64
%181 = getelementptr inbounds [256 x double], [256 x double]* %170, i64 0, i64 %180
%182 = load double, double* %181
%183 = call double @llvm.fmuladd.f64(double %155, double %157, double %182)
store double %183, double* %181
%184 = load double, double* %14
%185 = load double, double* %15
%186 = fsub double 1.000000e+00, %185
%187 = load i8*, i8** %5
%188 = load double, double* %12
%189 = call i32 @floor(double %188)
%190 = load i32, i32* %8
%191 = mul nsw i32 %189, %190
%192 = load double, double* %13
%193 = call i32 @ceil(double %192)
%194 = add nsw i32 %191, %193
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i8, i8* %187, i64 %195
%197 = load i8, i8* %196
%198 = zext i8 %197 to i64
%199 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %198
%200 = load i8*, i8** %6
%201 = load i32, i32* %10
%202 = load i32, i32* %8
%203 = mul nsw i32 %201, %202
%204 = load i32, i32* %11
%205 = add nsw i32 %203, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %200, i64 %206
%208 = load i8, i8* %207
%209 = zext i8 %208 to i64
%210 = getelementptr inbounds [256 x double], [256 x double]* %199, i64 0, i64 %209
%211 = load double, double* %210
%212 = call double @llvm.fmuladd.f64(double %184, double %186, double %211)
store double %212, double* %210
%213 = load double, double* %14
%214 = fsub double 1.000000e+00, %213
%215 = load double, double* %15
%216 = load i8*, i8** %5
%217 = load double, double* %12
%218 = call i32 @ceil(double %217)
%219 = load i32, i32* %8
%220 = mul nsw i32 %218, %219
%221 = load double, double* %13
%222 = call i32 @floor(double %221)
%223 = add nsw i32 %220, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i8, i8* %216, i64 %224
%226 = load i8, i8* %225
%227 = zext i8 %226 to i64
%228 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %227
%229 = load i8*, i8** %6
%230 = load i32, i32* %10
%231 = load i32, i32* %8
%232 = mul nsw i32 %230, %231
%233 = load i32, i32* %11
%234 = add nsw i32 %232, %233
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i8, i8* %229, i64 %235
%237 = load i8, i8* %236
%238 = zext i8 %237 to i64
%239 = getelementptr inbounds [256 x double], [256 x double]* %228, i64 0, i64 %238
%240 = load double, double* %239
%241 = call double @llvm.fmuladd.f64(double %214, double %215, double %240)
store double %241, double* %239
%242 = load double, double* %14
%243 = load double, double* %15
%244 = load i8*, i8** %5
%245 = load double, double* %12
%246 = call i32 @ceil(double %245)
%247 = load i32, i32* %8
%248 = mul nsw i32 %246, %247
%249 = load double, double* %13
%250 = call i32 @ceil(double %249)
%251 = add nsw i32 %248, %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8, i8* %244, i64 %252
%254 = load i8, i8* %253
%255 = zext i8 %254 to i64
%256 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %255
%257 = load i8*, i8** %6
%258 = load i32, i32* %10
%259 = load i32, i32* %8
%260 = mul nsw i32 %258, %259
%261 = load i32, i32* %11
%262 = add nsw i32 %260, %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i8, i8* %257, i64 %263
%265 = load i8, i8* %264
%266 = zext i8 %265 to i64
%267 = getelementptr inbounds [256 x double], [256 x double]* %256, i64 0, i64 %266
%268 = load double, double* %267
%269 = call double @llvm.fmuladd.f64(double %242, double %243, double %268)
store double %269, double* %267
br label %270
270: ; preds = %153, %140
br label %271
271: ; preds = %270
%272 = load i32, i32* %11
%273 = add nsw i32 %272, 1
store i32 %273, i32* %11
br label %76
274: ; preds = %76
br label %275
275: ; preds = %274
%276 = load i32, i32* %10
%277 = add nsw i32 %276, 1
store i32 %277, i32* %10
br label %71
278: ; preds = %71
store double 0.000000e+00, double* %16
store i32 0, i32* %10
br label %279
279: ; preds = %300, %278
%280 = load i32, i32* %10
%281 = icmp slt i32 %280, 256
br i1 %281, label %282, label %303
282: ; preds = %279
store i32 0, i32* %11
br label %283
283: ; preds = %296, %282
%284 = load i32, i32* %11
%285 = icmp slt i32 %284, 256
br i1 %285, label %286, label %299
286: ; preds = %283
%287 = load i32, i32* %10
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %288
%290 = load i32, i32* %11
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [256 x double], [256 x double]* %289, i64 0, i64 %291
%293 = load double, double* %292
%294 = load double, double* %16
%295 = fadd double %294, %293
store double %295, double* %16
br label %296
296: ; preds = %286
%297 = load i32, i32* %11
%298 = add nsw i32 %297, 1
store i32 %298, i32* %11
br label %283
299: ; preds = %283
br label %300
300: ; preds = %299
%301 = load i32, i32* %10
%302 = add nsw i32 %301, 1
store i32 %302, i32* %10
br label %279
303: ; preds = %279
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %20
store double 0.000000e+00, double* %21
%304 = getelementptr inbounds [256 x double], [256 x double]* %17, i64 0, i64 0
%305 = call i32 @memset(double* %304, i32 0, i32 2048)
%306 = getelementptr inbounds [256 x double], [256 x double]* %18, i64 0, i64 0
%307 = call i32 @memset(double* %306, i32 0, i32 2048)
store i32 0, i32* %10
br label %308
308: ; preds = %387, %303
%309 = load i32, i32* %10
%310 = icmp slt i32 %309, 256
br i1 %310, label %311, label %390
311: ; preds = %308
store i32 0, i32* %11
br label %312
312: ; preds = %383, %311
%313 = load i32, i32* %11
%314 = icmp slt i32 %313, 256
br i1 %314, label %315, label %386
315: ; preds = %312
%316 = load double, double* %16
%317 = load i32, i32* %10
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %318
%320 = load i32, i32* %11
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds [256 x double], [256 x double]* %319, i64 0, i64 %321
%323 = load double, double* %322
%324 = fdiv double %323, %316
store double %324, double* %322
%325 = load i32, i32* %10
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %326
%328 = load i32, i32* %11
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [256 x double], [256 x double]* %327, i64 0, i64 %329
%331 = load double, double* %330
%332 = load i32, i32* %10
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [256 x double], [256 x double]* %17, i64 0, i64 %333
%335 = load double, double* %334
%336 = fadd double %335, %331
store double %336, double* %334
%337 = load i32, i32* %10
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %338
%340 = load i32, i32* %11
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [256 x double], [256 x double]* %339, i64 0, i64 %341
%343 = load double, double* %342
%344 = load i32, i32* %11
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds [256 x double], [256 x double]* %18, i64 0, i64 %345
%347 = load double, double* %346
%348 = fadd double %347, %343
store double %348, double* %346
%349 = load i32, i32* %10
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %350
%352 = load i32, i32* %11
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds [256 x double], [256 x double]* %351, i64 0, i64 %353
%355 = load double, double* %354
%356 = fcmp ogt double %355, 0x3E7AD7F29ABCAF48
br i1 %356, label %357, label %379
357: ; preds = %315
%358 = load i32, i32* %10
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %359
%361 = load i32, i32* %11
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds [256 x double], [256 x double]* %360, i64 0, i64 %362
%364 = load double, double* %363
%365 = fneg double %364
%366 = load i32, i32* %10
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %9, i64 0, i64 %367
%369 = load i32, i32* %11
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds [256 x double], [256 x double]* %368, i64 0, i64 %370
%372 = load double, double* %371
%373 = fptosi double %372 to i32
%374 = call double @log(i32 %373)
%375 = call double @log(i32 2)
%376 = fdiv double %374, %375
%377 = load double, double* %19
%378 = call double @llvm.fmuladd.f64(double %365, double %376, double %377)
store double %378, double* %19
br label %382
379: ; preds = %315
%380 = load double, double* %19
%381 = fadd double %380, 0.000000e+00
store double %381, double* %19
br label %382
382: ; preds = %379, %357
br label %383
383: ; preds = %382
%384 = load i32, i32* %11
%385 = add nsw i32 %384, 1
store i32 %385, i32* %11
br label %312
386: ; preds = %312
br label %387
387: ; preds = %386
%388 = load i32, i32* %10
%389 = add nsw i32 %388, 1
store i32 %389, i32* %10
br label %308
390: ; preds = %308
store i32 0, i32* %10
br label %391
391: ; preds = %445, %390
%392 = load i32, i32* %10
%393 = icmp slt i32 %392, 256
br i1 %393, label %394, label %448
394: ; preds = %391
%395 = load i32, i32* %10
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [256 x double], [256 x double]* %17, i64 0, i64 %396
%398 = load double, double* %397
%399 = fcmp ogt double %398, 0x3E7AD7F29ABCAF48
br i1 %399, label %400, label %416
400: ; preds = %394
%401 = load i32, i32* %10
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds [256 x double], [256 x double]* %17, i64 0, i64 %402
%404 = load double, double* %403
%405 = fneg double %404
%406 = load i32, i32* %10
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds [256 x double], [256 x double]* %17, i64 0, i64 %407
%409 = load double, double* %408
%410 = fptosi double %409 to i32
%411 = call double @log(i32 %410)
%412 = call double @log(i32 2)
%413 = fdiv double %411, %412
%414 = load double, double* %20
%415 = call double @llvm.fmuladd.f64(double %405, double %413, double %414)
store double %415, double* %20
br label %419
416: ; preds = %394
%417 = load double, double* %20
%418 = fadd double %417, 0.000000e+00
store double %418, double* %20
br label %419
419: ; preds = %416, %400
%420 = load i32, i32* %10
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds [256 x double], [256 x double]* %18, i64 0, i64 %421
%423 = load double, double* %422
%424 = fcmp ogt double %423, 0x3E7AD7F29ABCAF48
br i1 %424, label %425, label %441
425: ; preds = %419
%426 = load i32, i32* %10
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds [256 x double], [256 x double]* %18, i64 0, i64 %427
%429 = load double, double* %428
%430 = fneg double %429
%431 = load i32, i32* %10
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds [256 x double], [256 x double]* %18, i64 0, i64 %432
%434 = load double, double* %433
%435 = fptosi double %434 to i32
%436 = call double @log(i32 %435)
%437 = call double @log(i32 2)
%438 = fdiv double %436, %437
%439 = load double, double* %21
%440 = call double @llvm.fmuladd.f64(double %430, double %438, double %439)
store double %440, double* %21
br label %444
441: ; preds = %419
%442 = load double, double* %21
%443 = fadd double %442, 0.000000e+00
store double %443, double* %21
br label %444
444: ; preds = %441, %425
br label %445
445: ; preds = %444
%446 = load i32, i32* %10
%447 = add nsw i32 %446, 1
store i32 %447, i32* %10
br label %391
448: ; preds = %391
%449 = load double, double* %19
%450 = load double, double* %20
%451 = fsub double %449, %450
%452 = load double, double* %21
%453 = fsub double %451, %452
ret double %453
}

LLVM IR (-O2):
define double @c_update(i8* nocapture %0, i8* nocapture %1, double* nocapture %2, i32 %3) {
%5 = alloca [256 x [256 x double]]
%6 = bitcast [256 x [256 x double]]* %5 to i8*
%7 = alloca [256 x double]
%8 = alloca [256 x double]
%9 = mul i32 %3, %3
%10 = icmp eq i32 %9, 0
br i1 %10, label %30, label %11
11: ; preds = %4
%12 = zext i32 %9 to i64
%13 = and i64 %12, 1
%14 = icmp eq i32 %9, 1
br i1 %14, label %17, label %15
15: ; preds = %11
%16 = and i64 %12, 4294967294
br label %42
17: ; preds = %42, %11
%18 = phi i64 [ 0, %11 ], [ %64, %42 ]
%19 = icmp eq i64 %13, 0
br i1 %19, label %30, label %20
20: ; preds = %17
%21 = getelementptr inbounds i8, i8* %0, i64 %18
%22 = load i8, i8* %21
%23 = zext i8 %22 to i64
%24 = getelementptr inbounds i8, i8* %1, i64 %18
%25 = load i8, i8* %24
%26 = zext i8 %25 to i64
%27 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %23, i64 %26
%28 = load double, double* %27
%29 = fadd double %28, 1.000000e+00
store double %29, double* %27
br label %30
30: ; preds = %20, %17, %4
%31 = icmp sgt i32 %3, 0
br i1 %31, label %32, label %170
32: ; preds = %30
%33 = getelementptr inbounds double, double* %2, i64 1
%34 = getelementptr inbounds double, double* %2, i64 2
%35 = getelementptr inbounds double, double* %2, i64 3
%36 = getelementptr inbounds double, double* %2, i64 4
%37 = getelementptr inbounds double, double* %2, i64 5
%38 = add nsw i32 %3, -1
%39 = sitofp i32 %38 to double
%40 = zext i32 %3 to i64
%41 = zext i32 %3 to i64
br label %67
42: ; preds = %42, %15
%43 = phi i64 [ 0, %15 ], [ %64, %42 ]
%44 = phi i64 [ 0, %15 ], [ %65, %42 ]
%45 = getelementptr inbounds i8, i8* %0, i64 %43
%46 = load i8, i8* %45
%47 = zext i8 %46 to i64
%48 = getelementptr inbounds i8, i8* %1, i64 %43
%49 = load i8, i8* %48
%50 = zext i8 %49 to i64
%51 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %47, i64 %50
%52 = load double, double* %51
%53 = fadd double %52, 1.000000e+00
store double %53, double* %51
%54 = or i64 %43, 1
%55 = getelementptr inbounds i8, i8* %0, i64 %54
%56 = load i8, i8* %55
%57 = zext i8 %56 to i64
%58 = getelementptr inbounds i8, i8* %1, i64 %54
%59 = load i8, i8* %58
%60 = zext i8 %59 to i64
%61 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %57, i64 %60
%62 = load double, double* %61
%63 = fadd double %62, 1.000000e+00
store double %63, double* %61
%64 = add nuw nsw i64 %43, 2
%65 = add i64 %44, 2
%66 = icmp eq i64 %65, %16
br i1 %66, label %17, label %42
67: ; preds = %167, %32
%68 = phi i64 [ 0, %32 ], [ %168, %167 ]
%69 = trunc i64 %68 to i32
%70 = sitofp i32 %69 to double
%71 = mul nsw i64 %68, %40
br label %72
72: ; preds = %67, %164
%73 = phi i64 [ 0, %67 ], [ %165, %164 ]
%74 = load double, double* %2
%75 = load double, double* %33
%76 = trunc i64 %73 to i32
%77 = sitofp i32 %76 to double
%78 = fmul double %75, %77
%79 = tail call double @llvm.fmuladd.f64(double %74, double %70, double %78)
%80 = load double, double* %34
%81 = fadd double %80, %79
%82 = load double, double* %35
%83 = load double, double* %36
%84 = fmul double %83, %77
%85 = tail call double @llvm.fmuladd.f64(double %82, double %70, double %84)
%86 = load double, double* %37
%87 = fadd double %86, %85
%88 = tail call i32 @floor(double %81)
%89 = sitofp i32 %88 to double
%90 = fsub double %81, %89
%91 = tail call i32 @floor(double %87)
%92 = sitofp i32 %91 to double
%93 = fsub double %87, %92
%94 = fcmp ugt double %81, 0.000000e+00
br i1 %94, label %95, label %101
95: ; preds = %72
%96 = fcmp ult double %81, %39
%97 = fcmp ugt double %87, 0.000000e+00
%98 = select i1 %96, i1 %97, i1 false
%99 = fcmp ult double %87, %39
%100 = select i1 %98, i1 %99, i1 false
br i1 %100, label %107, label %101
101: ; preds = %95, %72
%102 = load i8, i8* %0
%103 = zext i8 %102 to i64
%104 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %103, i64 %103
%105 = load double, double* %104
%106 = fadd double %105, 1.000000e+00
store double %106, double* %104
br label %164
107: ; preds = %95
%108 = fsub double 1.000000e+00, %90
%109 = fsub double 1.000000e+00, %93
%110 = tail call i32 @floor(double %81)
%111 = mul nsw i32 %110, %3
%112 = tail call i32 @floor(double %87)
%113 = add nsw i32 %111, %112
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %0, i64 %114
%116 = load i8, i8* %115
%117 = zext i8 %116 to i64
%118 = add nuw nsw i64 %73, %71
%119 = getelementptr inbounds i8, i8* %1, i64 %118
%120 = load i8, i8* %119
%121 = zext i8 %120 to i64
%122 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %117, i64 %121
%123 = load double, double* %122
%124 = tail call double @llvm.fmuladd.f64(double %108, double %109, double %123)
store double %124, double* %122
%125 = tail call i32 @floor(double %81)
%126 = mul nsw i32 %125, %3
%127 = tail call i32 @ceil(double %87)
%128 = add nsw i32 %126, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %0, i64 %129
%131 = load i8, i8* %130
%132 = zext i8 %131 to i64
%133 = load i8, i8* %119
%134 = zext i8 %133 to i64
%135 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %132, i64 %134
%136 = load double, double* %135
%137 = tail call double @llvm.fmuladd.f64(double %90, double %109, double %136)
store double %137, double* %135
%138 = tail call i32 @ceil(double %81)
%139 = mul nsw i32 %138, %3
%140 = tail call i32 @floor(double %87)
%141 = add nsw i32 %139, %140
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %0, i64 %142
%144 = load i8, i8* %143
%145 = zext i8 %144 to i64
%146 = load i8, i8* %119
%147 = zext i8 %146 to i64
%148 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %145, i64 %147
%149 = load double, double* %148
%150 = tail call double @llvm.fmuladd.f64(double %108, double %93, double %149)
store double %150, double* %148
%151 = tail call i32 @ceil(double %81)
%152 = mul nsw i32 %151, %3
%153 = tail call i32 @ceil(double %87)
%154 = add nsw i32 %152, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %0, i64 %155
%157 = load i8, i8* %156
%158 = zext i8 %157 to i64
%159 = load i8, i8* %119
%160 = zext i8 %159 to i64
%161 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %158, i64 %160
%162 = load double, double* %161
%163 = tail call double @llvm.fmuladd.f64(double %90, double %93, double %162)
store double %163, double* %161
br label %164
164: ; preds = %107, %101
%165 = add nuw nsw i64 %73, 1
%166 = icmp eq i64 %165, %41
br i1 %166, label %167, label %72
167: ; preds = %164
%168 = add nuw nsw i64 %68, 1
%169 = icmp eq i64 %168, %41
br i1 %169, label %170, label %67
170: ; preds = %167, %30
br label %171
171: ; preds = %170, %194
%172 = phi i64 [ %195, %194 ], [ 0, %170 ]
%173 = phi double [ %191, %194 ], [ 0.000000e+00, %170 ]
br label %174
174: ; preds = %174, %171
%175 = phi i64 [ 0, %171 ], [ %192, %174 ]
%176 = phi double [ %173, %171 ], [ %191, %174 ]
%177 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %172, i64 %175
%178 = load double, double* %177
%179 = fadd double %176, %178
%180 = or i64 %175, 1
%181 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %172, i64 %180
%182 = load double, double* %181
%183 = fadd double %179, %182
%184 = or i64 %175, 2
%185 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %172, i64 %184
%186 = load double, double* %185
%187 = fadd double %183, %186
%188 = or i64 %175, 3
%189 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %172, i64 %188
%190 = load double, double* %189
%191 = fadd double %187, %190
%192 = add nuw nsw i64 %175, 4
%193 = icmp eq i64 %192, 256
br i1 %193, label %194, label %174
194: ; preds = %174
%195 = add nuw nsw i64 %172, 1
%196 = icmp eq i64 %195, 256
br i1 %196, label %197, label %171
197: ; preds = %194
%198 = bitcast [256 x double]* %7 to i8*
%199 = bitcast [256 x double]* %8 to i8*
%200 = getelementptr inbounds [256 x double], [256 x double]* %7, i64 0, i64 0
%201 = call i32 @memset(double* %200, i32 0, i32 2048)
%202 = getelementptr inbounds [256 x double], [256 x double]* %8, i64 0, i64 0
%203 = call i32 @memset(double* %202, i32 0, i32 2048)
br label %204
204: ; preds = %197, %233
%205 = phi i64 [ 0, %197 ], [ %234, %233 ]
%206 = phi double [ 0.000000e+00, %197 ], [ %230, %233 ]
%207 = getelementptr inbounds [256 x double], [256 x double]* %7, i64 0, i64 %205
br label %208
208: ; preds = %204, %229
%209 = phi i64 [ 0, %204 ], [ %231, %229 ]
%210 = phi double [ %206, %204 ], [ %230, %229 ]
%211 = getelementptr inbounds [256 x [256 x double]], [256 x [256 x double]]* %5, i64 0, i64 %205, i64 %209
%212 = load double, double* %211
%213 = fdiv double %212, %191
store double %213, double* %211
%214 = load double, double* %207
%215 = fadd double %213, %214
store double %215, double* %207
%216 = getelementptr inbounds [256 x double], [256 x double]* %8, i64 0, i64 %209
%217 = load double, double* %216
%218 = fadd double %213, %217
store double %218, double* %216
%219 = fcmp ogt double %213, 0x3E7AD7F29ABCAF48
br i1 %219, label %220, label %227
220: ; preds = %208
%221 = fneg double %213
%222 = fptosi double %213 to i32
%223 = call double @log(i32 %222)
%224 = call double @log(i32 2)
%225 = fdiv double %223, %224
%226 = call double @llvm.fmuladd.f64(double %221, double %225, double %210)
br label %229
227: ; preds = %208
%228 = fadd double %210, 0.000000e+00
br label %229
229: ; preds = %220, %227
%230 = phi double [ %226, %220 ], [ %228, %227 ]
%231 = add nuw nsw i64 %209, 1
%232 = icmp eq i64 %231, 256
br i1 %232, label %233, label %208
233: ; preds = %229
%234 = add nuw nsw i64 %205, 1
%235 = icmp eq i64 %234, 256
br i1 %235, label %236, label %204
236: ; preds = %233, %266
%237 = phi i64 [ %268, %266 ], [ 0, %233 ]
%238 = phi double [ %267, %266 ], [ 0.000000e+00, %233 ]
%239 = phi double [ %253, %266 ], [ 0.000000e+00, %233 ]
%240 = getelementptr inbounds [256 x double], [256 x double]* %7, i64 0, i64 %237
%241 = load double, double* %240
%242 = fcmp ogt double %241, 0x3E7AD7F29ABCAF48
br i1 %242, label %243, label %250
243: ; preds = %236
%244 = fneg double %241
%245 = fptosi double %241 to i32
%246 = call double @log(i32 %245)
%247 = call double @log(i32 2)
%248 = fdiv double %246, %247
%249 = call double @llvm.fmuladd.f64(double %244, double %248, double %239)
br label %252
250: ; preds = %236
%251 = fadd double %239, 0.000000e+00
br label %252
252: ; preds = %250, %243
%253 = phi double [ %249, %243 ], [ %251, %250 ]
%254 = getelementptr inbounds [256 x double], [256 x double]* %8, i64 0, i64 %237
%255 = load double, double* %254
%256 = fcmp ogt double %255, 0x3E7AD7F29ABCAF48
br i1 %256, label %257, label %264
257: ; preds = %252
%258 = fneg double %255
%259 = fptosi double %255 to i32
%260 = call double @log(i32 %259)
%261 = call double @log(i32 2)
%262 = fdiv double %260, %261
%263 = call double @llvm.fmuladd.f64(double %258, double %262, double %238)
br label %266
264: ; preds = %252
%265 = fadd double %238, 0.000000e+00
br label %266
266: ; preds = %257, %264
%267 = phi double [ %263, %257 ], [ %265, %264 ]
%268 = add nuw nsw i64 %237, 1
%269 = icmp eq i64 %268, 256
br i1 %269, label %270, label %236
270: ; preds = %266
%271 = fsub double %230, %253
%272 = fsub double %271, %267
ret double %272
}