Problem: Oleg came to see the maze of mirrors. The maze is a n by n room in which each cell is either empty or contains a mirror connecting opposite corners of this cell. Mirrors in this maze reflect light in a perfect way, which causes the interesting visual effects and contributes to the loss of orientation in the maze.

Oleg is a person of curious nature, so he decided to install n lasers facing internal of the maze on the south wall of the maze. On the north wall of the maze, Oleg installed n receivers, also facing internal of the maze. Let's number lasers and receivers from west to east with distinct integers from 1 to n. Each laser sends a beam of some specific kind and receiver with number a_i should receive the beam sent from laser number i. Since two lasers' beams can't come to the same receiver, these numbers form a permutation — each of the receiver numbers occurs exactly once.

You came to the maze together with Oleg. Help him to place the mirrors in the initially empty maze so that the maximum number of lasers' beams will come to the receivers they should. There are no mirrors outside the maze, so if the laser beam leaves the maze, it will not be able to go back.

Input

The first line contains a single integer n (1 ≤ n ≤ 1000) — the size of the maze.

The second line contains a permutation of n integers a_i (1 ≤ a_i ≤ n), where a_i defines the number of the receiver, to which the beam from i-th laser should come.

Output

In the first line print the maximum possible number of laser beams, which can come to the receivers they should.

In the next n lines of length n print the arrangement of mirrors, causing such number of laser beams to come where they should. If the corresponding cell is empty, print ".", otherwise print "/" or "\", depending on the orientation of the mirror.

In your output north should be above, south should be below, and west and east should be on left and on the right respectively.

It is allowed for laser beams to come not to the receivers they correspond to, but they are not counted in the answer.

If there are multiple arrangements of mirrors leading to the optimal answer — print any of them.

Example

Input

4
4 1 3 2


Output

3
...
\..
/../
...\

Note

The picture illustrates the arrangements of the mirrors in the first example.

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
char M[N][N];
int data[N], rdata[N];
int main() {
  int n;
  scanf("%d", &n);
  int p = 0;
  for (int i = (1); i < (n + 1); ++i) {
    scanf("%d", &data[i]);
    rdata[data[i]] = i;
    if (data[i] != i) p = 1;
  }
  if (p == 0) {
    printf("%d\n", n);
    for (int i = (0); i < (n); ++i) {
      for (int j = (0); j < (n); ++j) printf(".");
      puts("");
    }
    return 0;
  }
  printf("%d\n", n - 1);
  for (int i = (1); i < (n + 1); ++i)
    for (int j = (1); j < (n + 1); ++j) M[i][j] = '.';
  int f = n, P = 0;
  for (int i = (1); i < (n + 1); ++i)
    if (data[i] == 1) P = i;
  M[f][1] = M[f][P] = '/';
  f--;
  swap(data[1], data[P]);
  for (int i = (1); i < (n + 1); ++i) rdata[data[i]] = i;
  for (int cas = (2); cas < (n + 1); ++cas)
    if (data[cas] != cas) {
      M[f][1] = '\\';
      vector<int> V;
      V.push_back(cas);
      int now = rdata[cas];
      while (now != cas) {
        V.push_back(now);
        now = rdata[now];
      }
      for (int i = (1); i < (((int)(V).size())); ++i) {
        swap(data[V[i]], data[V[i - 1]]);
        if (V[i] > V[i - 1])
          M[f][V[i]] = M[f][V[i - 1]] = '\\';
        else
          M[f][V[i]] = M[f][V[i - 1]] = '/';
        f--;
      }
      M[f][1] = '/', M[f][V.back()] = '/';
      f--;
    }
  for (int i = (1); i < (n + 1); ++i) {
    for (int j = (1); j < (n + 1); ++j) printf("%c", M[i][j]);
    puts("");
  }
}