import java.util.*;

public class c {
    static int n;
    static char[][] input;
    static char[][] answer;

    static byte[] makeDSU(int n) {
        byte[] res = new byte[n];
        Arrays.fill(res, (byte)-1);
        return res;
    }

    static byte find(byte[] s, byte i) {
        return s[i] < (byte)0 ? i : (s[i] = find(s, s[i]));
    }

    static boolean union(byte[] s, byte a, byte b) {
        if ((a = find(s, a)) == (b = find(s, b))) return false;
        if (s[a] == s[b]) s[a]--;
        if (s[a] <= s[b]) s[b] = a;
        else s[a] = b;
        return true;
    }
    
    static int countIngoing(int i, int j) {
        int result = 0;
        if (i < n && j < n && answer[i][j] == '\\') result += 1;
        if (i > 0 && j < n && answer[i - 1][j] == '/') result += 1;
        if (i < n && j > 0 && answer[i][j - 1] == '/') result += 1;
        if (i > 0 && j > 0 && answer[i - 1][j - 1] == '\\') result += 1;

        return result;
    }

    static int countPerpendicular(int i, int j) {
        int result = 0;
        if (i < n && j < n && answer[i][j] == '/') result += 1;
        if (i > 0 && j < n && answer[i - 1][j] == '\\') result += 1;
        if (i < n && j > 0 && answer[i][j - 1] == '\\') result += 1;
        if (i > 0 && j > 0 && answer[i - 1][j - 1] == '/') result += 1;

        return result;
    }

    static int countUnknown(int i, int j) {
        int result = 0;
        if (i < n && j < n && answer[i][j] == 0) result += 1;
        if (i > 0 && j < n && answer[i - 1][j] == 0) result += 1;
        if (i < n && j > 0 && answer[i][j - 1] == 0) result += 1;
        if (i > 0 && j > 0 && answer[i - 1][j - 1] == 0) result += 1;

        return result;
    }

    static boolean verify(int i, int j) {
        if (input[i][j] == '+') return true;
        int expected = input[i][j] - '0';
        int ingoing = countIngoing(i, j);
        int unknown = countUnknown(i, j);
        if (ingoing > expected) return false;
        if (ingoing + unknown < expected) return false;

        return true;
    }

    static byte[] dsu;

    static boolean solve(int i, int j) {
        if (i == n) {
            return true;
        }

        int ni = i, nj = j + 1;
        if (nj == n) {
            ni += 1;
            nj = 0;
        }

        byte[] save = dsu;

        byte A = (byte)(i * (n + 1) + j);
        byte B = (byte)((i + 1) * (n + 1) + (j + 1));
        if (find(dsu, A) != find(dsu, B)) {
            answer[i][j] = '\\';
            if (verify(i, j + 1) && verify(i + 1, j) && verify(i + 1, j + 1) && verify(i, j)) {
                dsu = Arrays.copyOf(dsu, dsu.length);
                union(dsu, A, B);
                if (solve(ni, nj)) return true;
                dsu = save;
            }
        }

        A = (byte)(i * (n + 1) + (j + 1));
        B = (byte)((i + 1) * (n + 1) + j);
        if (find(dsu, A) != find(dsu, B)) {
            answer[i][j] = '/';
            if (verify(i, j + 1) && verify(i + 1, j) && verify(i + 1, j + 1) && verify(i, j)) {
                dsu = Arrays.copyOf(dsu, dsu.length);
                union(dsu, A, B);
                if (solve(ni, nj)) return true;
                dsu = save;
            }
        }

        answer[i][j] = 0;
        return false;
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        scan.nextLine();
        answer = new char[n][n];
        input = new char[n + 1][];
        for (int i = 0; i <= n; ++i) {
            input[i] = scan.nextLine().toCharArray();
        }

        dsu = makeDSU((n + 1) * (n + 1));
        solve(0, 0);

        for (char[] arr : answer) {
            System.out.println(String.valueOf(arr));
        }
    }
}