#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 */
int /*<<< orphan*/ do_vect(double **, unsigned long);
int /*<<< orphan*/ error_density(int, char *);
int gidz_general(unsigned int, unsigned int, unsigned int, unsigned int,
                 unsigned int);
int /*<<< orphan*/ printf(char *, double, double, double, ...);
void shrink_margin(double **outmap, unsigned *out_extx, unsigned *out_exty,
                   unsigned *out_extz, double *out_origx, double *out_origy,
                   double *out_origz, unsigned long *out_nvox, double *inmap,
                   unsigned in_extx, unsigned in_exty, unsigned in_extz,
                   double in_origx, double in_origy, double in_origz,
                   double widthx, double widthy, double widthz) {
  unsigned m, p, q, sx, sy, sz;
  unsigned minx, miny, minz, maxx, maxy, maxz;
  int margin[6];
  unsigned indz, indx, indy;
  unsigned long index_old, index_new;
  char *program = "lib_vwk";
  maxx = 0;
  maxy = 0;
  maxz = 0;
  minx = in_extx - 1;
  miny = in_exty - 1;
  minz = in_extz - 1;
  for (q = 0; q < in_extz; q++)
    for (m = 0; m < in_exty; m++)
      for (p = 0; p < in_extx; p++)
        if (*(inmap + gidz_general(q, m, p, in_exty, in_extx)) > 0) {
          if (p <= minx)
            minx = p;
          if (p >= maxx)
            maxx = p;
          if (m <= miny)
            miny = m;
          if (m >= maxy)
            maxy = m;
          if (q <= minz)
            minz = q;
          if (q >= maxz)
            maxz = q;
        }
  if (maxx < minx) {
    error_density(17020, program);
  }
  margin[1] = in_extx - maxx - 1;
  margin[3] = in_exty - maxy - 1;
  margin[5] = in_extz - maxz - 1;
  margin[0] = minx;
  margin[2] = miny;
  margin[4] = minz;
  p = in_extx - (margin[0] + margin[1]);
  m = in_exty - (margin[2] + margin[3]);
  q = in_extz - (margin[4] + margin[5]);
  if (2 * (p / 2) == p) {
    p++;
    if (margin[0] > 0)
      margin[0]--;
  }
  if (2 * (m / 2) == m) {
    m++;
    if (margin[2] > 0)
      margin[2]--;
  }
  if (2 * (q / 2) == q) {
    q++;
    if (margin[4] > 0)
      margin[4]--;
  }
  *out_nvox = p * m * q;
  do_vect(outmap, *out_nvox);
  for (indz = margin[4]; indz < in_extz - margin[5]; indz++)
    for (indy = margin[2]; indy < in_exty - margin[3]; indy++)
      for (indx = margin[0]; indx < in_extx - margin[1]; indx++) {
        index_new = p * m * (indz - margin[4]) + p * (indy - margin[2]) +
                    (indx - margin[0]);
        index_old = in_extx * in_exty * indz + in_extx * indy + indx;
        *(*outmap + index_new) = *(inmap + index_old);
      }
  sx = in_extx;
  sy = in_exty;
  sz = in_extz;
  *out_extx = p;
  *out_exty = m;
  *out_extz = q;
  *out_origx = in_origx + margin[0] * widthx;
  *out_origy = in_origy + margin[2] * widthy;
  *out_origz = in_origz + margin[4] * widthz;
  printf("lib_vwk> Map size changed from %d x %d x %d to %d x %d x %d.\n", sx,
         sy, sz, *out_extx, *out_exty, *out_extz);
  printf("lib_vwk> New map origin (coord of first voxel): (%.3f,%.3f,%.3f)\n",
         *out_origx, *out_origy, *out_origz);
}


x86 assembly (clang, -O0):
<shrink_margin>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
movsd  %xmm4,-0x58(%rbp)
movsd  %xmm5,-0x60(%rbp)
lea    0xe63(%rip),%rax
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
movl   $0x0,-0x90(%rbp)
mov    0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x38(%rbp),%eax
jae    1319 <shrink_margin+0x1d9>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x30(%rbp),%eax
jae    1306 <shrink_margin+0x1c6>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x28(%rbp),%eax
jae    12f3 <shrink_margin+0x1b3>
mov    0x20(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x6c(%rbp),%edi
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
call   1050 <gidz_general@plt>
mov    %eax,%ecx
mov    -0xe0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12e0 <shrink_margin+0x1a0>
mov    -0x68(%rbp),%eax
cmp    -0x7c(%rbp),%eax
ja     1269 <shrink_margin+0x129>
mov    -0x68(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x88(%rbp),%eax
jb     1281 <shrink_margin+0x141>
mov    -0x68(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x80(%rbp),%eax
ja     1293 <shrink_margin+0x153>
mov    -0x64(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jb     12ab <shrink_margin+0x16b>
mov    -0x64(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x84(%rbp),%eax
ja     12c3 <shrink_margin+0x183>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x90(%rbp),%eax
jb     12db <shrink_margin+0x19b>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    12e0 <shrink_margin+0x1a0>
jmp    12e5 <shrink_margin+0x1a5>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    120d <shrink_margin+0xcd>
jmp    12f8 <shrink_margin+0x1b8>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11fa <shrink_margin+0xba>
jmp    130b <shrink_margin+0x1cb>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11e7 <shrink_margin+0xa7>
mov    -0x88(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jae    1339 <shrink_margin+0x1f9>
mov    -0xd8(%rbp),%rsi
mov    $0x427c,%edi
call   1040 <error_density@plt>
mov    0x28(%rbp),%eax
sub    -0x88(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    0x30(%rbp),%eax
sub    -0x8c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    0x38(%rbp),%eax
sub    -0x90(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    0x28(%rbp),%eax
mov    -0xb0(%rbp),%ecx
add    -0xac(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    0x30(%rbp),%eax
mov    -0xa8(%rbp),%ecx
add    -0xa4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%eax
mov    -0xa0(%rbp),%ecx
add    -0x9c(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
cmp    -0x68(%rbp),%eax
jne    1405 <shrink_margin+0x2c5>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0xb0(%rbp)
jle    1400 <shrink_margin+0x2c0>
mov    -0xb0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb0(%rbp)
jmp    1405 <shrink_margin+0x2c5>
mov    -0x64(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
cmp    -0x64(%rbp),%eax
jne    1441 <shrink_margin+0x301>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0xa8(%rbp)
jle    143c <shrink_margin+0x2fc>
mov    -0xa8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa8(%rbp)
jmp    1441 <shrink_margin+0x301>
mov    -0x6c(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
cmp    -0x6c(%rbp),%eax
jne    147d <shrink_margin+0x33d>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0xa0(%rbp)
jle    1478 <shrink_margin+0x338>
mov    -0xa0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa0(%rbp)
jmp    147d <shrink_margin+0x33d>
mov    -0x68(%rbp),%eax
imul   -0x64(%rbp),%eax
imul   -0x6c(%rbp),%eax
mov    %eax,%eax
mov    %eax,%ecx
mov    0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rdi
mov    0x18(%rbp),%rax
mov    (%rax),%rsi
call   1060 <do_vect@plt>
mov    -0xa0(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    0x38(%rbp),%ecx
sub    -0x9c(%rbp),%ecx
cmp    %ecx,%eax
jae    15df <shrink_margin+0x49f>
mov    -0xa8(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    0x30(%rbp),%ecx
sub    -0xa4(%rbp),%ecx
cmp    %ecx,%eax
jae    15c6 <shrink_margin+0x486>
mov    -0xb0(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    0x28(%rbp),%ecx
sub    -0xac(%rbp),%ecx
cmp    %ecx,%eax
jae    15ad <shrink_margin+0x46d>
mov    -0x68(%rbp),%eax
imul   -0x64(%rbp),%eax
mov    -0xb4(%rbp),%ecx
sub    -0xa0(%rbp),%ecx
imul   %ecx,%eax
mov    -0x68(%rbp),%ecx
mov    -0xbc(%rbp),%edx
sub    -0xa8(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0xb8(%rbp),%ecx
sub    -0xb0(%rbp),%ecx
add    %ecx,%eax
mov    %eax,%eax
mov    %rax,-0xd0(%rbp)
mov    0x28(%rbp),%eax
imul   0x30(%rbp),%eax
imul   -0xb4(%rbp),%eax
mov    0x28(%rbp),%ecx
imul   -0xbc(%rbp),%ecx
add    %ecx,%eax
add    -0xb8(%rbp),%eax
mov    %eax,%eax
mov    %rax,-0xc8(%rbp)
mov    0x20(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0xd0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    14f5 <shrink_margin+0x3b5>
jmp    15b2 <shrink_margin+0x472>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    14d2 <shrink_margin+0x392>
jmp    15cb <shrink_margin+0x48b>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    14af <shrink_margin+0x36f>
mov    0x28(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x30(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    0x38(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x68(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x64(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x6c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x38(%rbp),%xmm1
cvtsi2sdl -0xb0(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm1
cvtsi2sdl -0xa8(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x48(%rbp),%xmm1
cvtsi2sdl -0xa0(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x70(%rbp),%eax
cvtsi2sd %rax,%xmm0
mov    -0x74(%rbp),%eax
cvtsi2sd %rax,%xmm1
mov    -0x78(%rbp),%eax
cvtsi2sd %rax,%xmm2
mov    -0x10(%rbp),%rax
mov    (%rax),%esi
mov    -0x18(%rbp),%rax
mov    (%rax),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
lea    0x965(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm2
lea    0x97d(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<shrink_margin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
movsd  %xmm5,0xf8(%rsp)
movsd  %xmm4,0xe8(%rsp)
movsd  %xmm3,0xd8(%rsp)
movsd  %xmm2,0xf0(%rsp)
movsd  %xmm1,0xe0(%rsp)
movsd  %xmm0,0xd0(%rsp)
mov    %r9,0x120(%rsp)
mov    %r8,0x118(%rsp)
mov    %rcx,0xc8(%rsp)
mov    %rdx,0x108(%rsp)
mov    %rsi,0x100(%rsp)
mov    %rdi,0xb0(%rsp)
mov    0x1d8(%rsp),%ecx
mov    0x1d0(%rsp),%edx
mov    0x1c8(%rsp),%r8d
mov    0x1c0(%rsp),%rax
mov    %rax,0xc0(%rsp)
mov    0x1b8(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x1b0(%rsp),%rax
mov    %rax,0x110(%rsp)
lea    -0x1(%r8),%eax
mov    %rax,0x20(%rsp)
mov    %rdx,0x30(%rsp)
lea    -0x1(%rdx),%r13d
test   %ecx,%ecx
mov    %rcx,0x88(%rsp)
mov    %r8,0x28(%rsp)
je     12fd <shrink_margin+0x1bd>
lea    -0x1(%rcx),%r14d
xor    %r15d,%r15d
xor    %eax,%eax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %r12d,%r12d
jmp    1252 <shrink_margin+0x112>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15d
cmp    0x88(%rsp),%r15d
je     1314 <shrink_margin+0x1d4>
cmpl   $0x0,0x30(%rsp)
je     1240 <shrink_margin+0x100>
xor    %ebx,%ebx
jmp    1269 <shrink_margin+0x129>
nopl   (%rax)
add    $0x1,%ebx
cmp    0x30(%rsp),%ebx
je     1240 <shrink_margin+0x100>
test   %r8d,%r8d
je     1260 <shrink_margin+0x120>
xor    %ebp,%ebp
jmp    128d <shrink_margin+0x14d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%ebp
mov    0x28(%rsp),%r8
cmp    %ebp,%r8d
je     1260 <shrink_margin+0x120>
mov    %r15d,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    0x30(%rsp),%rcx
call   1050 <gidz_general@plt>
cltq
mov    0xc0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
ucomisd 0xd4b(%rip),%xmm0
jbe    1280 <shrink_margin+0x140>
mov    0x20(%rsp),%rax
cmp    %eax,%ebp
cmovbe %ebp,%eax
mov    %rax,0x20(%rsp)
cmp    %r12d,%ebp
cmovae %ebp,%r12d
cmp    %r13d,%ebx
cmovbe %ebx,%r13d
mov    0x40(%rsp),%rax
cmp    %eax,%ebx
cmovae %ebx,%eax
mov    %rax,0x40(%rsp)
cmp    %r14d,%r15d
cmovbe %r15d,%r14d
mov    0x38(%rsp),%rax
cmp    %eax,%r15d
cmovae %r15d,%eax
mov    %rax,0x38(%rsp)
jmp    1280 <shrink_margin+0x140>
mov    $0xffffffff,%r14d
xor    %r12d,%r12d
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    0x20(%rsp),%r15
cmp    %r15d,%r12d
jae    132f <shrink_margin+0x1ef>
lea    0xce3(%rip),%rsi
mov    $0x427c,%edi
call   1040 <error_density@plt>
add    $0x1,%r12d
mov    %r12d,0x4c(%rsp)
mov    0x40(%rsp),%rax
lea    0x1(%rax),%ecx
mov    0x38(%rsp),%rax
lea    0x1(%rax),%esi
mov    %r12d,%edx
sub    %r15d,%edx
mov    %ecx,0x7c(%rsp)
sub    %r13d,%ecx
mov    %esi,%eax
mov    %esi,%r12d
mov    %r14d,%ebp
sub    %r14d,%eax
xor    %esi,%esi
test   $0x1,%dl
sete   %sil
test   %r15d,%r15d
setg   %bl
and    %sil,%bl
movzbl %bl,%ebx
mov    %r15d,%edi
mov    %rbx,%r14
sub    %ebx,%edi
mov    %edi,0x8(%rsp)
add    %edx,%esi
xor    %edi,%edi
test   $0x1,%cl
sete   %dil
test   %r13d,%r13d
setg   %dl
and    %dil,%dl
movzbl %dl,%ebx
mov    %r13d,%edx
sub    %ebx,%edx
mov    %edx,0x10(%rsp)
add    %ecx,%edi
xor    %edx,%edx
test   $0x1,%al
sete   %dl
test   %ebp,%ebp
setg   %cl
and    %dl,%cl
movzbl %cl,%ecx
sub    %ecx,%ebp
add    %eax,%edx
mov    %esi,0xc(%rsp)
mov    %edi,0x6c(%rsp)
imul   %edi,%esi
mov    %esi,0x18(%rsp)
mov    %edx,0x70(%rsp)
imul   %edx,%esi
mov    0x50(%rsp),%rax
mov    %rsi,(%rax)
mov    0xb0(%rsp),%rdi
call   1060 <do_vect@plt>
mov    0x28(%rsp),%eax
mov    %rax,0x50(%rsp)
mov    %ebp,0x14(%rsp)
cmp    %r12d,%ebp
mov    0xc0(%rsp),%rbp
jae    1894 <shrink_margin+0x754>
mov    %r14,%r12
neg    %r12d
neg    %ebx
mov    0x8(%rsp),%edi
mov    0x4c(%rsp),%r8d
mov    %rdi,%rax
not    %rax
add    %r8,%rax
mov    %rax,0xa8(%rsp)
mov    0x14(%rsp),%edx
mov    %edx,%eax
mov    0x30(%rsp),%rcx
imul   %ecx,%eax
add    %eax,%r13d
add    %ebx,%r13d
mov    0x28(%rsp),%rax
imul   %eax,%r13d
mov    %r13,0x98(%rsp)
lea    (%r15,%r13,1),%esi
add    %r12d,%esi
imul   %eax,%ecx
mov    %rcx,0x90(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0x160(%rsp)
lea    0x0(,%rdi,8),%rax
mov    %rbp,%rcx
sub    %rax,%rcx
mov    %rcx,0x168(%rsp)
mov    %r8,%rax
sub    %rdi,%rax
lea    -0x4(%rax),%rcx
mov    %rcx,0x158(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rax,0xb8(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rdi,%r13
mov    %rax,0x148(%rsp)
add    %rdi,%rax
mov    %rax,0x140(%rsp)
mov    %rcx,%rax
mov    %rcx,0x150(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x128(%rsp)
add    %r15d,%r12d
neg    %r12d
mov    %r12,0xa0(%rsp)
mov    0x18(%rsp),%eax
mov    %rax,0x138(%rsp)
mov    0xc(%rsp),%eax
mov    %rax,0x170(%rsp)
xor    %eax,%eax
mov    %rax,0x60(%rsp)
movl   $0x4,0x1c(%rsp)
mov    %esi,0x74(%rsp)
mov    %esi,0x48(%rsp)
mov    %edx,%eax
mov    %rax,0x58(%rsp)
jmp    1574 <shrink_margin+0x434>
nopw   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rsi
lea    0x1(%rsi),%eax
mov    0x60(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x60(%rsp)
mov    0x90(%rsp),%rcx
add    %ecx,0x48(%rsp)
mov    0x1c(%rsp),%edx
add    0x18(%rsp),%edx
mov    %edx,0x1c(%rsp)
add    %rcx,0x98(%rsp)
mov    0x138(%rsp),%rcx
add    %rcx,0xa0(%rsp)
cmp    0x38(%rsp),%esi
mov    %rax,0x58(%rsp)
je     1894 <shrink_margin+0x754>
mov    0x10(%rsp),%eax
cmp    0x7c(%rsp),%eax
jae    1520 <shrink_margin+0x3e0>
mov    0x18(%rsp),%eax
mov    %eax,%ecx
mov    0x60(%rsp),%rdx
imul   %edx,%ecx
mov    %ecx,0x84(%rsp)
mov    0x90(%rsp),%rcx
imul   %edx,%ecx
add    0x74(%rsp),%ecx
mov    %ecx,0x80(%rsp)
mov    0x58(%rsp),%rcx
mov    %ecx,%edx
sub    0x14(%rsp),%edx
imul   %eax,%edx
sub    0x8(%rsp),%edx
mov    %edx,0x78(%rsp)
imul   0x30(%rsp),%ecx
mov    %rcx,0x130(%rsp)
xor    %r11d,%r11d
mov    0xa0(%rsp),%r9
mov    0x98(%rsp),%r10
mov    0x1c(%rsp),%eax
mov    %eax,0x20(%rsp)
mov    0x48(%rsp),%r12d
mov    0x10(%rsp),%eax
mov    %eax,%r14d
jmp    1630 <shrink_margin+0x4f0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%r14),%eax
add    $0x1,%r11d
add    0x28(%rsp),%r12d
mov    0xc(%rsp),%ecx
add    %ecx,0x20(%rsp)
add    0x50(%rsp),%r10
add    0x170(%rsp),%r9
cmp    0x40(%rsp),%r14d
mov    %eax,%r14d
je     1520 <shrink_margin+0x3e0>
mov    0x4c(%rsp),%eax
cmp    %eax,0x8(%rsp)
jae    1600 <shrink_margin+0x4c0>
mov    0xb0(%rsp),%rax
mov    (%rax),%rsi
mov    %r13,%rcx
cmpq   $0x4,0xb8(%rsp)
jae    1700 <shrink_margin+0x5c0>
mov    %r8d,%edi
sub    %ecx,%edi
mov    %rcx,%rax
not    %rax
add    %r8,%rax
and    $0x3,%rdi
je     168d <shrink_margin+0x54d>
nopl   0x0(%rax,%rax,1)
lea    (%r9,%rcx,1),%edx
lea    (%r10,%rcx,1),%ebx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1670 <shrink_margin+0x530>
cmp    $0x3,%rax
jb     1600 <shrink_margin+0x4c0>
nopw   0x0(%rax,%rax,1)
lea    (%r9,%rcx,1),%rax
mov    %eax,%edx
lea    (%r10,%rcx,1),%rdi
mov    %edi,%ebx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
lea    0x1(%rax),%edx
lea    0x1(%rdi),%ebx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
lea    0x2(%rax),%edx
lea    0x2(%rdi),%ebx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x3,%eax
add    $0x3,%edi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    16a0 <shrink_margin+0x560>
jmp    1600 <shrink_margin+0x4c0>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%eax
mov    %eax,%r15d
imul   %r11d,%r15d
add    0x84(%rsp),%r15d
mov    %r11d,%eax
imul   0x28(%rsp),%eax
add    0x80(%rsp),%eax
mov    %eax,%ecx
mov    0xa8(%rsp),%rbx
add    %ebx,%ecx
setb   %dil
mov    %r15d,%edx
mov    %r13,%rcx
add    %ebx,%edx
jb     1657 <shrink_margin+0x517>
mov    0xa8(%rsp),%rdx
shr    $0x20,%rdx
mov    %r13,%rcx
jne    1657 <shrink_margin+0x517>
mov    %r13,%rcx
test   %dil,%dil
jne    1657 <shrink_margin+0x517>
mov    %r13,%rcx
test   %rdx,%rdx
jne    1657 <shrink_margin+0x517>
lea    (%r8,%rax,1),%rcx
mov    0x168(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%rsi,%r15,8),%rdi
cmp    %rcx,%rdi
jae    17b0 <shrink_margin+0x670>
add    %r8,%r15
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    0x160(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rcx,%r15,8),%rdi
mov    %r13,%rcx
cmp    %rdi,%rax
jb     1657 <shrink_margin+0x517>
cmpq   $0x4,0x158(%rsp)
jae    17c0 <shrink_margin+0x680>
xor    %r15d,%r15d
jmp    1822 <shrink_margin+0x6e2>
mov    0x128(%rsp),%rcx
mov    0x20(%rsp),%eax
mov    %r12d,%edi
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x4(%rax),%ebx
mov    %edi,%edx
movups 0x0(%rbp,%rdx,8),%xmm0
movups 0x10(%rbp,%rdx,8),%xmm1
movups %xmm0,(%rsi,%rbx,8)
movups %xmm1,0x10(%rsi,%rbx,8)
mov    %eax,%edx
lea    0x4(%rdi),%ebx
movupd 0x0(%rbp,%rbx,8),%xmm0
movups 0x10(%rbp,%rbx,8),%xmm1
movupd %xmm0,(%rsi,%rdx,8)
movups %xmm1,0x10(%rsi,%rdx,8)
add    $0x8,%r15
add    $0x8,%edi
add    $0x8,%eax
add    $0xfffffffffffffffe,%rcx
jne    17e0 <shrink_margin+0x6a0>
testb  $0x1,0x150(%rsp)
01
je     1871 <shrink_margin+0x731>
mov    %r14,%rdx
mov    %edx,%eax
sub    0x10(%rsp),%eax
imul   0xc(%rsp),%eax
add    0x78(%rsp),%eax
mov    0x130(%rsp),%rcx
lea    (%r14,%rcx,1),%edx
imul   0x28(%rsp),%edx
add    0x8(%rsp),%r15d
add    %r15d,%eax
add    %edx,%r15d
movupd 0x0(%rbp,%r15,8),%xmm0
movups 0x10(%rbp,%r15,8),%xmm1
movupd %xmm0,(%rsi,%rax,8)
movups %xmm1,0x10(%rsi,%rax,8)
mov    0x140(%rsp),%rcx
mov    0x148(%rsp),%rax
cmp    %rax,0xb8(%rsp)
je     1600 <shrink_margin+0x4c0>
jmp    1657 <shrink_margin+0x517>
mov    0x100(%rsp),%rdx
mov    0xc(%rsp),%eax
mov    %eax,(%rdx)
mov    0x108(%rsp),%rdi
mov    0x6c(%rsp),%eax
mov    %eax,(%rdi)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%rsp),%xmm0
mov    0xc8(%rsp),%rax
mov    0x70(%rsp),%ecx
mov    %ecx,(%rax)
mulsd  0xd8(%rsp),%xmm0
addsd  0xd0(%rsp),%xmm0
mov    0x118(%rsp),%r14
movsd  %xmm0,(%r14)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rsp),%xmm0
mulsd  0xe8(%rsp),%xmm0
addsd  0xe0(%rsp),%xmm0
mov    0x120(%rsp),%rbx
movsd  %xmm0,(%rbx)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x14(%rsp),%xmm0
mulsd  0xf8(%rsp),%xmm0
addsd  0xf0(%rsp),%xmm0
mov    0x110(%rsp),%rbp
movsd  %xmm0,0x0(%rbp)
xorps  %xmm0,%xmm0
cvtsi2sdq 0x50(%rsp),%xmm0
mov    0x30(%rsp),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
mov    0x88(%rsp),%eax
cvtsi2sd %rax,%xmm2
mov    (%rdx),%esi
mov    (%rdi),%edx
lea    0x6ae(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  (%r14),%xmm0
movsd  (%rbx),%xmm1
movsd  0x0(%rbp),%xmm2
lea    0x6d0(%rip),%rdi
mov    $0x3,%al
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [8 x i8] c"lib_vwk\00"
@.str.1 = [62 x i8] c"lib_vwk> Map size changed from %d x %d x %d to %d x %d x %d.\0A\00"
@.str.2 = [66 x i8] c"lib_vwk> New map origin (coord of first voxel): (%.3f,%.3f,%.3f)\0A\00"
define void @shrink_margin(double** %0, i32* %1, i32* %2, i32* %3, double* %4, double* %5, double* %6, i64* %7, double* %8, i32 %9, i32 %10, i32 %11, double %12, double %13, double %14, double %15, double %16, double %17) {
%19 = alloca double**
%20 = alloca i32*
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca i64*
%27 = alloca double*
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca [6 x i32]
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i64
%54 = alloca i64
%55 = alloca i8*
store double** %0, double*** %19
store i32* %1, i32** %20
store i32* %2, i32** %21
store i32* %3, i32** %22
store double* %4, double** %23
store double* %5, double** %24
store double* %6, double** %25
store i64* %7, i64** %26
store double* %8, double** %27
store i32 %9, i32* %28
store i32 %10, i32* %29
store i32 %11, i32* %30
store double %12, double* %31
store double %13, double* %32
store double %14, double* %33
store double %15, double* %34
store double %16, double* %35
store double %17, double* %36
store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8** %55
store i32 0, i32* %46
store i32 0, i32* %47
store i32 0, i32* %48
%56 = load i32, i32* %28
%57 = sub i32 %56, 1
store i32 %57, i32* %43
%58 = load i32, i32* %29
%59 = sub i32 %58, 1
store i32 %59, i32* %44
%60 = load i32, i32* %30
%61 = sub i32 %60, 1
store i32 %61, i32* %45
store i32 0, i32* %39
br label %62
62: ; preds = %134, %18
%63 = load i32, i32* %39
%64 = load i32, i32* %30
%65 = icmp ult i32 %63, %64
br i1 %65, label %66, label %137
66: ; preds = %62
store i32 0, i32* %37
br label %67
67: ; preds = %130, %66
%68 = load i32, i32* %37
%69 = load i32, i32* %29
%70 = icmp ult i32 %68, %69
br i1 %70, label %71, label %133
71: ; preds = %67
store i32 0, i32* %38
br label %72
72: ; preds = %126, %71
%73 = load i32, i32* %38
%74 = load i32, i32* %28
%75 = icmp ult i32 %73, %74
br i1 %75, label %76, label %129
76: ; preds = %72
%77 = load double*, double** %27
%78 = load i32, i32* %39
%79 = load i32, i32* %37
%80 = load i32, i32* %38
%81 = load i32, i32* %29
%82 = load i32, i32* %28
%83 = call i32 @gidz_general(i32 %78, i32 %79, i32 %80, i32 %81, i32 %82)
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds double, double* %77, i64 %84
%86 = load double, double* %85
%87 = fcmp ogt double %86, 0.000000e+00
br i1 %87, label %88, label %125
88: ; preds = %76
%89 = load i32, i32* %38
%90 = load i32, i32* %43
%91 = icmp ule i32 %89, %90
br i1 %91, label %92, label %94
92: ; preds = %88
%93 = load i32, i32* %38
store i32 %93, i32* %43
br label %94
94: ; preds = %92, %88
%95 = load i32, i32* %38
%96 = load i32, i32* %46
%97 = icmp uge i32 %95, %96
br i1 %97, label %98, label %100
98: ; preds = %94
%99 = load i32, i32* %38
store i32 %99, i32* %46
br label %100
100: ; preds = %98, %94
%101 = load i32, i32* %37
%102 = load i32, i32* %44
%103 = icmp ule i32 %101, %102
br i1 %103, label %104, label %106
104: ; preds = %100
%105 = load i32, i32* %37
store i32 %105, i32* %44
br label %106
106: ; preds = %104, %100
%107 = load i32, i32* %37
%108 = load i32, i32* %47
%109 = icmp uge i32 %107, %108
br i1 %109, label %110, label %112
110: ; preds = %106
%111 = load i32, i32* %37
store i32 %111, i32* %47
br label %112
112: ; preds = %110, %106
%113 = load i32, i32* %39
%114 = load i32, i32* %45
%115 = icmp ule i32 %113, %114
br i1 %115, label %116, label %118
116: ; preds = %112
%117 = load i32, i32* %39
store i32 %117, i32* %45
br label %118
118: ; preds = %116, %112
%119 = load i32, i32* %39
%120 = load i32, i32* %48
%121 = icmp uge i32 %119, %120
br i1 %121, label %122, label %124
122: ; preds = %118
%123 = load i32, i32* %39
store i32 %123, i32* %48
br label %124
124: ; preds = %122, %118
br label %125
125: ; preds = %124, %76
br label %126
126: ; preds = %125
%127 = load i32, i32* %38
%128 = add i32 %127, 1
store i32 %128, i32* %38
br label %72
129: ; preds = %72
br label %130
130: ; preds = %129
%131 = load i32, i32* %37
%132 = add i32 %131, 1
store i32 %132, i32* %37
br label %67
133: ; preds = %67
br label %134
134: ; preds = %133
%135 = load i32, i32* %39
%136 = add i32 %135, 1
store i32 %136, i32* %39
br label %62
137: ; preds = %62
%138 = load i32, i32* %46
%139 = load i32, i32* %43
%140 = icmp ult i32 %138, %139
br i1 %140, label %141, label %144
141: ; preds = %137
%142 = load i8*, i8** %55
%143 = call i32 @error_density(i32 17020, i8* %142)
br label %144
144: ; preds = %141, %137
%145 = load i32, i32* %28
%146 = load i32, i32* %46
%147 = sub i32 %145, %146
%148 = sub i32 %147, 1
%149 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 1
store i32 %148, i32* %149
%150 = load i32, i32* %29
%151 = load i32, i32* %47
%152 = sub i32 %150, %151
%153 = sub i32 %152, 1
%154 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 3
store i32 %153, i32* %154
%155 = load i32, i32* %30
%156 = load i32, i32* %48
%157 = sub i32 %155, %156
%158 = sub i32 %157, 1
%159 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 5
store i32 %158, i32* %159
%160 = load i32, i32* %43
%161 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 0
store i32 %160, i32* %161
%162 = load i32, i32* %44
%163 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 2
store i32 %162, i32* %163
%164 = load i32, i32* %45
%165 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 4
store i32 %164, i32* %165
%166 = load i32, i32* %28
%167 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 0
%168 = load i32, i32* %167
%169 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 1
%170 = load i32, i32* %169
%171 = add nsw i32 %168, %170
%172 = sub i32 %166, %171
store i32 %172, i32* %38
%173 = load i32, i32* %29
%174 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 2
%175 = load i32, i32* %174
%176 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 3
%177 = load i32, i32* %176
%178 = add nsw i32 %175, %177
%179 = sub i32 %173, %178
store i32 %179, i32* %37
%180 = load i32, i32* %30
%181 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 4
%182 = load i32, i32* %181
%183 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 5
%184 = load i32, i32* %183
%185 = add nsw i32 %182, %184
%186 = sub i32 %180, %185
store i32 %186, i32* %39
%187 = load i32, i32* %38
%188 = udiv i32 %187, 2
%189 = mul i32 2, %188
%190 = load i32, i32* %38
%191 = icmp eq i32 %189, %190
br i1 %191, label %192, label %203
192: ; preds = %144
%193 = load i32, i32* %38
%194 = add i32 %193, 1
store i32 %194, i32* %38
%195 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 0
%196 = load i32, i32* %195
%197 = icmp sgt i32 %196, 0
br i1 %197, label %198, label %202
198: ; preds = %192
%199 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 0
%200 = load i32, i32* %199
%201 = add nsw i32 %200, -1
store i32 %201, i32* %199
br label %202
202: ; preds = %198, %192
br label %203
203: ; preds = %202, %144
%204 = load i32, i32* %37
%205 = udiv i32 %204, 2
%206 = mul i32 2, %205
%207 = load i32, i32* %37
%208 = icmp eq i32 %206, %207
br i1 %208, label %209, label %220
209: ; preds = %203
%210 = load i32, i32* %37
%211 = add i32 %210, 1
store i32 %211, i32* %37
%212 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 2
%213 = load i32, i32* %212
%214 = icmp sgt i32 %213, 0
br i1 %214, label %215, label %219
215: ; preds = %209
%216 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 2
%217 = load i32, i32* %216
%218 = add nsw i32 %217, -1
store i32 %218, i32* %216
br label %219
219: ; preds = %215, %209
br label %220
220: ; preds = %219, %203
%221 = load i32, i32* %39
%222 = udiv i32 %221, 2
%223 = mul i32 2, %222
%224 = load i32, i32* %39
%225 = icmp eq i32 %223, %224
br i1 %225, label %226, label %237
226: ; preds = %220
%227 = load i32, i32* %39
%228 = add i32 %227, 1
store i32 %228, i32* %39
%229 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 4
%230 = load i32, i32* %229
%231 = icmp sgt i32 %230, 0
br i1 %231, label %232, label %236
232: ; preds = %226
%233 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 4
%234 = load i32, i32* %233
%235 = add nsw i32 %234, -1
store i32 %235, i32* %233
br label %236
236: ; preds = %232, %226
br label %237
237: ; preds = %236, %220
%238 = load i32, i32* %38
%239 = load i32, i32* %37
%240 = mul i32 %238, %239
%241 = load i32, i32* %39
%242 = mul i32 %240, %241
%243 = zext i32 %242 to i64
%244 = load i64*, i64** %26
store i64 %243, i64* %244
%245 = load double**, double*** %19
%246 = load i64*, i64** %26
%247 = load i64, i64* %246
%248 = call i32 @do_vect(double** %245, i64 %247)
%249 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 4
%250 = load i32, i32* %249
store i32 %250, i32* %50
br label %251
251: ; preds = %328, %237
%252 = load i32, i32* %50
%253 = load i32, i32* %30
%254 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 5
%255 = load i32, i32* %254
%256 = sub i32 %253, %255
%257 = icmp ult i32 %252, %256
br i1 %257, label %258, label %331
258: ; preds = %251
%259 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 2
%260 = load i32, i32* %259
store i32 %260, i32* %52
br label %261
261: ; preds = %324, %258
%262 = load i32, i32* %52
%263 = load i32, i32* %29
%264 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 3
%265 = load i32, i32* %264
%266 = sub i32 %263, %265
%267 = icmp ult i32 %262, %266
br i1 %267, label %268, label %327
268: ; preds = %261
%269 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 0
%270 = load i32, i32* %269
store i32 %270, i32* %51
br label %271
271: ; preds = %320, %268
%272 = load i32, i32* %51
%273 = load i32, i32* %28
%274 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 1
%275 = load i32, i32* %274
%276 = sub i32 %273, %275
%277 = icmp ult i32 %272, %276
br i1 %277, label %278, label %323
278: ; preds = %271
%279 = load i32, i32* %38
%280 = load i32, i32* %37
%281 = mul i32 %279, %280
%282 = load i32, i32* %50
%283 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 4
%284 = load i32, i32* %283
%285 = sub i32 %282, %284
%286 = mul i32 %281, %285
%287 = load i32, i32* %38
%288 = load i32, i32* %52
%289 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 2
%290 = load i32, i32* %289
%291 = sub i32 %288, %290
%292 = mul i32 %287, %291
%293 = add i32 %286, %292
%294 = load i32, i32* %51
%295 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 0
%296 = load i32, i32* %295
%297 = sub i32 %294, %296
%298 = add i32 %293, %297
%299 = zext i32 %298 to i64
store i64 %299, i64* %54
%300 = load i32, i32* %28
%301 = load i32, i32* %29
%302 = mul i32 %300, %301
%303 = load i32, i32* %50
%304 = mul i32 %302, %303
%305 = load i32, i32* %28
%306 = load i32, i32* %52
%307 = mul i32 %305, %306
%308 = add i32 %304, %307
%309 = load i32, i32* %51
%310 = add i32 %308, %309
%311 = zext i32 %310 to i64
store i64 %311, i64* %53
%312 = load double*, double** %27
%313 = load i64, i64* %53
%314 = getelementptr inbounds double, double* %312, i64 %313
%315 = load double, double* %314
%316 = load double**, double*** %19
%317 = load double*, double** %316
%318 = load i64, i64* %54
%319 = getelementptr inbounds double, double* %317, i64 %318
store double %315, double* %319
br label %320
320: ; preds = %278
%321 = load i32, i32* %51
%322 = add i32 %321, 1
store i32 %322, i32* %51
br label %271
323: ; preds = %271
br label %324
324: ; preds = %323
%325 = load i32, i32* %52
%326 = add i32 %325, 1
store i32 %326, i32* %52
br label %261
327: ; preds = %261
br label %328
328: ; preds = %327
%329 = load i32, i32* %50
%330 = add i32 %329, 1
store i32 %330, i32* %50
br label %251
331: ; preds = %251
%332 = load i32, i32* %28
store i32 %332, i32* %40
%333 = load i32, i32* %29
store i32 %333, i32* %41
%334 = load i32, i32* %30
store i32 %334, i32* %42
%335 = load i32, i32* %38
%336 = load i32*, i32** %20
store i32 %335, i32* %336
%337 = load i32, i32* %37
%338 = load i32*, i32** %21
store i32 %337, i32* %338
%339 = load i32, i32* %39
%340 = load i32*, i32** %22
store i32 %339, i32* %340
%341 = load double, double* %31
%342 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 0
%343 = load i32, i32* %342
%344 = sitofp i32 %343 to double
%345 = load double, double* %34
%346 = call double @llvm.fmuladd.f64(double %344, double %345, double %341)
%347 = load double*, double** %23
store double %346, double* %347
%348 = load double, double* %32
%349 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 2
%350 = load i32, i32* %349
%351 = sitofp i32 %350 to double
%352 = load double, double* %35
%353 = call double @llvm.fmuladd.f64(double %351, double %352, double %348)
%354 = load double*, double** %24
store double %353, double* %354
%355 = load double, double* %33
%356 = getelementptr inbounds [6 x i32], [6 x i32]* %49, i64 0, i64 4
%357 = load i32, i32* %356
%358 = sitofp i32 %357 to double
%359 = load double, double* %36
%360 = call double @llvm.fmuladd.f64(double %358, double %359, double %355)
%361 = load double*, double** %25
store double %360, double* %361
%362 = load i32, i32* %40
%363 = uitofp i32 %362 to double
%364 = load i32, i32* %41
%365 = uitofp i32 %364 to double
%366 = load i32, i32* %42
%367 = uitofp i32 %366 to double
%368 = load i32*, i32** %20
%369 = load i32, i32* %368
%370 = load i32*, i32** %21
%371 = load i32, i32* %370
%372 = load i32*, i32** %22
%373 = load i32, i32* %372
%374 = call i32 (i8*, double, double, double, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.1, i64 0, i64 0), double %363, double %365, double %367, i32 %369, i32 %371, i32 %373)
%375 = load double*, double** %23
%376 = load double, double* %375
%377 = load double*, double** %24
%378 = load double, double* %377
%379 = load double*, double** %25
%380 = load double, double* %379
%381 = call i32 (i8*, double, double, double, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0), double %376, double %378, double %380)
ret void
}

LLVM IR (-O2):
@.str = [8 x i8] c"lib_vwk\00"
@.str.1 = [62 x i8] c"lib_vwk> Map size changed from %d x %d x %d to %d x %d x %d.\0A\00"
@.str.2 = [66 x i8] c"lib_vwk> New map origin (coord of first voxel): (%.3f,%.3f,%.3f)\0A\00"
define void @shrink_margin(double** %0, i32* nocapture %1, i32* nocapture %2, i32* nocapture %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, i64* nocapture writeonly %7, double* nocapture %8, i32 %9, i32 %10, i32 %11, double %12, double %13, double %14, double %15, double %16, double %17) {
%19 = add i32 %9, -1
%20 = add i32 %10, -1
%21 = icmp eq i32 %11, 0
br i1 %21, label %95, label %22
22: ; preds = %18
%23 = add i32 %11, -1
%24 = icmp eq i32 %10, 0
%25 = icmp eq i32 %9, 0
br label %26
26: ; preds = %22, %86
%27 = phi i32 [ 0, %22 ], [ %93, %86 ]
%28 = phi i32 [ %19, %22 ], [ %92, %86 ]
%29 = phi i32 [ %20, %22 ], [ %91, %86 ]
%30 = phi i32 [ %23, %22 ], [ %90, %86 ]
%31 = phi i32 [ 0, %22 ], [ %89, %86 ]
%32 = phi i32 [ 0, %22 ], [ %88, %86 ]
%33 = phi i32 [ 0, %22 ], [ %87, %86 ]
br i1 %24, label %86, label %34
34: ; preds = %26, %77
%35 = phi i32 [ %84, %77 ], [ 0, %26 ]
%36 = phi i32 [ %83, %77 ], [ %28, %26 ]
%37 = phi i32 [ %82, %77 ], [ %29, %26 ]
%38 = phi i32 [ %81, %77 ], [ %30, %26 ]
%39 = phi i32 [ %80, %77 ], [ %31, %26 ]
%40 = phi i32 [ %79, %77 ], [ %32, %26 ]
%41 = phi i32 [ %78, %77 ], [ %33, %26 ]
br i1 %25, label %77, label %42
42: ; preds = %34, %68
%43 = phi i32 [ %75, %68 ], [ 0, %34 ]
%44 = phi i32 [ %74, %68 ], [ %36, %34 ]
%45 = phi i32 [ %73, %68 ], [ %37, %34 ]
%46 = phi i32 [ %72, %68 ], [ %38, %34 ]
%47 = phi i32 [ %71, %68 ], [ %39, %34 ]
%48 = phi i32 [ %70, %68 ], [ %40, %34 ]
%49 = phi i32 [ %69, %68 ], [ %41, %34 ]
%50 = tail call i32 @gidz_general(i32 %27, i32 %35, i32 %43, i32 %10, i32 %9)
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %8, i64 %51
%53 = load double, double* %52
%54 = fcmp ogt double %53, 0.000000e+00
br i1 %54, label %55, label %68
55: ; preds = %42
%56 = icmp ugt i32 %43, %44
%57 = select i1 %56, i32 %44, i32 %43
%58 = icmp ult i32 %43, %49
%59 = select i1 %58, i32 %49, i32 %43
%60 = icmp ugt i32 %35, %45
%61 = select i1 %60, i32 %45, i32 %35
%62 = icmp ult i32 %35, %48
%63 = select i1 %62, i32 %48, i32 %35
%64 = icmp ugt i32 %27, %46
%65 = select i1 %64, i32 %46, i32 %27
%66 = icmp ult i32 %27, %47
%67 = select i1 %66, i32 %47, i32 %27
br label %68
68: ; preds = %55, %42
%69 = phi i32 [ %49, %42 ], [ %59, %55 ]
%70 = phi i32 [ %48, %42 ], [ %63, %55 ]
%71 = phi i32 [ %47, %42 ], [ %67, %55 ]
%72 = phi i32 [ %46, %42 ], [ %65, %55 ]
%73 = phi i32 [ %45, %42 ], [ %61, %55 ]
%74 = phi i32 [ %44, %42 ], [ %57, %55 ]
%75 = add nuw i32 %43, 1
%76 = icmp eq i32 %75, %9
br i1 %76, label %77, label %42
77: ; preds = %68, %34
%78 = phi i32 [ %41, %34 ], [ %69, %68 ]
%79 = phi i32 [ %40, %34 ], [ %70, %68 ]
%80 = phi i32 [ %39, %34 ], [ %71, %68 ]
%81 = phi i32 [ %38, %34 ], [ %72, %68 ]
%82 = phi i32 [ %37, %34 ], [ %73, %68 ]
%83 = phi i32 [ %36, %34 ], [ %74, %68 ]
%84 = add nuw i32 %35, 1
%85 = icmp eq i32 %84, %10
br i1 %85, label %86, label %34
86: ; preds = %77, %26
%87 = phi i32 [ %33, %26 ], [ %78, %77 ]
%88 = phi i32 [ %32, %26 ], [ %79, %77 ]
%89 = phi i32 [ %31, %26 ], [ %80, %77 ]
%90 = phi i32 [ %30, %26 ], [ %81, %77 ]
%91 = phi i32 [ %29, %26 ], [ %82, %77 ]
%92 = phi i32 [ %28, %26 ], [ %83, %77 ]
%93 = add nuw i32 %27, 1
%94 = icmp eq i32 %93, %11
br i1 %94, label %95, label %26
95: ; preds = %86, %18
%96 = phi i32 [ 0, %18 ], [ %87, %86 ]
%97 = phi i32 [ 0, %18 ], [ %88, %86 ]
%98 = phi i32 [ 0, %18 ], [ %89, %86 ]
%99 = phi i32 [ -1, %18 ], [ %90, %86 ]
%100 = phi i32 [ %20, %18 ], [ %91, %86 ]
%101 = phi i32 [ %19, %18 ], [ %92, %86 ]
%102 = icmp ult i32 %96, %101
br i1 %102, label %103, label %105
103: ; preds = %95
%104 = tail call i32 @error_density(i32 17020, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
br label %105
105: ; preds = %103, %95
%106 = add i32 %96, 1
%107 = add i32 %97, 1
%108 = add i32 %98, 1
%109 = sub i32 %106, %101
%110 = sub i32 %107, %100
%111 = sub i32 %108, %99
%112 = and i32 %109, -2
%113 = icmp eq i32 %112, %109
%114 = icmp sgt i32 %101, 0
%115 = and i1 %113, %114
%116 = sext i1 %115 to i32
%117 = add i32 %101, %116
%118 = zext i1 %113 to i32
%119 = add i32 %109, %118
%120 = and i32 %110, -2
%121 = icmp eq i32 %120, %110
%122 = icmp sgt i32 %100, 0
%123 = and i1 %121, %122
%124 = sext i1 %123 to i32
%125 = add nsw i32 %100, %124
%126 = zext i1 %121 to i32
%127 = add i32 %110, %126
%128 = and i32 %111, -2
%129 = icmp eq i32 %128, %111
%130 = icmp sgt i32 %99, 0
%131 = and i1 %129, %130
%132 = sext i1 %131 to i32
%133 = add i32 %99, %132
%134 = zext i1 %129 to i32
%135 = add i32 %111, %134
%136 = mul i32 %119, %127
%137 = mul i32 %136, %135
%138 = zext i32 %137 to i64
store i64 %138, i64* %7
%139 = tail call i32 @do_vect(double** %0, i64 %138)
%140 = icmp ult i32 %133, %108
br i1 %140, label %141, label %366
141: ; preds = %105
%142 = icmp ult i32 %125, %107
%143 = icmp ult i32 %117, %106
%144 = zext i32 %117 to i64
%145 = zext i32 %106 to i64
%146 = xor i64 %144, -1
%147 = add nsw i64 %146, %145
%148 = mul i32 %119, %127
%149 = mul i32 %133, %10
%150 = add i32 %100, %149
%151 = add i32 %150, %124
%152 = mul i32 %151, %9
%153 = add i32 %101, %152
%154 = add i32 %153, %116
%155 = mul i32 %10, %9
%156 = mul i32 %119, %127
%157 = sub nsw i64 0, %144
%158 = mul i32 %133, %10
%159 = add i32 %100, %158
%160 = add i32 %159, %124
%161 = mul i32 %160, %9
%162 = add i32 %101, %161
%163 = add i32 %162, %116
%164 = mul i32 %10, %9
%165 = getelementptr double, double* %8, i64 %157
%166 = sub nsw i64 %145, %144
%167 = add nsw i64 %166, -4
%168 = lshr i64 %167, 2
%169 = add nuw nsw i64 %168, 1
%170 = icmp ult i64 %166, 4
%171 = trunc i64 %147 to i32
%172 = icmp ugt i64 %147, 4294967295
%173 = trunc i64 %147 to i32
%174 = icmp ugt i64 %147, 4294967295
%175 = and i64 %166, -4
%176 = add nsw i64 %175, %144
%177 = and i64 %169, 1
%178 = icmp ult i64 %167, 4
%179 = and i64 %169, 9223372036854775806
%180 = icmp eq i64 %177, 0
%181 = icmp eq i64 %166, %175
br label %182
182: ; preds = %141, %362
%183 = phi i32 [ 0, %141 ], [ %365, %362 ]
%184 = phi i32 [ %133, %141 ], [ %363, %362 ]
%185 = mul i32 %156, %183
%186 = mul i32 %164, %183
%187 = add i32 %163, %186
%188 = mul i32 %148, %183
%189 = mul i32 %155, %183
%190 = add i32 %154, %189
br i1 %142, label %191, label %362
191: ; preds = %182
%192 = sub nuw i32 %184, %133
%193 = mul i32 %192, %136
%194 = sub i32 %193, %117
%195 = mul i32 %184, %10
br label %196
196: ; preds = %191, %358
%197 = phi i32 [ 0, %191 ], [ %361, %358 ]
%198 = phi i32 [ %125, %191 ], [ %359, %358 ]
%199 = mul i32 %119, %197
%200 = add i32 %185, %199
%201 = zext i32 %200 to i64
%202 = add nuw nsw i64 %145, %201
%203 = mul i32 %197, %9
%204 = add i32 %187, %203
%205 = zext i32 %204 to i64
%206 = getelementptr double, double* %8, i64 %205
%207 = add nuw nsw i64 %145, %205
%208 = getelementptr double, double* %165, i64 %207
%209 = mul i32 %119, %197
%210 = add i32 %188, %209
%211 = mul i32 %197, %9
%212 = add i32 %190, %211
br i1 %143, label %213, label %358
213: ; preds = %196
%214 = sub nuw i32 %198, %125
%215 = mul i32 %214, %119
%216 = add i32 %194, %215
%217 = add i32 %198, %195
%218 = mul i32 %217, %9
%219 = load double*, double** %0
br i1 %170, label %295, label %220
220: ; preds = %213
%221 = xor i32 %210, -1
%222 = icmp ult i32 %221, %171
%223 = or i1 %222, %172
%224 = xor i32 %212, -1
%225 = icmp ult i32 %224, %173
%226 = or i1 %225, %174
%227 = or i1 %223, %226
br i1 %227, label %295, label %228
228: ; preds = %220
%229 = getelementptr double, double* %219, i64 %201
%230 = getelementptr double, double* %219, i64 %157
%231 = getelementptr double, double* %230, i64 %202
%232 = icmp ult double* %229, %208
%233 = icmp ult double* %206, %231
%234 = and i1 %232, %233
br i1 %234, label %295, label %235
235: ; preds = %228
br i1 %178, label %275, label %236
236: ; preds = %235, %236
%237 = phi i64 [ %272, %236 ], [ 0, %235 ]
%238 = phi i64 [ %273, %236 ], [ 0, %235 ]
%239 = trunc i64 %237 to i32
%240 = add i32 %117, %239
%241 = add i32 %216, %240
%242 = zext i32 %241 to i64
%243 = add i32 %218, %240
%244 = zext i32 %243 to i64
%245 = getelementptr inbounds double, double* %8, i64 %244
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = getelementptr inbounds double, double* %245, i64 2
%249 = bitcast double* %248 to <2 x double>*
%250 = load <2 x double>, <2 x double>* %249
%251 = getelementptr inbounds double, double* %219, i64 %242
%252 = bitcast double* %251 to <2 x double>*
store <2 x double> %247, <2 x double>* %252
%253 = getelementptr inbounds double, double* %251, i64 2
%254 = bitcast double* %253 to <2 x double>*
store <2 x double> %250, <2 x double>* %254
%255 = trunc i64 %237 to i32
%256 = or i32 %255, 4
%257 = add i32 %117, %256
%258 = add i32 %216, %257
%259 = zext i32 %258 to i64
%260 = add i32 %218, %257
%261 = zext i32 %260 to i64
%262 = getelementptr inbounds double, double* %8, i64 %261
%263 = bitcast double* %262 to <2 x double>*
%264 = load <2 x double>, <2 x double>* %263
%265 = getelementptr inbounds double, double* %262, i64 2
%266 = bitcast double* %265 to <2 x double>*
%267 = load <2 x double>, <2 x double>* %266
%268 = getelementptr inbounds double, double* %219, i64 %259
%269 = bitcast double* %268 to <2 x double>*
store <2 x double> %264, <2 x double>* %269
%270 = getelementptr inbounds double, double* %268, i64 2
%271 = bitcast double* %270 to <2 x double>*
store <2 x double> %267, <2 x double>* %271
%272 = add nuw i64 %237, 8
%273 = add i64 %238, 2
%274 = icmp eq i64 %273, %179
br i1 %274, label %275, label %236
275: ; preds = %236, %235
%276 = phi i64 [ 0, %235 ], [ %272, %236 ]
br i1 %180, label %294, label %277
277: ; preds = %275
%278 = trunc i64 %276 to i32
%279 = add i32 %117, %278
%280 = add i32 %216, %279
%281 = zext i32 %280 to i64
%282 = add i32 %218, %279
%283 = zext i32 %282 to i64
%284 = getelementptr inbounds double, double* %8, i64 %283
%285 = bitcast double* %284 to <2 x double>*
%286 = load <2 x double>, <2 x double>* %285
%287 = getelementptr inbounds double, double* %284, i64 2
%288 = bitcast double* %287 to <2 x double>*
%289 = load <2 x double>, <2 x double>* %288
%290 = getelementptr inbounds double, double* %219, i64 %281
%291 = bitcast double* %290 to <2 x double>*
store <2 x double> %286, <2 x double>* %291
%292 = getelementptr inbounds double, double* %290, i64 2
%293 = bitcast double* %292 to <2 x double>*
store <2 x double> %289, <2 x double>* %293
br label %294
294: ; preds = %275, %277
br i1 %181, label %358, label %295
295: ; preds = %228, %220, %213, %294
%296 = phi i64 [ %144, %228 ], [ %144, %220 ], [ %144, %213 ], [ %176, %294 ]
%297 = sub nsw i64 %145, %296
%298 = xor i64 %296, -1
%299 = add nsw i64 %298, %145
%300 = and i64 %297, 3
%301 = icmp eq i64 %300, 0
br i1 %301, label %316, label %302
302: ; preds = %295, %302
%303 = phi i64 [ %313, %302 ], [ %296, %295 ]
%304 = phi i64 [ %314, %302 ], [ 0, %295 ]
%305 = trunc i64 %303 to i32
%306 = add i32 %216, %305
%307 = zext i32 %306 to i64
%308 = add i32 %218, %305
%309 = zext i32 %308 to i64
%310 = getelementptr inbounds double, double* %8, i64 %309
%311 = load double, double* %310
%312 = getelementptr inbounds double, double* %219, i64 %307
store double %311, double* %312
%313 = add nuw nsw i64 %303, 1
%314 = add i64 %304, 1
%315 = icmp eq i64 %314, %300
br i1 %315, label %316, label %302
316: ; preds = %302, %295
%317 = phi i64 [ %296, %295 ], [ %313, %302 ]
%318 = icmp ult i64 %299, 3
br i1 %318, label %358, label %319
319: ; preds = %316, %319
%320 = phi i64 [ %356, %319 ], [ %317, %316 ]
%321 = trunc i64 %320 to i32
%322 = add i32 %216, %321
%323 = zext i32 %322 to i64
%324 = add i32 %218, %321
%325 = zext i32 %324 to i64
%326 = getelementptr inbounds double, double* %8, i64 %325
%327 = load double, double* %326
%328 = getelementptr inbounds double, double* %219, i64 %323
store double %327, double* %328
%329 = trunc i64 %320 to i32
%330 = add i32 %329, 1
%331 = add i32 %216, %330
%332 = zext i32 %331 to i64
%333 = add i32 %218, %330
%334 = zext i32 %333 to i64
%335 = getelementptr inbounds double, double* %8, i64 %334
%336 = load double, double* %335
%337 = getelementptr inbounds double, double* %219, i64 %332
store double %336, double* %337
%338 = trunc i64 %320 to i32
%339 = add i32 %338, 2
%340 = add i32 %216, %339
%341 = zext i32 %340 to i64
%342 = add i32 %218, %339
%343 = zext i32 %342 to i64
%344 = getelementptr inbounds double, double* %8, i64 %343
%345 = load double, double* %344
%346 = getelementptr inbounds double, double* %219, i64 %341
store double %345, double* %346
%347 = trunc i64 %320 to i32
%348 = add i32 %347, 3
%349 = add i32 %216, %348
%350 = zext i32 %349 to i64
%351 = add i32 %218, %348
%352 = zext i32 %351 to i64
%353 = getelementptr inbounds double, double* %8, i64 %352
%354 = load double, double* %353
%355 = getelementptr inbounds double, double* %219, i64 %350
store double %354, double* %355
%356 = add nuw nsw i64 %320, 4
%357 = icmp eq i64 %356, %145
br i1 %357, label %358, label %319
358: ; preds = %316, %319, %294, %196
%359 = add nuw i32 %198, 1
%360 = icmp eq i32 %198, %97
%361 = add i32 %197, 1
br i1 %360, label %362, label %196
362: ; preds = %358, %182
%363 = add nuw i32 %184, 1
%364 = icmp eq i32 %184, %98
%365 = add i32 %183, 1
br i1 %364, label %366, label %182
366: ; preds = %362, %105
store i32 %119, i32* %1
store i32 %127, i32* %2
store i32 %135, i32* %3
%367 = sitofp i32 %117 to double
%368 = tail call double @llvm.fmuladd.f64(double %367, double %15, double %12)
store double %368, double* %4
%369 = sitofp i32 %125 to double
%370 = tail call double @llvm.fmuladd.f64(double %369, double %16, double %13)
store double %370, double* %5
%371 = sitofp i32 %133 to double
%372 = tail call double @llvm.fmuladd.f64(double %371, double %17, double %14)
store double %372, double* %6
%373 = uitofp i32 %9 to double
%374 = uitofp i32 %10 to double
%375 = uitofp i32 %11 to double
%376 = load i32, i32* %1
%377 = load i32, i32* %2
%378 = tail call i32 (i8*, double, double, double, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.1, i64 0, i64 0), double %373, double %374, double %375, i32 %376, i32 %377, i32 %135)
%379 = load double, double* %4
%380 = load double, double* %5
%381 = load double, double* %6
%382 = tail call i32 (i8*, double, double, double, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0), double %379, double %380, double %381)
ret void
}