Problem: You've got an n × n × n cube, split into unit cubes. Your task is to number all unit cubes in this cube with positive integers from 1 to n3 so that: 

  * each number was used as a cube's number exactly once; 
  * for each 1 ≤ i < n3, unit cubes with numbers i and i + 1 were neighbouring (that is, shared a side); 
  * for each 1 ≤ i < n there were at least two different subcubes with sizes i × i × i, made from unit cubes, which are numbered with consecutive numbers. That is, there are such two numbers x and y, that the unit cubes of the first subcube are numbered by numbers x, x + 1, ..., x + i3 - 1, and the unit cubes of the second subcube are numbered by numbers y, y + 1, ..., y + i3 - 1. 



Find and print the required numeration of unit cubes of the cube.

Input

The first line contains a single integer n (1 ≤ n ≤ 50) — the size of the cube, whose unit cubes need to be numbered.

Output

Print all layers of the cube as n n × n matrices. Separate them with new lines. Print the layers in the order in which they follow in the cube. See the samples for clarifications. 

It is guaranteed that there always is a solution that meets the conditions given in the problem statement.

Examples

Input

3


Output

1 4 17 
2 3 18 
27 26 19 

8 5 16 
7 6 15 
24 25 20 

9 12 13 
10 11 14 
23 22 21 

Note

In the sample the cubes with sizes 2 × 2 × 2 are numbered with integers 1, ..., 8 and 5, ..., 12.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
inline int read() {
  register int x = 0, f = 1;
  register char ch = getchar();
  while (!isdigit(ch)) {
    if (ch == '-') f = 0;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = x * 10 + (ch ^ '0');
    ch = getchar();
  }
  return f ? x : -x;
}
const int N = 51;
int n, a[N][N][N], b[N][N][N];
inline void move(int o, int x, int y, int z, int dx, int dy, int dz, int n,
                 int m, int id, int did) {
  for (int i = (1), _ed = (n); i <= _ed; ++i)
    for (int j = (1), _ed = (m); j <= _ed; ++j) {
      a[x][y][z] = id;
      id += did;
      if (j < m) {
        x += dx, y += dy, z += dz;
        continue;
      }
      dx *= -1, dy *= -1, dz *= -1;
      if (abs(o) == 1)
        x += o;
      else if (abs(o) == 2)
        y += o / 2;
      else
        z += o / 3;
    }
}
inline void work(int n) {
  move(1, 1, 0, 1, 0, 0, 1, n, n, 0, -1);
  int m = n * n * n;
  if (n & 1) {
    move(-2, 0, n, 1, 0, 0, 1, n + 1, n, m + 1, 1);
    move(1, 0, 0, 0, 0, 1, 0, n + 1, n + 1, m + n * (n + 1) + 1, 1);
    for (int i = (1), _ed = (n + 1); i <= _ed; ++i)
      for (int j = (1), _ed = (n + 1); j <= _ed; ++j)
        for (int k = (1), _ed = (n + 1); k <= _ed; ++k)
          b[i][j][k] = a[n + 1 - i][k - 1][n + 1 - j] + n * n;
  } else {
    move(3, 0, n, 1, 0, -1, 0, n, n + 1, m + 1, 1);
    move(1, 0, n, n + 1, 0, -1, 0, n + 1, n + 1, m + n * (n + 1) + 1, 1);
    for (int i = (1), _ed = (n + 1); i <= _ed; ++i)
      for (int j = (1), _ed = (n + 1); j <= _ed; ++j)
        for (int k = (1), _ed = (n + 1); k <= _ed; ++k)
          b[i][j][k] = a[n + 1 - i][k - 1][j] + n * n;
  }
  memcpy(a, b, sizeof a);
}
int main() {
  n = read();
  a[1][1][1] = 1;
  for (int i = (1), _ed = (n - 1); i <= _ed; ++i) work(i);
  for (int i = (1), _ed = (n); i <= _ed; ++i) {
    for (int j = (1), _ed = (n); j <= _ed; ++j) {
      for (int k = (1), _ed = (n); k <= _ed; ++k) printf("%d ", a[i][j][k]);
      puts("");
    }
    puts("");
  }
  return 0;
}