#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double sqrt(double);
void extendsurface(int nx, int ny, int nz, float *E, char *c, float *Ex,
                   char *cx) {
  int ix, iy, iz, i, j, k;
  float R[27], s, t;
  for (i = 0; i < 3; i++)
    for (j = 0; j < 3; j++)
      for (k = 0; k < 3; k++) {
        R[i + 3 * (j + 3 * k)] =
            (i != 1 ? (j != 1 ? (k != 1 ? 1.0 / sqrt(3.0) : 1.0 / sqrt(2.0))
                              : (k != 1 ? 1.0 / sqrt(2.0) : 1))
                    : (j != 1 ? (k != 1 ? 1.0 / sqrt(2.0) : 1)
                              : (k != 1 ? 1 : 0)));
      }
  for (iz = 0; iz < nz; iz++) {
    for (ix = 0; ix < nx; ix++) {
      for (iy = 0; iy < ny; iy++) {
        if (iz == 0 || ix == 0 || iy == 0 || iz == nz - 1 || ix == nx - 1 ||
            iy == ny - 1) {
          Ex[iy + ny * (ix + iz * nx)] = E[iy + ny * (ix + iz * nx)];
          cx[iy + ny * (ix + iz * nx)] = 0;
        } else {
          if (!c[iy + ny * (ix + iz * nx)]) {
            s = 0;
            for (i = -1; i < 2; i++) {
              for (j = -1; j < 2; j++) {
                for (k = -1; k < 2; k++) {
                  s += R[(i + 1) + 3 * ((j + 1) + 3 * (k + 1))] *
                       c[iy + j + ny * (ix + i + nx * (iz + k))];
                }
              }
            }
            if (s) {
              t = 0;
              for (i = -1; i <= 1; i++) {
                for (j = -1; j <= 1; j++) {
                  for (k = -1; k <= 1; k++) {
                    t += (R[(i + 1) + 3 * ((j + 1) + 3 * (k + 1))] *
                          E[iy + j + ny * (ix + i + nx * (iz + k))] *
                          c[iy + j + ny * (ix + i + nx * (iz + k))]);
                  }
                }
              }
              Ex[iy + ny * (ix + iz * nx)] = t / s;
              cx[iy + ny * (ix + iz * nx)] = 1;
            } else {
              Ex[iy + ny * (ix + iz * nx)] = E[iy + ny * (ix + iz * nx)];
              cx[iy + ny * (ix + iz * nx)] = 0;
            }
          } else {
            Ex[iy + ny * (ix + iz * nx)] = E[iy + ny * (ix + iz * nx)];
            cx[iy + ny * (ix + iz * nx)] = 1;
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<extendsurface>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    1343 <extendsurface+0x233>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x3,-0x3c(%rbp)
jge    1330 <extendsurface+0x220>
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    131d <extendsurface+0x20d>
cmpl   $0x1,-0x38(%rbp)
je     1254 <extendsurface+0x144>
cmpl   $0x1,-0x3c(%rbp)
je     11e7 <extendsurface+0xd7>
cmpl   $0x1,-0x40(%rbp)
je     11ae <extendsurface+0x9e>
movsd  0xe83(%rip),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe63(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    11d2 <extendsurface+0xc2>
movsd  0xe52(%rip),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe3a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    123f <extendsurface+0x12f>
cmpl   $0x1,-0x40(%rbp)
je     121a <extendsurface+0x10a>
movsd  0xe0f(%rip),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xdf7(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    122f <extendsurface+0x11f>
movsd  0xdde(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    122f <extendsurface+0x11f>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    12e7 <extendsurface+0x1d7>
cmpl   $0x1,-0x3c(%rbp)
je     12bb <extendsurface+0x1ab>
cmpl   $0x1,-0x40(%rbp)
je     1291 <extendsurface+0x181>
movsd  0xd98(%rip),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xd80(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    12a6 <extendsurface+0x196>
movsd  0xd67(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    12a6 <extendsurface+0x196>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    12d7 <extendsurface+0x1c7>
mov    -0x40(%rbp),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x1,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x38(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
cltq
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    115d <extendsurface+0x4d>
jmp    1322 <extendsurface+0x212>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    114c <extendsurface+0x3c>
jmp    1335 <extendsurface+0x225>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    113b <extendsurface+0x2b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17e9 <extendsurface+0x6d9>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17d6 <extendsurface+0x6c6>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17c3 <extendsurface+0x6b3>
cmpl   $0x0,-0x34(%rbp)
je     13cd <extendsurface+0x2bd>
cmpl   $0x0,-0x2c(%rbp)
je     13cd <extendsurface+0x2bd>
cmpl   $0x0,-0x30(%rbp)
je     13cd <extendsurface+0x2bd>
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     13cd <extendsurface+0x2bd>
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     13cd <extendsurface+0x2bd>
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    143a <extendsurface+0x32a>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    17b0 <extendsurface+0x6a0>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    1743 <extendsurface+0x633>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movl   $0xffffffff,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jge    1547 <extendsurface+0x437>
movl   $0xffffffff,-0x3c(%rbp)
cmpl   $0x2,-0x3c(%rbp)
jge    1534 <extendsurface+0x424>
movl   $0xffffffff,-0x40(%rbp)
cmpl   $0x2,-0x40(%rbp)
jge    1521 <extendsurface+0x411>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    %edx,%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
cltq
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x3c(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
add    -0x38(%rbp),%esi
mov    -0x4(%rbp),%edi
mov    -0x34(%rbp),%r8d
add    -0x40(%rbp),%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm2
movss  -0xb4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1496 <extendsurface+0x386>
jmp    1526 <extendsurface+0x416>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1485 <extendsurface+0x375>
jmp    1539 <extendsurface+0x429>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1474 <extendsurface+0x364>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1566 <extendsurface+0x456>
jp     1566 <extendsurface+0x456>
jmp    16d6 <extendsurface+0x5c6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movl   $0xffffffff,-0x38(%rbp)
cmpl   $0x1,-0x38(%rbp)
jg     167c <extendsurface+0x56c>
movl   $0xffffffff,-0x3c(%rbp)
cmpl   $0x1,-0x3c(%rbp)
jg     1669 <extendsurface+0x559>
movl   $0xffffffff,-0x40(%rbp)
cmpl   $0x1,-0x40(%rbp)
jg     1656 <extendsurface+0x546>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%edx
add    $0x1,%edx
imul   $0x3,%edx,%edx
add    %edx,%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
cltq
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x3c(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
add    -0x38(%rbp),%esi
mov    -0x4(%rbp),%edi
mov    -0x34(%rbp),%r8d
add    -0x40(%rbp),%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x3c(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
add    -0x38(%rbp),%esi
mov    -0x4(%rbp),%edi
mov    -0x34(%rbp),%r8d
add    -0x40(%rbp),%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm2
movss  -0xb8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    159a <extendsurface+0x48a>
jmp    165b <extendsurface+0x54b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1589 <extendsurface+0x479>
jmp    166e <extendsurface+0x55e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1578 <extendsurface+0x468>
movss  -0xb8(%rbp),%xmm0
ff
divss  -0xb4(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    173e <extendsurface+0x62e>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    17ab <extendsurface+0x69b>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
mov    -0x2c(%rbp),%esi
mov    -0x34(%rbp),%edi
imul   -0x4(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    17b0 <extendsurface+0x6a0>
jmp    17b5 <extendsurface+0x6a5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1370 <extendsurface+0x260>
jmp    17c8 <extendsurface+0x6b8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    135d <extendsurface+0x24d>
jmp    17db <extendsurface+0x6cb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    134a <extendsurface+0x23a>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<extendsurface>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r8,0x8(%rsp)
mov    %rsi,-0x30(%rsp)
mov    %rdi,-0x68(%rsp)
movabs $0x3f3504f33f13cd3a,%rax
04 35 3f
mov    %rax,0xd0(%rsp)
movaps 0xec7(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xecb(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0xecc(%rip),%xmm1
movaps %xmm1,0xa0(%rsp)
movaps 0xecd(%rip),%xmm1
movaps %xmm1,0xc0(%rsp)
movaps %xmm1,0x90(%rsp)
movaps %xmm0,0xb0(%rsp)
movl   $0x3f13cd3a,0xd8(%rsp)
3a cd 13 3f
test   %edx,%edx
jle    16cb <extendsurface+0x5cb>
mov    %rcx,%r14
mov    0x120(%rsp),%rbp
lea    -0x1(%rdx),%eax
mov    %rax,0x60(%rsp)
mov    -0x68(%rsp),%rsi
lea    -0x1(%rsi),%eax
mov    %rax,0x58(%rsp)
mov    -0x30(%rsp),%rax
lea    -0x1(%rax),%edi
mov    %rdi,0x50(%rsp)
movslq %esi,%r8
movslq %eax,%rbx
mov    %edx,%eax
mov    %rax,0x28(%rsp)
mov    %r8,%rax
not    %rax
imul   %rbx,%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
mov    %rdx,-0x38(%rsp)
mov    %rbx,%rdi
imul   %r8,%rdi
mov    %rcx,%rdx
sub    %rbx,%rdx
mov    %rdx,-0x40(%rsp)
lea    -0x1(%r8),%rdx
imul   %rbx,%rdx
lea    (%rcx,%rdx,1),%rsi
mov    %rsi,-0x48(%rsp)
lea    (%r14,%rax,4),%rax
mov    %rax,-0x50(%rsp)
lea    0x0(,%rbx,4),%rax
mov    %r14,%rsi
mov    %rax,0x40(%rsp)
sub    %rax,%rsi
mov    %rsi,-0x58(%rsp)
lea    (%r14,%rdx,4),%rax
mov    %rax,-0x60(%rsp)
xorps  %xmm0,%xmm0
mov    %r8,0x10(%rsp)
mov    %r8d,%eax
mov    %rax,0x38(%rsp)
mov    %ebx,%eax
mov    %rax,0x68(%rsp)
mov    %rdi,0x20(%rsp)
lea    0x0(,%rdi,4),%rax
mov    %rax,0x18(%rsp)
xor    %eax,%eax
mov    %rax,-0x78(%rsp)
mov    %r14,0x48(%rsp)
jmp    12b4 <extendsurface+0x1b4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x78(%rsp),%rdx
add    $0x1,%rdx
mov    0x20(%rsp),%rax
add    %rax,-0x38(%rsp)
add    %rax,-0x40(%rsp)
add    %rax,-0x48(%rsp)
mov    0x18(%rsp),%rax
add    %rax,-0x50(%rsp)
add    %rax,-0x58(%rsp)
add    %rax,-0x60(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x78(%rsp)
cmp    0x28(%rsp),%rdx
je     16cb <extendsurface+0x5cb>
cmpl   $0x0,-0x68(%rsp)
jle    1270 <extendsurface+0x170>
mov    -0x78(%rsp),%rax
imul   0x10(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    -0x60(%rsp),%rax
mov    %rax,(%rsp)
mov    -0x58(%rsp),%rax
mov    %rax,-0x8(%rsp)
mov    -0x50(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    -0x48(%rsp),%rax
mov    %rax,-0x18(%rsp)
mov    -0x40(%rsp),%rax
mov    %rax,-0x20(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,-0x28(%rsp)
xor    %eax,%eax
mov    %rax,-0x70(%rsp)
jmp    134e <extendsurface+0x24e>
nop
mov    -0x70(%rsp),%rdx
add    $0x1,%rdx
add    %rbx,-0x28(%rsp)
add    %rbx,-0x20(%rsp)
add    %rbx,-0x18(%rsp)
mov    0x40(%rsp),%rax
add    %rax,-0x10(%rsp)
add    %rax,-0x8(%rsp)
add    %rax,(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x70(%rsp)
cmp    0x38(%rsp),%rdx
je     1270 <extendsurface+0x170>
cmpl   $0x0,-0x30(%rsp)
jle    1310 <extendsurface+0x210>
cmpq   $0x0,-0x78(%rsp)
sete   %al
mov    -0x70(%rsp),%rdx
test   %rdx,%rdx
sete   %cl
or     %al,%cl
mov    %cl,-0x79(%rsp)
mov    0x30(%rsp),%rax
lea    (%rdx,%rax,1),%rcx
imul   %rbx,%rcx
mov    (%rsp),%r13
mov    -0x8(%rsp),%rdi
mov    -0x10(%rsp),%r10
mov    -0x18(%rsp),%r12
mov    -0x20(%rsp),%r15
mov    -0x28(%rsp),%r11
xor    %eax,%eax
jmp    13da <extendsurface+0x2da>
nopl   (%rax)
movss  (%r14,%r8,4),%xmm2
xor    %esi,%esi
movss  %xmm2,(%r9,%r8,4)
mov    %sil,0x0(%rbp,%r8,1)
add    $0x1,%rax
add    $0x1,%r11
add    $0x1,%r15
add    $0x1,%r12
add    $0x4,%r10
add    $0x4,%rdi
add    $0x4,%r13
cmp    0x68(%rsp),%rax
je     1310 <extendsurface+0x210>
test   %rax,%rax
sete   %dl
or     -0x79(%rsp),%dl
lea    (%rax,%rcx,1),%r8
test   %dl,%dl
jne    13a0 <extendsurface+0x2a0>
mov    -0x78(%rsp),%rdx
cmp    0x60(%rsp),%rdx
je     13a0 <extendsurface+0x2a0>
mov    -0x70(%rsp),%rdx
cmp    0x58(%rsp),%rdx
je     13a0 <extendsurface+0x2a0>
cmp    0x50(%rsp),%rax
je     13a0 <extendsurface+0x2a0>
mov    0x8(%rsp),%rdx
cmpb   $0x0,(%rdx,%r8,1)
je     1422 <extendsurface+0x322>
movss  (%r14,%r8,4),%xmm2
mov    $0x1,%sil
jmp    13a8 <extendsurface+0x2a8>
xorps  %xmm1,%xmm1
mov    $0xfffffffffffffffd,%rbp
xor    %esi,%esi
xchg   %ax,%ax
movsbl -0x1(%r11,%rsi,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
mulss  0x7c(%rsp,%rbp,4),%xmm2
movsbl -0x1(%r15,%rsi,1),%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
addss  %xmm1,%xmm2
mulss  0xa0(%rsp,%rbp,4),%xmm3
movsbl -0x1(%r12,%rsi,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
addss  %xmm2,%xmm3
mulss  0xc4(%rsp,%rbp,4),%xmm1
addss  %xmm3,%xmm1
movsbl (%r11,%rsi,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
movsbl (%r15,%rsi,1),%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
mulss  0x88(%rsp,%rbp,4),%xmm2
mulss  0xac(%rsp,%rbp,4),%xmm3
movsbl (%r12,%rsi,1),%edx
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
mulss  0xd0(%rsp,%rbp,4),%xmm4
movsbl 0x1(%r11,%rsi,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
addss  %xmm3,%xmm4
mulss  0x94(%rsp,%rbp,4),%xmm2
addss  %xmm4,%xmm2
movsbl 0x1(%r15,%rsi,1),%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
movsbl 0x1(%r12,%rsi,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  0xb8(%rsp,%rbp,4),%xmm3
mulss  0xdc(%rsp,%rbp,4),%xmm1
addss  %xmm2,%xmm3
addss  %xmm3,%xmm1
add    %rbx,%rsi
inc    %rbp
jne    1430 <extendsurface+0x330>
ucomiss %xmm0,%xmm1
jne    152b <extendsurface+0x42b>
jnp    16b6 <extendsurface+0x5b6>
mov    %r9,%rbp
xorps  %xmm2,%xmm2
mov    $0xfffffffffffffffd,%r14
xor    %r9d,%r9d
nopl   0x0(%rax,%rax,1)
movss  0x7c(%rsp,%r14,4),%xmm3
mulss  -0x4(%r10,%r9,4),%xmm3
movsbl -0x1(%r11,%r9,1),%edx
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
movss  0x88(%rsp,%r14,4),%xmm5
mulss  %xmm3,%xmm4
addss  %xmm2,%xmm4
movss  0xa0(%rsp,%r14,4),%xmm2
movsbl -0x1(%r15,%r9,1),%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
mulss  -0x4(%rdi,%r9,4),%xmm2
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
movss  0xc4(%rsp,%r14,4),%xmm2
mulss  -0x4(%r13,%r9,4),%xmm2
movsbl -0x1(%r12,%r9,1),%edx
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
mulss  (%r10,%r9,4),%xmm5
movsbl (%r11,%r9,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
movss  0xac(%rsp,%r14,4),%xmm3
mulss  (%rdi,%r9,4),%xmm3
movsbl (%r15,%r9,1),%edx
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
mulss  %xmm3,%xmm4
movss  0xd0(%rsp,%r14,4),%xmm3
mulss  0x0(%r13,%r9,4),%xmm3
movsbl (%r12,%r9,1),%edx
xorps  %xmm5,%xmm5
cvtsi2ss %edx,%xmm5
addss  %xmm2,%xmm4
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
movss  0x94(%rsp,%r14,4),%xmm2
movsbl 0x1(%r11,%r9,1),%edx
xorps  %xmm3,%xmm3
cvtsi2ss %edx,%xmm3
mulss  0x4(%r10,%r9,4),%xmm2
mulss  %xmm2,%xmm3
addss  %xmm5,%xmm3
movss  0xb8(%rsp,%r14,4),%xmm2
mulss  0x4(%rdi,%r9,4),%xmm2
movsbl 0x1(%r15,%r9,1),%edx
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
movss  0xdc(%rsp,%r14,4),%xmm3
mulss  0x4(%r13,%r9,4),%xmm3
movsbl 0x1(%r12,%r9,1),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
add    %rbx,%r9
inc    %r14
jne    1540 <extendsurface+0x440>
divss  %xmm1,%xmm2
mov    $0x1,%sil
mov    %rbp,%r9
mov    0x48(%rsp),%r14
mov    0x120(%rsp),%rbp
jmp    13a8 <extendsurface+0x2a8>
movss  (%r14,%r8,4),%xmm2
xor    %esi,%esi
mov    0x120(%rsp),%rbp
jmp    13a8 <extendsurface+0x2a8>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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