import java.io.*;

import java.lang.reflect.Array;
import java.math.*;
import java.util.*;

public class icpc
{
    public static void main(String[] args)throws IOException
    {
        Reader in = new Reader();
//        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int n = in.nextInt();
        if (n % 2 == 1)
            System.out.println(-1);
        else
        {
            StringBuilder stringBuilder1 = new StringBuilder();
            StringBuilder stringBuilder2 = new StringBuilder();
            for (int i=0;i<n;i++)
            {
                for (int j=0;j<n / 2;j++)
                {
                    if ((i % 2 == 0 && j % 2 == 0) || (i % 2 == 1 && j % 2 == 1))
                    {
                        stringBuilder1.append("bb");
                        stringBuilder2.append("ww");
                    }
                    else if ((i % 2 == 0 && j % 2 == 1) || (i % 2 == 1 && j % 2 == 0))
                    {
                        stringBuilder1.append("ww");
                        stringBuilder2.append("bb");
                    }
                }
                stringBuilder1.append("\n");
                stringBuilder2.append("\n");
            }
            StringBuilder ans = new StringBuilder();
            for (int i=0;i<n / 2;i++)
            {
                if (i % 2 == 0)
                {
                    ans.append(stringBuilder1).append("\n");
                    ans.append(stringBuilder1).append("\n");
                }
                else
                {
                    ans.append(stringBuilder2).append("\n");
                    ans.append(stringBuilder2).append("\n");
                }
            }
            System.out.println(ans);
        }
    }
}
class FastFourierTransform
{
    private void fft(double[] a, double[] b, boolean invert)
    {
        int count = a.length;
        for (int i = 1, j = 0; i < count; i++)
        {
            int bit = count >> 1;
            for (; j >= bit; bit >>= 1)
                j -= bit;
            j += bit;
            if (i < j)
            {
                double temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                temp = b[i];
                b[i] = b[j];
                b[j] = temp;
            }
        }
        for (int len = 2; len <= count; len <<= 1)
        {
            int halfLen = len >> 1;
            double angle = 2 * Math.PI / len;
            if (invert)
                angle = -angle;
            double wLenA = Math.cos(angle);
            double wLenB = Math.sin(angle);
            for (int i = 0; i < count; i += len)
            {
                double wA = 1;
                double wB = 0;
                for (int j = 0; j < halfLen; j++)
                {
                    double uA = a[i + j];
                    double uB = b[i + j];
                    double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
                    double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
                    a[i + j] = uA + vA;
                    b[i + j] = uB + vB;
                    a[i + j + halfLen] = uA - vA;
                    b[i + j + halfLen] = uB - vB;
                    double nextWA = wA * wLenA - wB * wLenB;
                    wB = wA * wLenB + wB * wLenA;
                    wA = nextWA;
                }
            }
        }
        if (invert)
        {
            for (int i = 0; i < count; i++)
            {
                a[i] /= count;
                b[i] /= count;
            }
        }
    }

    public long[] multiply(long[] a, long[] b)
    {
        int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
        resultSize = Math.max(resultSize, 1);
        double[] aReal = new double[resultSize];
        double[] aImaginary = new double[resultSize];
        double[] bReal = new double[resultSize];
        double[] bImaginary = new double[resultSize];
        for (int i = 0; i < a.length; i++)
            aReal[i] = a[i];
        for (int i = 0; i < b.length; i++)
            bReal[i] = b[i];
        fft(aReal, aImaginary, false);
        fft(bReal, bImaginary, false);
        for (int i = 0; i < resultSize; i++)
        {
            double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
            aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
            aReal[i] = real;
        }
        fft(aReal, aImaginary, true);
        long[] result = new long[resultSize];
        for (int i = 0; i < resultSize; i++)
            result[i] = Math.round(aReal[i]);
        return result;
    }
}
class NumberTheory
{
    public boolean isPrime(long n)
    {
        if(n < 2)
            return false;
        for(long x = 2;x * x <= n;x++)
        {
            if(n % x == 0)
                return false;
        }
        return true;
    }
    public ArrayList<Long> primeFactorisation(long n)
    {
        ArrayList<Long> f = new ArrayList<>();
        for(long x=2;x * x <= n;x++)
        {
            while(n % x == 0)
            {
                f.add(x);
                n /= x;
            }
        }
        if(n > 1)
            f.add(n);
        return f;
    }
    public int[] sieveOfEratosthenes(int n)
    {
        //Returns an array with the smallest prime factor for each number and primes marked as 0
        int[] sieve = new int[n + 1];
        for(int x=2;x * x <= n;x++)
        {
            if(sieve[x] != 0)
                continue;
            for(int u=x*x;u<=n;u+=x)
            {
                if(sieve[u] == 0)
                {
                    sieve[u] = x;
                }
            }
        }
        return sieve;
    }
    public long gcd(long a, long b)
    {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    public long phi(long n)
    {
        double result = n;

        for(long p=2;p*p<=n;p++)
        {
            if(n % p == 0)
            {
                while (n % p == 0)
                    n /= p;
                result *= (1.0 - (1.0 / (double)p));
            }
        }
        if(n > 1)
            result *= (1.0 - (1.0 / (double)n));
        return (long)result;
    }
    public Name extendedEuclid(long a, long b)
    {
        if(b == 0)
            return new Name(a, 1, 0);
        Name n1 = extendedEuclid(b, a % b);
        Name n2 = new Name(n1.d, n1.y, n1.x - (long)Math.floor((double)a / b) * n1.y);
        return n2;
    }
    public long modularExponentiation(long a, long b, long n)
    {
        long d = 1L;
        String bString = Long.toBinaryString(b);
        for(int i=0;i<bString.length();i++)
        {
            d = (d * d) % n;
            if(bString.charAt(i) == '1')
                d = (d * a) % n;
        }
        return d;
    }
}
class Name
{
    long d;
    long x;
    long y;

    public Name(long d, long x, long y)
    {
        this.d = d;
        this.x = x;
        this.y = y;
    }
}
class SuffixArray
{
    int ALPHABET_SZ = 256, N;
    int[] T, lcp, sa, sa2, rank, tmp, c;

    public SuffixArray(String str)
    {
        this(toIntArray(str));
    }

    private static int[] toIntArray(String s)
    {
        int[] text = new int[s.length()];
        for (int i = 0; i < s.length(); i++) text[i] = s.charAt(i);
        return text;
    }

    public SuffixArray(int[] text)
    {
        T = text;
        N = text.length;
        sa = new int[N];
        sa2 = new int[N];
        rank = new int[N];
        c = new int[Math.max(ALPHABET_SZ, N)];
        construct();
        kasai();
    }

    private void construct()
    {
        int i, p, r;
        for (i = 0; i < N; ++i) c[rank[i] = T[i]]++;
        for (i = 1; i < ALPHABET_SZ; ++i) c[i] += c[i - 1];
        for (i = N - 1; i >= 0; --i) sa[--c[T[i]]] = i;
        for (p = 1; p < N; p <<= 1)
        {
            for (r = 0, i = N - p; i < N; ++i) sa2[r++] = i;
            for (i = 0; i < N; ++i) if (sa[i] >= p) sa2[r++] = sa[i] - p;
            Arrays.fill(c, 0, ALPHABET_SZ, 0);
            for (i = 0; i < N; ++i) c[rank[i]]++;
            for (i = 1; i < ALPHABET_SZ; ++i) c[i] += c[i - 1];
            for (i = N - 1; i >= 0; --i) sa[--c[rank[sa2[i]]]] = sa2[i];
            for (sa2[sa[0]] = r = 0, i = 1; i < N; ++i)
            {
                if (!(rank[sa[i - 1]] == rank[sa[i]]
                        && sa[i - 1] + p < N
                        && sa[i] + p < N
                        && rank[sa[i - 1] + p] == rank[sa[i] + p])) r++;
                sa2[sa[i]] = r;
            }
            tmp = rank;
            rank = sa2;
            sa2 = tmp;
            if (r == N - 1) break;
            ALPHABET_SZ = r + 1;
        }
    }

    private void kasai()
    {
        lcp = new int[N];
        int[] inv = new int[N];
        for (int i = 0; i < N; i++) inv[sa[i]] = i;
        for (int i = 0, len = 0; i < N; i++)
        {
            if (inv[i] > 0)
            {
                int k = sa[inv[i] - 1];
                while ((i + len < N) && (k + len < N) && T[i + len] == T[k + len]) len++;
                lcp[inv[i] - 1] = len;
                if (len > 0) len--;
            }
        }
    }
}
class ZAlgorithm
{
    public int[] calculateZ(char input[])
    {
        int Z[] = new int[input.length];
        int left = 0;
        int right = 0;
        for(int k = 1; k < input.length; k++) {
            if(k > right) {
                left = right = k;
                while(right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                //we are operating inside box
                int k1 = k - left;
                //if value does not stretches till right bound then just copy it.
                if(Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { //otherwise try to see if there are more matches.
                    left = k;
                    while(right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        }
        return Z;
    }
    public ArrayList<Integer> matchPattern(char text[], char pattern[])
    {
        char newString[] = new char[text.length + pattern.length + 1];
        int i = 0;
        for(char ch : pattern) {
            newString[i] = ch;
            i++;
        }
        newString[i] = '$';
        i++;
        for(char ch : text) {
            newString[i] = ch;
            i++;
        }
        ArrayList<Integer> result = new ArrayList<>();
        int Z[] = calculateZ(newString);

        for(i = 0; i < Z.length ; i++) {
            if(Z[i] == pattern.length) {
                result.add(i - pattern.length - 1);
            }
        }
        return result;
    }
}
class KMPAlgorithm
{
    public int[] computeTemporalArray(char[] pattern)
    {
        int[] lps = new int[pattern.length];

        int index = 0;
        for(int i=1;i<pattern.length;)
        {
            if(pattern[i] == pattern[index])
            {
                lps[i] = index + 1;
                index++;
                i++;
            }
            else
            {
                if(index != 0)
                {
                    index = lps[index - 1];
                }
                else
                {
                    lps[i] = 0;
                    i++;
                }
            }
        }
        return lps;
    }

    public ArrayList<Integer> KMPMatcher(char[] text, char[] pattern)
    {
        int[] lps = computeTemporalArray(pattern);

        int j = 0;
        int i = 0;
        int n = text.length;
        int m = pattern.length;
        ArrayList<Integer> indices = new ArrayList<>();
        while(i < n)
        {
            if(pattern[j] == text[i])
            {
                i++;
                j++;
            }
            if(j == m)
            {
                indices.add(i - j);
                j = lps[j - 1];
            }
            else if(i < n && pattern[j] != text[i])
            {
                if(j != 0)
                    j = lps[j - 1];
                else
                    i = i + 1;
            }
        }
        return indices;
    }
}
class Hashing
{
    public long[] computePowers(long p, int n, long m)
    {
        long[] powers = new long[n];
        powers[0] = 1;
        for(int i=1;i<n;i++)
        {
            powers[i] = (powers[i - 1] * p) % m;
        }
        return powers;
    }
    public long computeHash(String s)
    {
        long p = 31;
        long m = 1_000_000_009;
        long hashValue = 0L;
        long[] powers = computePowers(p, s.length(), m);
        for(int i=0;i<s.length();i++)
        {
            char ch = s.charAt(i);
            hashValue = (hashValue + (ch - 'a' + 1) * powers[i]) % m;
        }
        return hashValue;
    }
}
class BasicFunctions
{
    public long min(long[] A)
    {
        long min = Long.MAX_VALUE;
        for(int i=0;i<A.length;i++)
        {
            min = Math.min(min, A[i]);
        }
        return min;
    }
    public long max(long[] A)
    {
        long max = Long.MAX_VALUE;
        for(int i=0;i<A.length;i++)
        {
            max = Math.max(max, A[i]);
        }
        return max;
    }
}
class MergeSortInt
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]
    void merge(int arr[], int l, int m, int r) {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int[n1];
        int R[] = new int[n2];

        /*Copy data to temp arrays*/
        for (int i = 0; i < n1; ++i)
            L[i] = arr[l + i];
        for (int j = 0; j < n2; ++j)
            R[j] = arr[m + 1 + j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r) {
        if (l < r) {
            // Find the middle point
            int m = (l + r) / 2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr, m + 1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

}
class MergeSortLong
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]
    void merge(long arr[], int l, int m, int r) {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        long L[] = new long[n1];
        long R[] = new long[n2];

        /*Copy data to temp arrays*/
        for (int i = 0; i < n1; ++i)
            L[i] = arr[l + i];
        for (int j = 0; j < n2; ++j)
            R[j] = arr[m + 1 + j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(long arr[], int l, int r) {
        if (l < r) {
            // Find the middle point
            int m = (l + r) / 2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr, m + 1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }
}
class Node
{
    String s;
    Node(String s)
    {
        this.s = s;
    }

    @Override
    public boolean equals(Object ob)
    {
        if(ob == null)
            return false;
        if(!(ob instanceof Node))
            return false;
        if(ob == this)
            return true;
        Node obj = (Node)ob;
        if(this.s.equals(obj.s))
            return true;
        return false;
    }

    @Override
    public int hashCode()
    {
        return (int)this.s.length();
    }
}
class Reader
{
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader()
    {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException
    {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException
    {
        byte[] buf = new byte[64]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1)
        {
            if (c == '\n')
                break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException
    {
        int ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do
        {
            ret = ret * 10 + c - '0';
        }  while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    public long nextLong() throws IOException
    {
        long ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');
        if (neg)
            return -ret;
        return ret;
    }

    public double nextDouble() throws IOException
    {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');

        if (c == '.')
        {
            while ((c = read()) >= '0' && c <= '9')
            {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException
    {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read() throws IOException
    {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException
    {
        if (din == null)
            return;
        din.close();
    }
}
class FenwickTree
{
    public void update(long[] fenwickTree,long delta,int index)
    {
        index += 1;
        while(index < fenwickTree.length)
        {
            fenwickTree[index] += delta;
            index = index + (index & (-index));
        }
    }
    public long prefixSum(long[] fenwickTree,int index)
    {
        long sum = 0L;
        index += 1;
        while(index > 0)
        {
            sum += fenwickTree[index];
            index -= (index & (-index));
        }
        return sum;
    }
}
class SegmentTree
{
    public int nextPowerOfTwo(int num)
    {
        if(num == 0)
            return 1;
        if(num > 0 && (num & (num - 1)) == 0)
            return num;
        while((num &(num - 1)) > 0)
        {
            num = num & (num - 1);
        }
        return num << 1;
    }
    public int[] createSegmentTree(int[] input)
    {
        int np2 = nextPowerOfTwo(input.length);
        int[] segmentTree = new int[np2 * 2 - 1];

        for(int i=0;i<segmentTree.length;i++)
            segmentTree[i] = Integer.MIN_VALUE;

        constructSegmentTree(segmentTree,input,0,input.length-1,0);
        return segmentTree;

    }
    private void constructSegmentTree(int[] segmentTree,int[] input,int low,int high,int pos)
    {
        if(low == high)
        {
            segmentTree[pos] = input[low];
            return;
        }
        int mid = (low + high)/ 2;
        constructSegmentTree(segmentTree,input,low,mid,2*pos + 1);
        constructSegmentTree(segmentTree,input,mid+1,high,2*pos + 2);
        segmentTree[pos] = Math.max(segmentTree[2*pos + 1],segmentTree[2*pos + 2]);
    }
    public int rangeMinimumQuery(int []segmentTree,int qlow,int qhigh,int len)
    {
        return rangeMinimumQuery(segmentTree,0,len-1,qlow,qhigh,0);
    }
    private int rangeMinimumQuery(int segmentTree[],int low,int high,int qlow,int qhigh,int pos)
    {
        if(qlow <= low && qhigh >= high){
            return segmentTree[pos];
        }
        if(qlow > high || qhigh < low){
            return Integer.MIN_VALUE;
        }
        int mid = (low+high)/2;
        return Math.max(rangeMinimumQuery(segmentTree, low, mid, qlow, qhigh, 2 * pos + 1),
                rangeMinimumQuery(segmentTree, mid + 1, high, qlow, qhigh, 2 * pos + 2));
    }
}
class Trie
{

    private class TrieNode
    {
        Map<Character, TrieNode> children;
        boolean endOfWord;
        public TrieNode()
        {
            children = new HashMap<>();
            endOfWord = false;
        }
    }

    private final TrieNode root;
    public Trie()
    {
        root = new TrieNode();
    }

    public void insert(String word)
    {
        TrieNode current = root;
        for (int i = 0; i < word.length(); i++)
        {
            char ch = word.charAt(i);
            TrieNode node = current.children.get(ch);
            if (node == null)
            {
                node = new TrieNode();
                current.children.put(ch, node);
            }
            current = node;
        }
        current.endOfWord = true;
    }

    public boolean search(String word)
    {
        TrieNode current = root;
        for (int i = 0; i < word.length(); i++)
        {
            char ch = word.charAt(i);
            TrieNode node = current.children.get(ch);
            if (node == null)
            {
                return false;
            }
            current = node;
        }
        return current.endOfWord;
    }

    public void delete(String word)
    {
        delete(root, word, 0);
    }

    private boolean delete(TrieNode current, String word, int index)
    {
        if (index == word.length())
        {
            if (!current.endOfWord)
            {
                return false;
            }
            current.endOfWord = false;
            return current.children.size() == 0;
        }
        char ch = word.charAt(index);
        TrieNode node = current.children.get(ch);
        if (node == null)
        {
            return false;
        }
        boolean shouldDeleteCurrentNode = delete(node, word, index + 1);

        if (shouldDeleteCurrentNode)
        {
            current.children.remove(ch);
            return current.children.size() == 0;
        }
        return false;
    }
}
class SegmentTreeLazy
{
    public int nextPowerOfTwo(int num)
    {
        if(num == 0)
            return 1;
        if(num > 0 && (num & (num - 1)) == 0)
            return num;
        while((num &(num - 1)) > 0)
        {
            num = num & (num - 1);
        }
        return num << 1;
    }

    public int[] createSegmentTree(int input[])
    {
        int nextPowOfTwo = nextPowerOfTwo(input.length);
        int segmentTree[] = new int[nextPowOfTwo*2 -1];

        for(int i=0; i < segmentTree.length; i++){
            segmentTree[i] = Integer.MAX_VALUE;
        }
        constructMinSegmentTree(segmentTree, input, 0, input.length - 1, 0);
        return segmentTree;
    }

    private void constructMinSegmentTree(int segmentTree[], int input[], int low, int high,int pos)
    {
        if(low == high)
        {
            segmentTree[pos] = input[low];
            return;
        }
        int mid = (low + high)/2;
        constructMinSegmentTree(segmentTree, input, low, mid, 2 * pos + 1);
        constructMinSegmentTree(segmentTree, input, mid + 1, high, 2 * pos + 2);
        segmentTree[pos] = Math.min(segmentTree[2*pos+1], segmentTree[2*pos+2]);
    }

    public void updateSegmentTreeRangeLazy(int input[], int segmentTree[], int lazy[], int startRange, int endRange, int delta)
    {
        updateSegmentTreeRangeLazy(segmentTree, lazy, startRange, endRange, delta, 0, input.length - 1, 0);
    }

    private void updateSegmentTreeRangeLazy(int segmentTree[], int lazy[], int startRange, int endRange, int delta, int low, int high, int pos)
    {
        if(low > high)
        {
            return;
        }
        if (lazy[pos] != 0)
        {
            segmentTree[pos] += lazy[pos];
            if (low != high)
            {
                lazy[2 * pos + 1] += lazy[pos];
                lazy[2 * pos + 2] += lazy[pos];
            }
            lazy[pos] = 0;
        }

        if(startRange > high || endRange < low)
        {
            return;
        }

        if(startRange <= low && endRange >= high)
        {
            segmentTree[pos] += delta;
            if(low != high) {
                lazy[2*pos + 1] += delta;
                lazy[2*pos + 2] += delta;
            }
            return;
        }

        int mid = (low + high)/2;
        updateSegmentTreeRangeLazy(segmentTree, lazy, startRange, endRange, delta, low, mid, 2*pos+1);
        updateSegmentTreeRangeLazy(segmentTree, lazy, startRange, endRange, delta, mid+1, high, 2*pos+2);
        segmentTree[pos] = Math.min(segmentTree[2*pos + 1], segmentTree[2*pos + 2]);
    }

    public int rangeMinimumQueryLazy(int segmentTree[], int lazy[], int qlow, int qhigh, int len)
    {
        return rangeMinimumQueryLazy(segmentTree, lazy, qlow, qhigh, 0, len - 1, 0);
    }

    private int rangeMinimumQueryLazy(int segmentTree[], int lazy[], int qlow, int qhigh, int low, int high, int pos)
    {
        if(low > high)
        {
            return Integer.MAX_VALUE;
        }
        if (lazy[pos] != 0)
        {
            segmentTree[pos] += lazy[pos];
            if (low != high)
            {
                lazy[2 * pos + 1] += lazy[pos];
                lazy[2 * pos + 2] += lazy[pos];
            }
            lazy[pos] = 0;
        }

        if(qlow > high || qhigh < low)
        {
            return Integer.MAX_VALUE;
        }

        if(qlow <= low && qhigh >= high)
        {
            return segmentTree[pos];
        }

        int mid = (low+high)/2;
        return Math.min(rangeMinimumQueryLazy(segmentTree, lazy, qlow, qhigh, low, mid, 2 * pos + 1), rangeMinimumQueryLazy(segmentTree, lazy,  qlow, qhigh, mid + 1, high, 2 * pos + 2));
    }
}


import java.util.Scanner;

public class A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		BWCube bwc = new BWCube();
		bwc.print();
	}

}

class BWCube {

	BWCube () {
		Scanner in = new Scanner(System.in);
		n = in.nextInt();
	}

	boolean sol () {
		if (n % 2 != 0) {
			return false;
		}
		return true;
	}

	void formLayers() {
		layer_o = new char[n][n];
		layer_e = new char[n][n];

		int lo = n/2-1;
		int hi = n/2;

		int rnd = 0;

		while (lo >= 0) {
			for (int k = lo; k <= hi; k++){
				layer_o[lo][k] = layer_o[hi][k] = bw[rnd];
				layer_e[lo][k] = layer_e[hi][k] = bw[1-rnd];
			}

			for (int k = lo+1; k < hi; k++){
				layer_o[k][lo] = layer_o[k][hi] = bw[rnd];
				layer_e[k][lo] = layer_e[k][hi] = bw[1-rnd];
			}

			lo--;
			hi++;
			rnd = 1-rnd;
		}

		lro = new String[n];
		lre = new String[n];

		for (int i = 0; i < n; i++){
			lro[i] = String.valueOf(layer_o[i]);
			lre[i] = String.valueOf(layer_e[i]);
		}

	}
	void printLayers() {

		int lr = 0;

		while (lr < n) {

			for (int i = 0; i < n; i++){
				System.out.println(lro[i]);
			}
			System.out.println();

			for (int i = 0; i < n; i++){
				System.out.println(lre[i]);
			}
			System.out.println();

			lr = lr + 2;
		}
	}

	void print() {
		if (sol()) {
			formLayers();
			printLayers();
		}
		else {
			System.out.println("-1");
		}
	}

	char[][] layer_o;
	char[][] layer_e;

	String[] lro;
	String[] lre;

	int n;
	static char[] bw = {'b', 'w'};
}


import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {

   // public static ArrayList<String> list = new ArrayList<String>();

    public static Scanner input = new Scanner(System.in);

    public static void main(String[] args)
            throws IOException {

   //  BufferedReader buffer=new BufferedReader(new InputStreamReader(System.in));
        //  String str;
        //  while((str=buffer.readLine())!=null){

  int n=input.nextInt();
if(n%2!=0){
    System.out.println("-1");
    return;

}

   for(int i=0;i<n;i++){
   boolean b=false;
   boolean w=false;
     int c=0;

     if(i%2==0){
         for(int ii=0;ii<n;ii++){
             b=false;
               if(ii%2==0 && c==2 ){
                   b=true;
                   w=true;
                   c=-2;
               }
               if(c==0){
                   b=false;w=false;}
              c++;
              if(w==true)
                  b=true;
            for(int jj=0;jj<n/2;jj++){

             if(b==false){
                 System.out.print("BB");
                 b=true;
                 continue;
             }
             if(b==true){
                 b=false;
               System.out.print("WW");
               continue;
             }

            }
             System.out.println();

         }
         System.out.println();
     }else{
                for(int ii=0;ii<n;ii++){
             b=false;
               if(ii%2==0 && c==2 ){
                   b=true;
                   w=true;
                   c=-2;
               }
               if(c==0){
                   b=false;w=false;}
              c++;
              if(w==true)
                  b=true;
            for(int jj=0;jj<n/2;jj++){

             if(b==false){
                 System.out.print("WW");
                 b=true;
                 continue;
             }
             if(b==true){
                 b=false;
               System.out.print("BB");
               continue;
             }

            }
             System.out.println();

         }
         System.out.println();
     }
   }// main

    }}


import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {

   // public static ArrayList<String> list = new ArrayList<String>();

    public static Scanner input = new Scanner(System.in);

    public static void main(String[] args)
            throws IOException {

   //  BufferedReader buffer=new BufferedReader(new InputStreamReader(System.in));
        //  String str;
        //  while((str=buffer.readLine())!=null){

  int n=input.nextInt();
if(n%2!=0){
    System.out.println("-1");
    return;

}

   for(int i=0;i<n;i++){
   boolean b=false;
   boolean w=false;
     int c=0;

     if(i%2==0){
         for(int ii=0;ii<n;ii++){
             b=false;
               if(ii%2==0 && c==2 ){
                   b=true;
                   w=true;
                   c=-2;
               }
               if(c==0){
                   b=false;w=false;}
              c++;
              if(w==true)
                  b=true;
            for(int jj=0;jj<n/2;jj++){

             if(b==false){
                 System.out.print("bb");
                 b=true;
                 continue;
             }
             if(b==true){
                 b=false;
               System.out.print("ww");
               continue;
             }

            }
             System.out.println();

         }
         System.out.println();
     }else{
                for(int ii=0;ii<n;ii++){
             b=false;
               if(ii%2==0 && c==2 ){
                   b=true;
                   w=true;
                   c=-2;
               }
               if(c==0){
                   b=false;w=false;}
              c++;
              if(w==true)
                  b=true;
            for(int jj=0;jj<n/2;jj++){

             if(b==false){
                 System.out.print("ww");
                 b=true;
                 continue;
             }
             if(b==true){
                 b=false;
               System.out.print("bb");
               continue;
             }

            }
             System.out.println();

         }
         System.out.println();
     }
   }// main

    }}


import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {

   // public static ArrayList<String> list = new ArrayList<String>();

    public static Scanner input = new Scanner(System.in);

    public static void main(String[] args)
            throws IOException {

   //  BufferedReader buffer=new BufferedReader(new InputStreamReader(System.in));
        //  String str;
        //  while((str=buffer.readLine())!=null){

  int n=input.nextInt();
if(n%2!=0){
    System.out.println("-1");
    return;

}

   StringBuilder S=new StringBuilder("");
   StringBuilder S2=new StringBuilder("");
   boolean one=false;
   for(int i=0;i<n/2;i++){
       if(one==false){
           S=S.append("bb");
           one=true;
       }else{
           one=false;
           S=S.append("ww");
       }
   }
   one=true;
      for(int i=0;i<n/2;i++){
       if(one==false){
           S2=S2.append("bb");
           one=true;
       }else{
           one=false;
           S2=S2.append("ww");
       }
   }
    String s=String.valueOf(S).concat("\n").concat(String.valueOf(S));
    String s2=String.valueOf(S2).concat("\n").concat(String.valueOf(S2));

    for(int i=0;i<n;i++){

        if(i%2==0){
           for(int ii=0;ii<n/2;ii++){
               if(ii%2==0){
                   System.out.println(s);
               }else{
                   System.out.println(s2);
               }
           }
        }else{
               for(int ii=0;ii<n/2;ii++){
               if(ii%2==0){
                   System.out.println(s2);
               }else{
                   System.out.println(s);
               }
           }

        }
        System.out.println();

    }

    }}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());
        if (n % 2 == 1) {
            System.out.println(-1);
            return;
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    int x=j;
                    if(k<x)x=k;
                    if(n-k-1<x)x=n-k-1;
                    if(n-j-1<x)x=n-j-1;
                    boolean b=(x%2==0);
                    if(i%2==1)b=!b;
                    if ((x % 2 == 0) ^ (i % 2 == 1)) {
                        System.out.append("b");
                    } else {
                        System.out.append("w");
                    }
                }
                System.out.append("\n");
            }
            System.out.append("\n");
        }
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());
        if (n % 2 == 1) {
            System.out.println(-1);
            return;
        }

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    int x=j;
                    if(k<x)x=k;
                    if(n-k-1<x)x=n-k-1;
                    if(n-j-1<x)x=n-j-1;
                    boolean b=(x%2==0);
                    if(i%2==1)b=!b;
                    if ((x % 2 == 0) ^ (i % 2 == 1)) {
                        sb.append("b");
                    } else {
                        sb.append("w");
                    }
                }
                sb.append("\n");
            }
            sb.append("\n");
        }
        System.out.print(sb.toString());
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author  tasyrkin
 * @since   2013/06/23
 */
public class CFTesting7A {
    public static void main(final String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        if (n % 2 == 1) {
            System.out.println(-1);
            return;
        }

        boolean[][] sq = new boolean[n][n];
        boolean isBlack = true;
        for (int s = 0; s < n / 2; s++) {
            for (int i = s; i < n - s; i++) {
                sq[s][i] = isBlack;
                sq[n - s - 1][i] = isBlack;
                sq[i][s] = isBlack;
                sq[i][n - s - 1] = isBlack;
            }

            isBlack = !isBlack;
        }

        boolean isInvert = false;
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < sq.length; i++) {
                StringBuffer sb = new StringBuffer();
                for (int j = 0; j < sq[0].length; j++) {
                    String c = (sq[i][j]) ? "b" : "w";
                    if (isInvert) {
                        c = c.equals("b") ? "w" : "b";
                    }

                    sb.append(c);
                }

                System.out.println(sb.toString());
            }

            isInvert = !isInvert;
            System.out.println();
        }
    }

}


import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class black
 {
   public static void main(String args[]) throws IOException
    {
     BufferedReader cin=new BufferedReader(new InputStreamReader(System.in));
     int n=Integer.parseInt(cin.readLine());
     for(int i=0;i<n;i++)
     {
       for(int j=0;j<n;j++)
       {
         for(int k=0;k<n/2;k++)
          {
            if((i/2)%2==0)
            {
              if(j%2==0)
                  {
                    if(k%2==0)
                    System.out.print("ww");
                    else
                     System.out.print("bb");
                   }
                 else
                   {
                    if(k%2==0)
                     System.out.print("bb");
                    else
                     System.out.print("ww");
                     }

            }
            else
            {
              if(j%2==0)
                  {
                    if(k%2==0)
                    System.out.print("bb");
                    else
                     System.out.print("ww");
                   }
                 else
                   {
                    if(k%2==0)
                     System.out.print("ww");
                    else
                     System.out.print("bb");
                     }
            }
        }
        System.out.println();
        }

          System.out.println();
    }
      }
      }


import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class black
 {
   public static void main(String args[]) throws IOException
    {
     BufferedReader cin=new BufferedReader(new InputStreamReader(System.in));
     int n=Integer.parseInt(cin.readLine());
     if(n%2==0)
     {
     for(int i=0;i<n;i++)
     {
       for(int j=0;j<n;j++)
       {
         for(int k=0;k<n/2;k++)
          {
            if((i/2)%2==0)
            {
              if(j%2==0)
                  {
                    if(k%2==0)
                    System.out.print("ww");
                    else
                     System.out.print("bb");
                   }
                 else
                   {
                    if(k%2==0)
                     System.out.print("bb");
                    else
                     System.out.print("ww");
                     }

            }
            else
            {
              if(j%2==0)
                  {
                    if(k%2==0)
                    System.out.print("bb");
                    else
                     System.out.print("ww");
                   }
                 else
                   {
                    if(k%2==0)
                     System.out.print("ww");
                    else
                     System.out.print("bb");
                     }
            }
        }
        System.out.println();
        }

          System.out.println();
    }
    }
    else
       System.out.println(-1);
      }
      }


import java.io.*;
import java.util.*;

public class Solution {
   BufferedReader in;
   StringTokenizer str;
   PrintWriter out;
   String SK;
   String next() throws IOException {
      while ((str == null) || (!str.hasMoreTokens())) {
      SK = in.readLine();
      if (SK == null)
      return null;
      str = new StringTokenizer(SK);
      }
      return str.nextToken();
   }
   int nextInt() throws IOException {
      return Integer.parseInt(next());
   }
   double nextDouble() throws IOException {
      return Double.parseDouble(next());
   }
   long nextLong() throws IOException {
      return Long.parseLong(next());
   }
   char[] charArray() throws IOException{
      return next().toCharArray();
   }
   public static void main(String[] args) throws IOException {
      new Solution().run();
   }
   void run() throws IOException {
      in = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);
      //in = new BufferedReader(new FileReader("input.txt"));
      //out = new PrintWriter("output.txt");
      solve();
      out.close();
   }
   void solve() throws IOException {
     int n=nextInt();
     if(n%2==1){
        out.println(-1);
     }
     else{
        for (int j = 0; j < n; j++) {
           for (int k = 0; k < n; k++) {
              for (int i = 0; i < n/2; i++) {
                 if((i+k)%2==0)out.print("ww");
                 else out.print("bb");
              }
              out.println("");
           }
           if(j<n-1)out.println("");
        }
     }

   }

}


import java.io.*;
import java.util.*;

public class Solution {
   BufferedReader in;
   StringTokenizer str;
   PrintWriter out;
   String SK;
   String next() throws IOException {
      while ((str == null) || (!str.hasMoreTokens())) {
      SK = in.readLine();
      if (SK == null)
      return null;
      str = new StringTokenizer(SK);
      }
      return str.nextToken();
   }
   int nextInt() throws IOException {
      return Integer.parseInt(next());
   }
   double nextDouble() throws IOException {
      return Double.parseDouble(next());
   }
   long nextLong() throws IOException {
      return Long.parseLong(next());
   }
   char[] charArray() throws IOException{
      return next().toCharArray();
   }
   public static void main(String[] args) throws IOException {
      new Solution().run();
   }
   void run() throws IOException {
      in = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);
      //in = new BufferedReader(new FileReader("input.txt"));
      //out = new PrintWriter("output.txt");
      solve();
      out.close();
   }
   void solve() throws IOException {
     int n=nextInt();
     if(n%2==1){
        out.println(-1);
     }
     else{
        int c=0;
        for (int j = 0; j < n; j++) {
           if(j%2==0)c++;
           for (int k = 0; k < n; k++) {
              for (int i = 0; i < n/2; i++) {
                 if(c%2==0){
                  if((i+k)%2==0)out.print("ww");
                  else out.print("bb");
                 }
                 else{
                    if((i+k)%2==0)out.print("bb");
                    else out.print("ww");
                 }
              }
              out.println("");
           }
           if(j<n-1)out.println("");
        }
     }

   }

}


//package tes7;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class A {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int n = ni();
		if(n % 2 == 1){
			out.println(-1);
		}else{
			for(int i = 0;i < n;i++){
				char a, b;
				if(i % 2 == 0){
					a = 'w'; b = 'b';
				}else{
					a = 'b'; b = 'w';
				}
				for(int j = 0;j < n;j++){
					for(int k = 0;k < n;k++){
						int d1 = j < n/2 ? n/2-1-j : j-n/2;
						int d2 = k < n/2 ? n/2-1-k : k-n/2;
						if(Math.max(d1, d2) % 2 == 0){
							out.print(a);
						}else{
							out.print(b);
						}
					}
					out.println();
				}
				out.println();
			}
		}
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception { new A().run(); }

	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}


import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class A
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;
	String FInput="";

	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{

			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}

	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}
		catch (NullPointerException e)
		{
			line=null;

		}

	}

	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	long NextLong()
	{
		String n = inputParser.nextToken();
		long val = Long.parseLong(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	double NextDouble()
	{
		String n = inputParser.nextToken();
		double val = Double.parseDouble(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}

	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}

	}

	public static void main(String [] argv)
	{
		//String filePath="input.txt";
        String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new A(filePath);
	}

	public void readFInput()
	{
		for(;;)
		{
			try
			{
				readNextLine();
				FInput+=line+" ";
			}
			catch(Exception e)
			{
				break;
			}
		}
		inputParser = new StringTokenizer(FInput, " ");
	}

	public A(String inputFile)
	{
		openInput(inputFile);
		readNextLine();
    	int k=NextInt();
    	StringBuilder ret = new StringBuilder();
    	if(k%2==1){System.out.println(-1);return;}
    	for(int i=0; i<k; i++)
    	{
    		for(int j=0; j<k; j++)
    		{
	    		for(int m=0; m<k; m++)
	    		{
	    			int x=j;
	    			if(m<x)x=m;
	    			if(k-m-1<x)x=k-m-1;
	    			if(k-j-1<x)x=k-j-1;
	    			boolean b=(x%2==0);
	    			if(i%2==1)b=!b;
	    			ret.append(b?"b":"w");
	    		}
	    		ret.append("\n");
    		}
    		ret.append("\n");
    	}
	    System.out.println(ret);

		closeInput();
	}

}


import java.io.StreamTokenizer;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		TokenizerReader in = new TokenizerReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(@SuppressWarnings("UnusedParameters") int testNumber, TokenizerReader in, PrintWriter out) {
        int k = in.nextInt();
        if (k % 2 == 1) {
            out.println(-1);
            return;
        }
        for (int layer = 0; layer < k; ++layer) {
            for (int i = 0; i < k; ++i) {
                for (int j = 0; j < k; ++j) {
                    int d = Math.max(Math.abs(2*i - (k-1)), Math.abs(2*j - (k-1)));
                    d = (d-1) / 2;
                    d += layer;
                    if (d % 2 == 0)
                        out.print("w");
                    else
                        out.print("b");
                }
                out.println();
            }
        }
    }
}

class TokenizerReader extends StreamTokenizer {
    public TokenizerReader(InputStream in) {
        super(new BufferedReader(new InputStreamReader(in)));
        defaultConfig();
    }

    public String nextString() {
        try {
            nextToken();
        } catch (IOException e) {
            throw new RuntimeException("nextString: exception in line " + lineno(), e);
        }
        return sval;
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

    public void defaultConfig() {
        resetSyntax();
        wordChars(33, 126);
        whitespaceChars(0, ' ');
    }

    }


import java.io.*;
import java.math.*;
import java.util.*;

public class Task323A implements Runnable {
  private void solve() throws IOException {
    int n = nextInt();
    if (n % 2 == 1) {
      writer.println(-1);
      return;
    }
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < n; ++j) {
        for (int k = 0; k < n; ++k) {
          if ((Math.min(
              Math.min(j, k), Math.min(n - 1 - j, n - 1 - k)) + i) % 2 == 1) {
            writer.print('b');
          } else {
            writer.print('w');
          }
        }
        writer.println();
      }
      writer.println();
    }
  }

  public static void main(String args[]) {
    new Task323A().run();
  }

  BufferedReader reader;
  PrintWriter writer;
  StringTokenizer tokenizer;

  public void run() {
    try {
      // System.setIn(new FileInputStream("test.in"));
      // System.setOut(new PrintStream(new FileOutputStream("test.out")));
      reader = new BufferedReader(new InputStreamReader(System.in));
      writer = new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
    }
  }

  String next() throws IOException {
    while (tokenizer == null || !tokenizer.hasMoreTokens()) {
      String s = reader.readLine();
      if (s == null) throw new IOException();
      tokenizer = new StringTokenizer(s);
    }
    return tokenizer.nextToken();
  }

  int nextInt() throws IOException {
    return Integer.parseInt(next());
  }

  long nextLong() throws IOException {
    return Long.parseLong(next());
  }

  double nextDouble() throws IOException {
    return Double.parseDouble(next());
  }
}


import java.io.*;
import java.math.*;
import java.util.*;

public class Task323A implements Runnable {
  private void solve() throws IOException {
    int n = nextInt();
    if (n != 2) {
      writer.println(-1);
      return;
    }
    writer.println("bb");
    writer.println("ww");
    writer.println();
    writer.println("bb");
    writer.println("ww");
  }

  public static void main(String args[]) {
    new Task323A().run();
  }

  BufferedReader reader;
  PrintWriter writer;
  StringTokenizer tokenizer;

  public void run() {
    try {
      // System.setIn(new FileInputStream("test.in"));
      // System.setOut(new PrintStream(new FileOutputStream("test.out")));
      reader = new BufferedReader(new InputStreamReader(System.in));
      writer = new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
    }
  }

  String next() throws IOException {
    while (tokenizer == null || !tokenizer.hasMoreTokens()) {
      String s = reader.readLine();
      if (s == null) throw new IOException();
      tokenizer = new StringTokenizer(s);
    }
    return tokenizer.nextToken();
  }

  int nextInt() throws IOException {
    return Integer.parseInt(next());
  }

  long nextLong() throws IOException {
    return Long.parseLong(next());
  }

  double nextDouble() throws IOException {
    return Double.parseDouble(next());
  }
}


import java.io.*;
import java.math.*;
import java.util.*;

public class Task323A implements Runnable {
  private void solve() throws IOException {
    int n = nextInt();
    if (n % 2 == 1) {
      writer.println(-1);
      return;
    }
    for (int i = 0; i < n; ++i) {
      char c = i % 2 == 0 ? 'b' : 'w';
      for (int j = 0; j < n; ++j) {
        for (int k = 0; k < n; ++k) {
          writer.print(c);
        }
        writer.println();
      }
      writer.println();
    }
  }

  public static void main(String args[]) {
    new Task323A().run();
  }

  BufferedReader reader;
  PrintWriter writer;
  StringTokenizer tokenizer;

  public void run() {
    try {
      // System.setIn(new FileInputStream("test.in"));
      // System.setOut(new PrintStream(new FileOutputStream("test.out")));
      reader = new BufferedReader(new InputStreamReader(System.in));
      writer = new PrintWriter(System.out);
      solve();
      reader.close();
      writer.close();
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
    }
  }

  String next() throws IOException {
    while (tokenizer == null || !tokenizer.hasMoreTokens()) {
      String s = reader.readLine();
      if (s == null) throw new IOException();
      tokenizer = new StringTokenizer(s);
    }
    return tokenizer.nextToken();
  }

  int nextInt() throws IOException {
    return Integer.parseInt(next());
  }

  long nextLong() throws IOException {
    return Long.parseLong(next());
  }

  double nextDouble() throws IOException {
    return Double.parseDouble(next());
  }
}


//+-------------------------------------+
//|     By   qwer_zcc                   |
//|     Date 30/09/2014                 |
//+-------------------------------------+
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <string>
#include <ctime>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#define INF (~0U>>1)-1
#define LLINF ~0ULL>>1
#define LL long long
#define uLL unsigned long long
#define uint unsigned int
#define D double
#define LD long double
#define rep(i,a,b) for (int i=a;i<=b;i++)
#define drep(i,a,b) for (int i=a;i>=b;i--)
#define M(a) memset(a,0,sizeof(a));
#define Chen(a,b,c) int((LL)(a)*(LL)(b)%(LL)(c))
#define pb push_back
#define mp make_pair
#define ps push
#define Pi M_PI
using namespace std;
template<class T> inline T min(T &a,T &b) {return a<b?a:b;}
template<class T> inline T max(T &a,T &b) {return a>b?a:b;}
template<class T> void read(T &x)
{
	char ch;
	while ((ch=getchar()) && !isdigit(ch));x=ch-'0';
	while ((ch=getchar()) && isdigit(ch)) x=x*10+ch-'0';
}
struct point
{
	int x,y;
	point() {}
	point(int _x,int _y) : x(_x),y(_y) {}
} ;
int n;
int main()
{
	scanf("%d",&n);
	if (n&1) {puts("-1");return 0;}
	rep(i,1,n)
	{
		rep(j,1,n)
		{
			rep(k,1,n)
			if (( (j+1)/2+(k+1)/2 )&1) printf(i&1?"W":"B");
			else printf(i&1?"B":"W");
			puts("");
		}
		puts("");
	}
}


//+-------------------------------------+
//|     By   qwer_zcc                   |
//|     Date 30/09/2014                 |
//+-------------------------------------+
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <string>
#include <ctime>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#define INF (~0U>>1)-1
#define LLINF ~0ULL>>1
#define LL long long
#define uLL unsigned long long
#define uint unsigned int
#define D double
#define LD long double
#define rep(i,a,b) for (int i=a;i<=b;i++)
#define drep(i,a,b) for (int i=a;i>=b;i--)
#define M(a) memset(a,0,sizeof(a));
#define Chen(a,b,c) int((LL)(a)*(LL)(b)%(LL)(c))
#define pb push_back
#define mp make_pair
#define ps push
#define Pi M_PI
using namespace std;
template<class T> inline T min(T &a,T &b) {return a<b?a:b;}
template<class T> inline T max(T &a,T &b) {return a>b?a:b;}
template<class T> void read(T &x)
{
	char ch;
	while ((ch=getchar()) && !isdigit(ch));x=ch-'0';
	while ((ch=getchar()) && isdigit(ch)) x=x*10+ch-'0';
}
struct point
{
	int x,y;
	point() {}
	point(int _x,int _y) : x(_x),y(_y) {}
} ;
int n;
int main()
{
	scanf("%d",&n);
	if (n&1) {puts("-1");return 0;}
	rep(i,1,n)
	{
		rep(j,1,n)
		{
			rep(k,1,n)
			if (( (j+1)/2+(k+1)/2 )&1) printf(i&1?"w":"b");
			else printf(i&1?"b":"w");
			puts("");
		}
		puts("");
	}
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    cin>>n;
    if(n%2==1)
    {
        cout<<-1;
        return 0;
    }
    for(int i=0;i<n/2;i++)
    {
        for(int j=0;j<n;j++)
        {
            for(int g=0;g<n/2;g++)
            {
                if((g+j+i)%2==0)
                    cout<<"bb";
                else
                    cout<<"ww";
            }
            cout<<endl;
        }
        cout<<endl;
        for(int j=0;j<n;j++)
        {
            for(int g=0;g<n/2;g++)
            {
                if((g+j+i)%2==0)
                    cout<<"bb";
                else
                    cout<<"ww";
            }
            cout<<endl;
        }
        cout<<endl;
    }
}


#include <iostream >
using namespace std;
int main()
{
    int n;
    while(cin>>n)
    {
        if(n%2==1)
        {
            cout<<-1<<endl;
        }
        else
        {
            for(int i=0;i<n;i++)
            {
                if(i%4==0 || i%4==1)
                {
                    for(int j=0;j<n;j++)
                    {
                        if(j%2==0)
                        {
                            for(int k=0;k<n;k++)
                                if(k%4==0 || k%4==1)cout<<"w";
                                else cout<<"b";
                            cout<<endl;
                        }
                        else
                        {
                            for(int k=0;k<n;k++)
                                if(k%4==0 || k%4==1)cout<<"b";
                                else cout<<"w";
                            cout<<endl;
                        }
                    }
                    cout<<endl;
                }
                else
                {
                    for(int j=0;j<n;j++)
                    {
                        if(j%2==1)
                        {
                            for(int k=0;k<n;k++)
                                if(k%4==0 || k%4==1)cout<<"w";
                                else cout<<"b";
                            cout<<endl;
                        }
                        else
                        {
                            for(int k=0;k<n;k++)
                                if(k%4==0 || k%4==1)cout<<"b";
                                else cout<<"w";
                            cout<<endl;
                        }
                    }
                    cout<<endl;
                }
            }
        }
    }
    return 0;

}


#include <iostream >
using namespace std;
int main()
{
	int n;
	while(cin>>n){
	if(n!=2)
	{
		cout<<-1<<endl;
	}
	else
	{
		cout<<"bb\nww\n\nbb\nww"<<endl;
	}
		}
	return 0;

}


#include<stdio.h>
#include<string.h>  /*
#include <algorithm>
#include<iostream>
#include<string.h>
#include <algorithm>*/
//using namespace std;
int main()
{
int k,i,j,m,g=2;
scanf("%d",&k);
if(k%2!=0)
{
printf("%d",-1);
}
else {
     for(i=1;i<=k;i++)
      {
        for(j=1;j<=k;j++)
        {
           for(m=1;m<=k;m++)
           {
            if(g==2 || g==1)
            {
              printf("b");
              g--;
            }
             else if(g==0 || g==-1)
                  {
                    printf("w");
                    if(g==-1)
                    {
                     g=3;
                    }
                   --g;
                  }
//         printf("\n");
         }
       printf("\n");
        }
      }

     }
return 0;
}


#include<stdio.h>
#include<string.h>  /*
#include <algorithm>
#include<iostream>
#include<string.h>
#include <algorithm>*/
//using namespace std;
int main()
{
int k,i,j,m,g=2;
scanf("%d",&k);
if(k%2!=0)
{
printf("%d",-1);
}
else {
     for(i=1;i<=k;i++)
      {
        for(j=1;j<=k;j++)
        {
           for(m=1;m<=k;m++)
           {
            if(g==2 || g==1)
            {
              printf("b ");
              g--;
            }
             else if(g==0 || g==-1)
                  {
                    printf("w ");
                    if(g==-1)
                    {
                     g=3;
                    }
                   --g;
                  }
//         printf("\n");
         }
       printf("\n");
        }
      }

     }
return 0;
}


#include<stdio.h>
#include<string.h>  /*
#include <algorithm>
#include<iostream>
#include<string.h>
#include <algorithm>*/
//using namespace std;
int main()
{
int k,i,j,m,g=2;
scanf("%d",&k);
if(k%2!=0)
{
printf("%d",-1);
}
else {
     for(i=1;i<=k;i++)
      {
        for(j=1;j<=k;j++)
        {
           for(m=1;m<=k;m++)
           {
            if(g==2 || g==1)
            {
              printf("b ");
              g--;
            }
             else if(g==0 || g==-1)
                  {
                    printf("w ");
                    if(g==-1)
                    {
                     g=3;
                    }
                   --g;
                  }
         printf("\n");
         }
       printf("\n");
        }
      }

     }
return 0;
}


/*
On your knees
Praying at the burial ground
Mistrustful eyes of intimacy
Pointing the way to the other side
You hear the screams of a million souls
Unguarded and left to their own resources
Where time turned into a frozen block
And even the water of life

You will die!

Wander in the valley

As you reach for the sky
With hollow shells of faded dreams
Time bomb ticking has just begun
To make reprisals on what I have done
Like grains of sand that fall from my hand
The fate I feel is drawing near
Shackles in my brain losing so fast
Waiting to unfold

Mummified bodies
Elixir of life wasting away
Perpetual glares of those who are delivered
Entomber in the derbis of honour and blood
A sinful voice that prophesied
Death becomes easy just close your eyes
Incantation of freedom so urgent and true
Your wish is my command
*/

//#pragma comment(linker, "/STACK:16777216")
#include <fstream>
#include <iostream>
#include <string>
#include <complex>
#include <math.h>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <stdio.h>
#include <stack>
#include <algorithm>
#include <list>
#include <ctime>
//#include <memory.h>

#define y0 sdkfaslhagaklsldk
#define y1 aasdfasdfasdf
#define yn askfhwqriuperikldjk
#define j1 assdgsdgasghsf
#define tm sdfjahlfasfh
#define lr asgasgash

#define  INF 100000000
#define eps 1e-10
//#define M_PI 3.141592653589793
//#define mx 1000000000000ll
#define bs 1000000007

//#define free asdfasdfsdadsg
#define MAXN 10000
//#define SIZE 60
#define bsize 256

using namespace std;

long n,temp;

int main(){
//freopen("transform.in ","r",stdin);
//freopen("transform.out","w",stdout);
//freopen("C:/input.txt","r",stdin);
//freopen("C:/output.txt","w",stdout);
ios_base::sync_with_stdio(0);

cin>>n;
if (n%2){cout<<-1<<endl;return 0;}
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
for (int q=0;q<n;q++)
{
    temp=i/2%2+j/2%2+q%2;
    if (temp%2)cout<<"b";else cout<<"w";
}cout<<endl;
}cout<<endl;}
cin.get();cin.get();
return 0;}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
char ar[105][105],br[105][105];
int main()
{
	int n;
	scanf("%d", &n);
	if(n&1)
	{
		puts("-1");
		return 0;
	}int sek=0;
	for(int i=0;i<n/2;i++){
		sek^=1;
		if(sek)
		{
			for(int j=i;j<n-i;j++)
			{
				ar[i][j]=ar[j][i]=ar[n-i-1][n-j-1]=ar[n-j-1][n-i-1]='w';
			}
		}
		else
		{
			for(int j=i;j<n-i;j++)
			{
				ar[i][j]=ar[j][i]=ar[n-i-1][n-j-1]=ar[n-j-1][n-i-1]='b';
			}
		}
	}
	sek=0;
	for(int i=0;i<n/2;i++){
		sek^=1;
		if(sek)
		{
			for(int j=i;j<n-i;j++)
			{
				br[i][j]=br[j][i]=br[n-i-1][n-j-1]=br[n-j-1][n-i-1]='b';
			}
		}
		else
		{
			for(int j=i;j<n-i;j++)
			{
				br[i][j]=br[j][i]=br[n-i-1][n-j-1]=br[n-j-1][n-i-1]='w';
			}
		}
	}

	for(int i=0;i<n/2;i++)
	{
		for(int j=0;j<n;j++) puts(ar[j]);
		puts("");
		for(int j=0;j<n;j++) puts(br[j]);
		puts("");
	}
	return 0;
}


#include <iostream>
#include <fstream>
#include <cstdio>
#include <math.h>
#include <queue>
#include <stack>
#include <set>
#include <string>
#include <utility>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <vector>
using namespace std;

#define ull unsigned long long
#define INF 1000000000000000000ll
#define ll long long
#define F first
#define S second
#define mp make_pair

int k;

int main(){

	cin >> k ;

	if(k==2){
		cout<<"bb"<<endl<<"ww"<<endl<<endl;
		cout<<"bb"<<endl<<"ww"<<endl<<endl;
		return 0;
	}
	cout<<-1;
	return 0;

}


#include <iostream>
#include <fstream>
#include <cstdio>
#include <math.h>
#include <queue>
#include <stack>
#include <set>
#include <string>
#include <utility>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <vector>
using namespace std;

#define ull unsigned long long
#define INF 1000000000000000000ll
#define ll long long
#define F first
#define S second
#define mp make_pair

int k,i,j,l,a[111][111];

void rec(int x){
	if(1+x>k-x){return;}
	for(i=1+x;i<=k-x;i++)a[i][1+x]=a[i][k-x]=x%2;
	for(i=1+x;i<=k-x;i++)a[1+x][i]=a[k-x][i]=x%2;
	rec(x+1);
}

int main(){

	cin >> k ;

	if(k%2){
		cout<<-1;
		return 0;
	}
	rec(0);

	for(l=1;l<=k;l++){
		for(i=1;i<=k;i++){
			for(j=1;j<=k;j++){
				if(l%2){if(a[i][j])cout<<'w';else cout<<'b';}
				else   {if(a[i][j])cout<<'b';else cout<<'w';}
			}
			cout<<endl;
		}
		cout<<endl;
	}
	return 0;

}


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>

const int mod = 1e9+7;
const int N = 100010;
const int inf = 0x3f3f3f3f;
const double eps=1e-8;

using namespace std;

typedef long long ll;

int main(){
	int n;
	scanf("%d", &n);
	if(n & 1) return puts("-1"), 0;
	string s[2] = {"ww", "bb"};
	for(int k = 0; k < n; k++){
		for(int i = 0; i < n; i++, cout << endl)
			for(int j = 0; j < n / 2; j++)
				cout << s[(i + j) & 1];
		cout << endl;
		if((k + 1) % 4 == 0) swap(s[0], s[1]);
	}
	return 0;
}


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>

const int mod = 1e9+7;
const int N = 100010;
const int inf = 0x3f3f3f3f;
const double eps=1e-8;

using namespace std;

typedef long long ll;

int main(){
	int n;
	scanf("%d", &n);
	if(n & 1) return puts("-1"), 0;
	string s[2] = {"ww", "bb"};
	for(int k = 0; k < n; k++){
		for(int i = 0; i < n; i++, cout << endl)
			for(int j = 0; j < n / 2; j++)
				cout << s[(i + j) & 1];
		cout << endl;
		if((k + 1) % 2 == 0) swap(s[0], s[1]);
	}
	return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    int n;
    cin>>n;
    if (n % 2) {
        cout<<-1<<endl;
        return 0;
    }
    for(int k=0; k<n; ++k) {
        for(int i=0; i<n; ++i) {
            for(int j==0; j<n; ++j) {
                if ((i/2%2) ^ (j/2%2) ^ (k%2))
                    printf("w");
                else
                    printf("b");
//                printf("%c", (((i/2%2) ^ (j/2%2) ^ (k%2)) == 1 ? 'b' : 'w'));
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    int n;
    cin>>n;
    if (n % 2) {
        cout<<-1<<endl;
        return 0;
    }
    for(int k=0; k<n; ++k) {
        for(int i=0; i<n; ++i) {
            for(int j=0; j<n; ++j) {
//                if ((i/2%2) ^ (j/2%2) ^ (k%2))
//                    printf("w");
//                else
//                    printf("b");
                printf("%c", (((i/2%2) ^ (j/2%2) ^ (k%2)) == 1 ? 'b' : 'w'));
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}


#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    int n;
    cin>>n;
    if (n % 2) {
        cout<<-1<<endl;
        return 0;
    }
    for(int k=0; k<n; ++k) {
        for(int i=0; i<n; ++i) {
            for(int j==0; j<n; ++j) {
                printf("%c", (((i/2%2) ^ (j/2%2) ^ (k%2)) == 1 ? 'b' : 'w'));
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define X first
#define Y second
#define sqr(x) ((x)*(x))
#define lowbit(x) ((x)&-(x))
#define fill(A,B) memset(A,B,sizeof(A))
#define Copy(A,B) memcpy(A,B,sizeof(A))
#define rep(i,A,B) for(int i=A;i<=B;i++)
#define per(i,B,A) for(int i=B;i>=A;i--)
#define RE(B,A) for(A::iterator it=B.begin();it!=B.end();++it)
#define re(i,A) for(int i=0;i<(int)A;i++)
#define re1(i,A) for(int i=1;i<(int)A;i++)
#define de(i,A) for(int i=A-1;i+1;i--)
#define For(i,A,B) for(int i=A;i<B;i++)
#define foredg(i,A) for(int i=H[A];i;i=e[i].nxt)
#define inf (1<<29)
#define inf64 (1LL<<50)
#define mn 100111
#define Mod (1000000007)
#define eps (1e-9)
#define si(x) ((int)x.size())
#define MAX(A,B) A=max(A,B)
#define MIN(A,B) A=min(A,B)
#define ls (cur<<1)
#define rs (cur<<1|1)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> pii;
typedef multiset<pii> Set;

const int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
ll powmod(ll a,ll b) {ll tmp=1;a%=Mod;for(;b;b>>=1){if(b&1)tmp=tmp*a%Mod;a=a*a%Mod;}return tmp;}
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template<class T>inline void R(T &xx){xx=0;char ch=getchar();bool F=0;while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();if(ch=='-')F=1,ch=getchar();while(ch>='0'&&ch<='9')xx=xx+xx+(xx<<3)+ch-48,ch=getchar();if(F)xx=-xx;}
template<class T>inline void add(int&x,T y){for(x+=y;x>=Mod;x-=Mod);}

int n;
int main(){
#ifndef ONLINE_JUDGE
    //freopen("1.in","r",stdin);
    //freopen("1.out","w",stdout);
#endif
    R(n);if(n&1)return puts("-1"),0;
    re(i,n)re(j,n){re(k,n)
        putchar(((i/2+j/2+k)&1)?'b':'w');puts("");}
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define X first
#define Y second
#define sqr(x) ((x)*(x))
#define lowbit(x) ((x)&-(x))
#define fill(A,B) memset(A,B,sizeof(A))
#define Copy(A,B) memcpy(A,B,sizeof(A))
#define rep(i,A,B) for(int i=A;i<=B;i++)
#define per(i,B,A) for(int i=B;i>=A;i--)
#define RE(B,A) for(A::iterator it=B.begin();it!=B.end();++it)
#define re(i,A) for(int i=0;i<(int)A;i++)
#define re1(i,A) for(int i=1;i<(int)A;i++)
#define de(i,A) for(int i=A-1;i+1;i--)
#define For(i,A,B) for(int i=A;i<B;i++)
#define foredg(i,A) for(int i=H[A];i;i=e[i].nxt)
#define inf (1<<29)
#define inf64 (1LL<<50)
#define mn 100111
#define Mod (1000000007)
#define eps (1e-9)
#define si(x) ((int)x.size())
#define MAX(A,B) A=max(A,B)
#define MIN(A,B) A=min(A,B)
#define ls (cur<<1)
#define rs (cur<<1|1)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> pii;
typedef multiset<pii> Set;

const int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
ll powmod(ll a,ll b) {ll tmp=1;a%=Mod;for(;b;b>>=1){if(b&1)tmp=tmp*a%Mod;a=a*a%Mod;}return tmp;}
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template<class T>inline void R(T &xx){xx=0;char ch=getchar();bool F=0;while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();if(ch=='-')F=1,ch=getchar();while(ch>='0'&&ch<='9')xx=xx+xx+(xx<<3)+ch-48,ch=getchar();if(F)xx=-xx;}
template<class T>inline void add(int&x,T y){for(x+=y;x>=Mod;x-=Mod);}

int n;
int main(){
#ifndef ONLINE_JUDGE
    freopen("1.in","r",stdin);
    //freopen("1.out","w",stdout);
#endif
    R(n);if(n&1)return puts("-1"),0;
    rep(i,1,n)rep(j,1,n)rep(k,1,n)
        putchar(((i/2+j/2+k)&1)?'b':'w');
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define X first
#define Y second
#define sqr(x) ((x)*(x))
#define lowbit(x) ((x)&-(x))
#define fill(A,B) memset(A,B,sizeof(A))
#define Copy(A,B) memcpy(A,B,sizeof(A))
#define rep(i,A,B) for(int i=A;i<=B;i++)
#define per(i,B,A) for(int i=B;i>=A;i--)
#define RE(B,A) for(A::iterator it=B.begin();it!=B.end();++it)
#define re(i,A) for(int i=0;i<(int)A;i++)
#define re1(i,A) for(int i=1;i<(int)A;i++)
#define de(i,A) for(int i=A-1;i+1;i--)
#define For(i,A,B) for(int i=A;i<B;i++)
#define foredg(i,A) for(int i=H[A];i;i=e[i].nxt)
#define inf (1<<29)
#define inf64 (1LL<<50)
#define mn 100111
#define Mod (1000000007)
#define eps (1e-9)
#define si(x) ((int)x.size())
#define MAX(A,B) A=max(A,B)
#define MIN(A,B) A=min(A,B)
#define ls (cur<<1)
#define rs (cur<<1|1)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> pii;
typedef multiset<pii> Set;

const int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
ll powmod(ll a,ll b) {ll tmp=1;a%=Mod;for(;b;b>>=1){if(b&1)tmp=tmp*a%Mod;a=a*a%Mod;}return tmp;}
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template<class T>inline void R(T &xx){xx=0;char ch=getchar();bool F=0;while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();if(ch=='-')F=1,ch=getchar();while(ch>='0'&&ch<='9')xx=xx+xx+(xx<<3)+ch-48,ch=getchar();if(F)xx=-xx;}
template<class T>inline void add(int&x,T y){for(x+=y;x>=Mod;x-=Mod);}

int n;
int main(){
#ifndef ONLINE_JUDGE
    freopen("1.in","r",stdin);
    //freopen("1.out","w",stdout);
#endif
    R(n);if(n&1)return puts("-1"),0;
    rep(i,1,n)rep(j,1,n){rep(k,1,n)
        putchar(((i/2+j/2+k)&1)?'b':'w');puts("");}
    return 0;
}


#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <utility>
#include <map>
#include <list>
#include <stdio.h>
#include <queue>
#include <set>
#include <cstdio>
#include <string>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stack>
#include <queue>
#include<stdio.h>
#include <limits.h>

#define F(i,n) for(int i = 0;i<n;i++)
#define FL(i,n) for(int i = n-1;i>=0;i--)
#define F1(i,n) for(int i = 1;i<=n;i++)
#define Fjin(j,i,n) for(int j = i;j<=n;j++)
#define MP(a,b) make_pair(a,b)
#define vint vector<int>
#define v2int vector<vector<int> >
using namespace std;

int main() {
    int n;
    cin>>n;
    if(n%2==1){cout<<-1;return 0;}
    if(n==2){cout<<"bb\nww\n\nbb\nww";return 0;}
    //string s="bbvv";
    bool b=true;
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j+=2){
                if(b){cout<<"bb";b=false;}
                else{cout<<"ww";b=true;}
            }
            if(b)b=false;else b=true;
            cout<<"\n";
        }
        if(k%2==0){
        if(b)b=false;else b=true;}
        cout<<"\n\n";
    }
    return 0;
}


#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <utility>
#include <map>
#include <list>
#include <stdio.h>
#include <queue>
#include <set>
#include <cstdio>
#include <string>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stack>
#include <queue>
#include<stdio.h>
#include <limits.h>

#define F(i,n) for(int i = 0;i<n;i++)
#define FL(i,n) for(int i = n-1;i>=0;i--)
#define F1(i,n) for(int i = 1;i<=n;i++)
#define Fjin(j,i,n) for(int j = i;j<=n;j++)
#define MP(a,b) make_pair(a,b)
#define vint vector<int>
#define v2int vector<vector<int> >
using namespace std;

int main() {
    int n;
    cin>>n;
    if(n%2==1){cout<<-1;return 0;}
    if(n==2){cout<<"bb\nww\n\nbb\nww";return 0;}
    //string s="bbvv";
    bool b=true;
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j+=2){
                if(b){cout<<"bb";}
                else{cout<<"ww";}
                b=!b;
            }
            if((n/2)%2==0)b=!b;
            cout<<"\n";
        }
        if(k%2==0){
        if(b)b=false;else b=true;}
        cout<<"\n\n";
    }
    return 0;
}


#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <utility>
#include <map>
#include <list>
#include <stdio.h>
#include <queue>
#include <set>
#include <cstdio>
#include <string>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stack>
#include <queue>
#include<stdio.h>
#include <limits.h>

#define F(i,n) for(int i = 0;i<n;i++)
#define FL(i,n) for(int i = n-1;i>=0;i--)
#define F1(i,n) for(int i = 1;i<=n;i++)
#define Fjin(j,i,n) for(int j = i;j<=n;j++)
#define MP(a,b) make_pair(a,b)
#define vint vector<int>
#define v2int vector<vector<int> >
using namespace std;

int main() {
    int n;
    cin>>n;
    if(n%2==1){cout<<-1;return 0;}
    if(n==2){cout<<"bb\nww\n\nbb\nww";return 0;}
    //string s="bbvv";
    bool b=true;
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j+=2){
                if(b){printf("bb");}
                else{printf("ww");}
                b=!b;
            }
            if((n/2)%2==0)b=!b;
            printf("\n");
        }
        if(k%2==0){
        if(b)b=false;else b=true;}
        printf("\n\n");
    }
    return 0;
}


#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <utility>
#include <map>
#include <list>
#include <stdio.h>
#include <queue>
#include <set>
#include <cstdio>
#include <string>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stack>
#include <queue>
#include<stdio.h>
#include <limits.h>

#define F(i,n) for(int i = 0;i<n;i++)
#define FL(i,n) for(int i = n-1;i>=0;i--)
#define F1(i,n) for(int i = 1;i<=n;i++)
#define Fjin(j,i,n) for(int j = i;j<=n;j++)
#define MP(a,b) make_pair(a,b)
#define vint vector<int>
#define v2int vector<vector<int> >
using namespace std;

int main() {
    int n;
    cin>>n;
    if(n%2==1){cout<<-1;return 0;}
    //if(n==2){cout<<"bb\nww\n\nbb\nww";return 0;}
    //string s="bbvv";
    bool b=true;
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j+=2){
                if(b){printf("bb");}
                else{printf("ww");}
                b=!b;
            }
            //if((n/2)%2==0)b=!b;
            puts("");
        }
        if(k%2==0){
        if(b)b=false;else b=true;}
        puts("");puts("");
    }
    return 0;
}


#include <cstdio>
#include <cstring>
#define rep(i,a,n) for (int i=a;i<n;i++)
int l;
int main() {
    scanf("%d",&l);
    if (l&1) return puts("-1"),0;
    else {
        rep(i,0,l) {
            rep(j,0,l) {
                rep(k,0,l) putchar(((j/2)&1)^((k/2)&1)^(i&1)?'w':'b');
                puts("");
            }
            puts("");
        }
    }
}


#include<vector>
#include<string>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<stack>
#include<cstdio>
using namespace std;
#define maxn 11111111
#define MOD 1000000007
int main()
{
	int n,i,j,k,flag;
	cin>>n;
	if(n%2==1)
		cout<<-1<<endl;
	else
	{
		for(k=0;k<n;k+=2)
		{
			flag=1;
			for(i=0;i<n;i+=2)
			{
				if(flag){
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("bb");
					else
						printf("ww");
				}
				putchar('\n');
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("bb");
					else
						printf("ww");
				}
				putchar('\n');
				}
				else
				{{
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("ww");
					else
						printf("bb");
				}
				putchar('\n');
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("ww");
					else
						printf("bb");
				}
				putchar('\n');
				}
				}
				flag=1-flag;
			}putchar('\n');
			flag=1;
			for(i=0;i<n;i+=2)
			{
				if(flag){
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("ww");
					else
						printf("bb");
				}
				putchar('\n');
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("ww");
					else
						printf("bb");
				}
				putchar('\n');
				}
				else
				{{
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("bb");
					else
						printf("ww");
				}
				putchar('\n');
				for(j=0;j<n;j+=2)
				{
					if(j/2%2==0)
					printf("bb");
					else
						printf("ww");
				}
				putchar('\n');
				}
				}
				flag=1-flag;
			}putchar('\n');
		}
	}
//	system("pause");
	return 0;
}


#include<vector>
#include<string>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<stack>
using namespace std;
#define maxn 11111111
#define MOD 1000000007
int main()
{
	int n,i,j,k,flag;
	cin>>n;
	if(n%2==1)
		cout<<-1<<endl;
	else
	{
		for(k=0;k<n;k+=2)
		{
			flag=1;
			for(i=0;i<n;i+=2)
			{
				if(flag){
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				}
				else
				{{
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				}
				}
				flag=1-flag;
			}putchar('\n');
			flag=1;
			for(i=0;i<n;i+=2)
			{
				if(flag){
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				}
				else
				{{
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				}
				}
				flag=1-flag;
			}putchar('\n');
		}
	}
//	system("pause");
	return 0;
}


#include<vector>
#include<string>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<cstdlib>
#include<stack>
#include<cstdio>
using namespace std;
#define maxn 11111111
#define MOD 1000000007
int main()
{
	int n,i,j,k,flag;
	cin>>n;
	if(n%2==1)
		cout<<-1<<endl;
	else
	{
		for(k=0;k<n;k+=2)
		{
			flag=1;
			for(i=0;i<n;i+=2)
			{
				if(flag){
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				}
				else
				{{
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				}
				}
				flag=1-flag;
			}putchar('\n');
			flag=1;
			for(i=0;i<n;i+=2)
			{
				if(flag){
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("wwbb");
				putchar('\n');
				}
				else
				{{
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				for(j=0;j<n;j+=4)
					printf("bbww");
				putchar('\n');
				}
				}
				flag=1-flag;
			}putchar('\n');
		}
	}
	//system("pause");
	return 0;
}


#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cin>>n;
    if (n%2==1){
        cout<<"-1\n";
    } else {
        int t=0;
        int a[102][102]={0};
        int visited[102][102]={0};
        for (int i=0;i<n/2;i++){
            int j=i;
            int k=n-1-i;
            for (int l=j;l<=k; l++){
                a[i][l]=t;
            }
            for (int l=j;l<=k; l++){
                a[l][i]=t;
            }
            for (int l=j;l<=k; l++){
                a[n-1-i][l]=t;
            }
            for (int l=j;l<=k; l++){
                a[l][n-1-i]=t;
            }
            if (t==0){
                t=1;
            } else {
                t=0;
            }
        }

        int b[102][102]={0};
        for( int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                b[i][j]=!(a[i][j]);
            }
        }
        for (int i=0;i<n;i++){
            if (i%2==0){
                for (int j=0;j<n;j++) {
                    for(int k=0;k<n;k++){
                        if (a[j][k]==0){
                            cout<<"b";
                        } else {
                            cout<<"w";
                        }
                    }
                    cout<<"\n";
                }
                cout<<"\n";
            } else {
                for (int j=0;j<n;j++) {
                    for(int k=0;k<n;k++){
                        if (b[j][k]==0){
                            cout<<"b";
                        } else {
                            cout<<"w";
                        }
                    }
                    cout<<"\n";
                }
                cout<<"\n";
            }

        }

    }
    return 0;
}


#include <iostream>

using namespace std;
int n,i,j,k,d;
int main()
{
    cin>>n;
    if(n%2!=0){cout<<-1;return 0;}
    for(i=0;i<n;i++)
      {

        for(j=0;j<n;j++)
           {for(k=0;k<n/2;k++)
    {if((j+k+i/2)%2==0)
        cout<<"bb";
    else if((j+k+i/2)%2!=0)
        cout<<"ww";
    }cout<<endl;}
cout<<endl;

}
}


#include <iostream>

using namespace std;
int n,i,j,k;
int main()
{
    cin>>n;
    if(n%2!=0){cout<<-1;return 0;}
    for(i=0;i<n;i++)
      {

        for(j=0;j<n;j++)
           {for(k=0;k<n/2;k++)
    {if((j+k)%2==0)
        cout<<"bb";
    else if((j+k)%2!=0)
        cout<<"ww";
    }cout<<endl;}
cout<<endl;}
}


#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;

#define FOR(it, c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define SZ(c) ((int)(c).size())

int main(void) {
	int n;
	scanf("%d", &n);
	if(n%2) puts("-1");
	else {
		for(int i=0;i<n;i++ ,puts(""))
			for(int j=0;j<n;j++,puts(""))
				for(int k=0;k<n;k++)
					if((i%2)^(min(min(j,k),min(n-1-j,n-1-k))%2)) putchar('b');
					else putchar('w');
	}
	return 0;
}


#include <iostream>
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <string.h>
using namespace std;

int M[110][110][110];
int k;

int check(){

    int ok = 1;

    for(int i=1;i<=k;i++)
            for(int j=1;j<=k;j++)
                    for(int l=1;l<=k;l++){

                            int cnt = 0;

                            if(M[i][j][l+1] == M[i][j][l])cnt++;
                            if(M[i][j][l-1] == M[i][j][l])cnt++;
                            if(M[i+1][j][l] == M[i][j][l])cnt++;
                            if(M[i-1][j][l] == M[i][j][l])cnt++;
                            if(M[i][j+1][l] == M[i][j][l])cnt++;
                            if(M[i][j-1][l] == M[i][j][l])cnt++;
                        //    printf("i=%d j=%d l=%d cont=%d\n",i,j,l,cnt);

                            if(cnt != 2)return 0;
                            }
                            return 1;
}
char ch[] = {'b','w'};
main(){

       srand(time(0));
       memset(M,-1,sizeof(M));

      cin >> k;

       for(int a=0;clock() < (CLOCKS_PER_SEC/2);a++){

               for(int i=1;i<=k;i++)
                       for(int j=1;j<=k;j++)
                               for(int l=1;l<=k;l++)
                                       M[i][j][l] = rand()%2;
              // printf("!");
               if(check())break;
               }

       if(!check())printf("-1\n");

       else{
            for(int i=1;i<=k;i++){
                       for(int j=1;j<=k;j++){
                               for(int l=1;l<=k;l++){
                                       printf("%c",ch[M[i][j][l]]);

                                       }printf("\n");}printf("\n");}

            }
            }


#include <iostream>
#include <algorithm>
#include <cmath>
#include <assert.h>
#include <stdio.h>
#include <ctime>
#include <cstdlib>
#include <utility>
#include <string.h>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>

#define INF (1<<30)
#define pii pair<int,int>
#define pll pair<long long,long long>
#define eps 1e-9

#ifdef ONLINE_JUDGE
#define debug(args...)
#else
#define debug(args...) fprintf(stderr,args)
#endif

using namespace std;

main(){

		int n;
		scanf("%d",&n);

		if(n%2 == 1){
			printf("-1\n");
			return 0;}

		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				for(int k=0;k<n;k++)
					printf("%c",((max((2*j > n-1) ? (j-n/2+1) : (n/2-j),(2*k > n-1) ? (k-n/2+1) : (n/2-k))%2) ^ (i%2)) ? 'b' : 'w');
					printf("\n");
				}
				printf("\n");}}


#include <iostream>
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <string.h>
using namespace std;

int M[110][110][110];
int k;

int check(){

    int ok = 1;

    for(int i=1;i<=k;i++)
            for(int j=1;j<=k;j++)
                    for(int l=1;l<=k;l++){

                            int cnt = 0;

                            if(M[i][j][l+1] == M[i][j][l])cnt++;
                            if(M[i][j][l-1] == M[i][j][l])cnt++;
                            if(M[i+1][j][l] == M[i][j][l])cnt++;
                            if(M[i-1][j][l] == M[i][j][l])cnt++;
                            if(M[i][j+1][l] == M[i][j][l])cnt++;
                            if(M[i][j-1][l] == M[i][j][l])cnt++;
                        //    printf("i=%d j=%d l=%d cont=%d\n",i,j,l,cnt);

                            if(cnt != 2)return 0;
                            }
                            return 1;
}
char ch[] = {'b','w'};
main(){

       srand(time(0));
       memset(M,-1,sizeof(M));

      cin >> k;

       for(int a=0;clock() < (CLOCKS_PER_SEC);a++){

               for(int i=1;i<=k;i++)
                       for(int j=1;j<=k;j++)
                               for(int l=1;l<=k;l++)
                                       M[i][j][l] = rand()%2;
              // printf("!");
               if(check())break;
               }

       if(!check())printf("-1\n");

       else{
            for(int i=1;i<=k;i++){
                       for(int j=1;j<=k;j++){
                               for(int l=1;l<=k;l++){
                                       printf("%c ",ch[M[i][j][l]]);

                                       }printf("\n");}printf("\n");}

            }
            }


#include <iostream>
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <string.h>
using namespace std;

int M[110][110][110];
int k;

int check(){

    int ok = 1;

    for(int i=1;i<=k;i++)
            for(int j=1;j<=k;j++)
                    for(int l=1;l<=k;l++){

                            int cnt = 0;

                            if(M[i][j][l+1] == M[i][j][l])cnt++;
                            if(M[i][j][l-1] == M[i][j][l])cnt++;
                            if(M[i+1][j][l] == M[i][j][l])cnt++;
                            if(M[i-1][j][l] == M[i][j][l])cnt++;
                            if(M[i][j+1][l] == M[i][j][l])cnt++;
                            if(M[i][j-1][l] == M[i][j][l])cnt++;
                        //    printf("i=%d j=%d l=%d cont=%d\n",i,j,l,cnt);

                            if(cnt != 2)return 0;
                            }
                            return 1;
}
char ch[] = {'b','w'};
main(){

       srand(time(0));
       memset(M,-1,sizeof(M));

      cin >> k;

       for(int a=0;clock() < (CLOCKS_PER_SEC);a++){

               for(int i=1;i<=k;i++)
                       for(int j=1;j<=k;j++)
                               for(int l=1;l<=k;l++)
                                       M[i][j][l] = rand()%2;
              // printf("!");
               if(check())break;
               }

       if(!check())printf("-1\n");

       else{
            for(int i=1;i<=k;i++){
                       for(int j=1;j<=k;j++){
                               for(int l=1;l<=k;l++){
                                       printf("%c",ch[M[i][j][l]]);

                                       }printf("\n");}printf("\n");}

            }
            }


/***********************************************\
 |Author: WiYR
 |Created Time: 2013/8/14 21:15:15
 |File Name: Black-and-White Cube.cpp
 |Description:
\***********************************************/
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>

using namespace std;
char mp[111][111][111];
int main() {
//  freopen("input.txt","r",stdin);
    int n;
    char s[2]={'w','b'};
    scanf("%d",&n);
    if(n%2)puts("-1");
    else {
        for(int i=1;i<=n;i++){
            for(int k=1;k<=n/2;k++){
                for(int j=k;j<=n-k+1;j++)
                   mp[i][k][j]=s[abs(i%2-k%2)];
                for(int j=k+1;j<=n-k+1;j++)
                    mp[i][j][n-k+1]=s[abs(i%2-k%2)];
                for(int j=n-k;j>=k;j--)
                    mp[i][n-k+1][j]=s[abs(i%2-k%2)];
                for(int j=n-k;j>k;j--)
                    mp[i][j][k]=s[abs(i%2-k%2)];
            }
        }
        for(int k=1;k<=n;k++){
            for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++)
                  printf("%c",mp[k][i][j]);
            puts("");
            }
            puts("");
        }
    }
   return 0;
}


#include <iostream>

using namespace std;

int n;

int main()
{
	cin>>n;
	if(n%2)
		{cout<<-1<<endl;return 0;}
	for(int i=0;i<n;++i)
	{
		for(int j=0;j<n;++j)
		{
			for(int l=0;l<n;++l)
				cout<<((min(min(j,n-j-1),min(l,n-l-1))+i)%2==0 ? "b" : "w");
			cout<<endl;
		}
		cout<<endl;
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define Rep(i,n) for(int i = 0; i < (n); ++i)
#define Repd(i,n) for(int i = (n)-1; i >= 0; --i)
#define For(i,a,b) for(int i = (a); i <= (b); ++i)
#define Ford(i,a,b) for(int i = (a); i >= (b); --i)
#define FOR(i,a,b) for(int i = (a), _b=(b); i<= _b; ++i)
#define FOD(i,a,b) for(int i = (a), _b=(b); i>= _b; --i)
#define REP(i,b) for(int i = 0, _b=(b); i< _b; ++i)
#define eeuler exp(1)
#define pb push_back
#define ll long long
#define ull unsigned long long
#define uint unsigned int
#define Pi acos(-1.0)
#define Epsa 0.0000008
#define Epsb 0.000005
#define eps 1e-9
#define INF 1e15
#define mod 1000000007ll
#define mod2 1000000009ll
#define oo 1000000007
#define ff first
#define ss second
#define mp make_pair
#define ED pair<int,int>
#define EDGE pair<ED,ED>
#define maxn 100111
#define maxe 1000
#define maxv 1000

int main(){
//    freopen("inp.txt","r",stdin);
//    freopen("out.txt","w",stdout);

    int n;
    scanf("%d",&n);
    if(n&1){
        printf("-1");
        return 0;
    }
    int sig=0;
    FOR(i,1,n){
        if(i!=1) printf("\n");
        REP(j,n){
            REP(k,n)
                if((j/2+k/2)%2==sig)
                    printf("b");
                else printf("w");
            printf("\n");
            }
        sig = !sig;
    }
    return 0;
}