Untitled

inline int borderHealth(short *board, int n, int d, int r, int c, short *newHealth) {
  int i, j, k;
  int neighborDepth, neighborRow, neighborColumn;
  short surroundingHealth = 0;

  for (i = -1; i <= 1; i++) {
    for (j = -1; j <= 1; j++) {
      for (k = -1; k <= 1; k++) {
        if (i == 0 && j == 0 && k == 0) continue;

        if (d + i == -1) neighborDepth = n - 1;
        else if (d + i == n) neighborDepth = 0;
        else neighborDepth = (d + i);
        if (r + j == -1) neighborRow = n - 1;
        else if (r + j == n) neighborRow = 0;
        else neighborRow = (r + j);
        if (c + k == -1) neighborColumn = n - 1;
        else if (c + k == n) neighborColumn = 0;
        else neighborColumn = (c + k);

        surroundingHealth += INDEX3D(board, n, neighborDepth, neighborRow,
          neighborColumn);
      }
    }
  }

  return newHealth[surroundingHealth];
}

void optIterate3DLife(int n, short *prev, short *next, short *newHealth) {
  int d, r, c, nm1 = n-1, n2 = n*n;
  short *dp, *rp, *cp;

  for (d = 1, dp = next + n2; d < nm1; d++, dp += n2) {
    for (r = 1, rp = dp + n; r < nm1; r++, rp += n) {
      short *p, left = 0, mid = 0, right = 0, self;
      c = 1; cp = rp + 1;

      p = prev + ((d-1) * n2) + ((r-1) * n) + c;
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);
      p += n;
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);
      p += n;
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);

      p += n2 - (n << 1);
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);
      p += n;
      left += *(p - 1);
      mid += *p; self = *p;
      right += *(p + 1);
      p += n;
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);

      p += n2 - (n << 1);
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);
      p += n;
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);
      p += n;
      left += *(p - 1);
      mid += *p;
      right += *(p + 1);

      *cp = newHealth[left + mid + right - self];

      for (c = 2, cp = rp + 2; c < nm1; c++, cp++) {
        left = mid;
        mid = right;
        right = 0;

        p = prev + ((d-1) * n2) + ((r-1) * n) + c;
        right += *(p + 1);
        p += n;
        right += *(p + 1);
        p += n;
        right += *(p + 1);

        p += n2 - (n << 1);
        right += *(p + 1);
        p += n;
        self = *p;
        right += *(p + 1);
        p += n;
        right += *(p + 1);

        p += n2 - (n << 1);
        right += *(p + 1);
        p += n;
        right += *(p + 1);
        p += n;
        right += *(p + 1);
        
        *cp = newHealth[left + mid + right - self];
      }
    }
  }

  d = 0;
  for (r = 0; r < n; r++) {
    for (c = 0; c < n; c++) {
      INDEX3D(next, n, d, r, c) = borderHealth(prev, n, d, r, c, newHealth);
    }
  }

  r = 0;
  for (d = 0; d < n; d++) {
    for (c = 0; c < n; c++) {
      INDEX3D(next, n, d, r, c) = borderHealth(prev, n, d, r, c, newHealth);
    }
  }

  c = 0;
  for (d = 0; d < n; d++) {
    for (r = 0; r < n; r++) {
      INDEX3D(next, n, d, r, c) = borderHealth(prev, n, d, r, c, newHealth);
    }
  }

  d = nm1;
  for (r = 0; r < n; r++) {
    for (c = 0; c < n; c++) {
      INDEX3D(next, n, d, r, c) = borderHealth(prev, n, d, r, c, newHealth);
    }
  }

  r = nm1;
  for (d = 0; d < n; d++) {
    for (c = 0; c < n; c++) {
      INDEX3D(next, n, d, r, c) = borderHealth(prev, n, d, r, c, newHealth);
    }
  }

  c = nm1;
  for (d = 0; d < n; d++) {
    for (r = 0; r < n; r++) {
      INDEX3D(next, n, d, r, c) = borderHealth(prev, n, d, r, c, newHealth);
    }
  }
}