Problem: Autumn came late to the kingdom of Far Far Away. The harvest was exuberant and it is now time to get ready for the winter. As most people celebrate the Harvest festival, Simon the Caretaker tries to solve a very non-trivial task of how to find place for the agricultural equipment in the warehouse.

He's got problems with some particularly large piece of equipment, which is, of course, turboplows. The problem is that when a turboplow is stored, it takes up not some simply rectangular space. It takes up a T-shaped space like on one of the four pictures below (here character "#" stands for the space occupied by the turboplow and character "." stands for the free space):
    
    
    ###      ..#      .#.      #..  
    .#.      ###      .#.      ###  
    .#.      ..#      ###      #..  
    

Simon faced a quite natural challenge: placing in the given n × m cells warehouse the maximum number of turboplows. As one stores the turboplows, he can rotate them in any manner (so that they take up the space like on one of the four pictures above). However, two turboplows cannot "overlap", that is, they cannot share the same cell in the warehouse.

Simon feels that he alone cannot find the optimal way of positioning the plugs in the warehouse that would maximize their quantity. Can you help him?

Input

The only line contains two space-separated integers n and m — the sizes of the warehouse (1 ≤ n, m ≤ 9).

Output

In the first line print the maximum number of turboplows that can be positioned in the warehouse. In each of the next n lines print m characters. Use "." (dot) to mark empty space and use successive capital Latin letters ("A" for the first turboplow, "B" for the second one and so on until you reach the number of turboplows in your scheme) to mark place for the corresponding turboplows considering that they are positioned in the optimal manner in the warehouse. The order in which you number places for the turboplows does not matter. If there are several optimal solutions for a warehouse of the given size, print any of them.

Examples

Input

3 3


Output

1
AAA
.A.
.A.


Input

5 6


Output

4
A..C..
AAAC..
ABCCCD
.B.DDD
BBB..D


Input

2 2


Output

0
..
..

Solution (in JAVA):

Solution:
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class studyDemo
{
    /********************************************** a list of common variables **********************************************/
    private MyScanner scan = new MyScanner();
    private PrintWriter out = new PrintWriter(System.out);
    private final double PI = Math.PI;
    private final int INF = (int)(1e9);
    private final double EPS = 1e-6;
    private final int SIZEN = (int)(1e7);
    private final int MOD = (int)(1e9 + 7);
    private final long MODH = 10000000007L, BASE = 10007;
    private final int[] DX = {0, 1, 0, -1}, DY = {-1, 0, 1, 0};
    private final int[][] dx = {{0, 1, 1, 1, 2}, {0, 1, 2, 2, 2}, {0, 1, 1, 1, 2}, {0, 0, 1, 2, 0}};
    private final int[][] dy = {{0, 0, 1, 2, 0}, {1, 1, 1, 0, 2}, {2, 2, 1, 0, 2}, {0, 1, 1, 1, 2}};
    private int n, m, ans;
    private char[][] map, ret;

    public boolean isLegal(int x, int y)
    {
        return x >= 0 && x < n && y >= 0 && y < m;
    }

    public void dfs(int x, int y, int cnt)
    {
        if(cnt + (n * m - x * m - y) / 6 <= ans) return;
        if(x + 2 == n)
        {
            if(cnt > ans)
            {
                ans = cnt;
                for(int i = 0;i < n;++i) System.arraycopy(map[i], 0, ret[i], 0, m);
            }
            return;
        }
        if(y + 2 == m) dfs(x + 1, 0, cnt);
        for(int k = 0;k < 4;++k)
        {
            boolean canPlace = true;
            for(int i = 0;i < 5;++i)
            {
                if(!isLegal(x + dx[k][i], y + dy[k][i]) || map[x + dx[k][i]][y + dy[k][i]] != '.')
                {
                    canPlace = false;
                    break;
                }
            }
            if(!canPlace) continue;
            for(int i = 0;i < 5;++i) map[x + dx[k][i]][y + dy[k][i]] = (char)('A' + cnt);
            dfs(x, y + 1, cnt + 1);
            for(int i = 0;i < 5;++i) map[x + dx[k][i]][y + dy[k][i]] = '.';
        }
        dfs(x, y + 1, cnt);
    }

    public void foo ()
    {
        n = scan.nextInt();
        m = scan.nextInt();
        map = new char[n][m];
        for(int i = 0;i < n;++i) Arrays.fill(map[i], '.');
        if(n < 3 || m < 3)
        {
            out.println(0);
            for(int i = 0;i < n;++i) out.println(map[i]);
            return;
        }
        ans = 0;
        ret = new char[n][m];
        dfs(0, 0, 0);
        out.println(ans);
        for(int i = 0;i < n;++i) out.println(ret[i]);
    }

    public static void main(String[] args)
    {
        studyDemo m = new studyDemo();
        m.foo();
        m.out.close();
    }

    /********************************************** a list of common algorithms **********************************************/
    /**
     * 1---Get greatest common divisor
     * @param a :	first number
     * @param b :	second number
     * @return		greatest common divisor
     */
    public long gcd(long a, long b)
    {
        return 0 == b ? a : gcd(b, a % b);
    }

    /**
     * 2---Get the distance from a point to a line
     * @param x1	the x coordinate of one endpoint of the line
     * @param y1	the y coordinate of one endpoint of the line
     * @param x2	the x coordinate of the other endpoint of the line
     * @param y2	the y coordinate of the other endpoint of the line
     * @param x		the x coordinate of the point
     * @param y		the x coordinate of the point
     * @return		the distance from a point to a line
     */
    public double getDist(long x1, long y1, long x2, long y2, long x, long y)
    {
        long a = y2 - y1;
        long b = x1 - x2;
        long c = y1 * (x2 - x1) - x1 * (y2 - y1);
        return Math.abs(a * x + b * y + c) / Math.sqrt(a * a + b * b);
    }

    /**
     * 3---Get the distance from one point to a segment (not a line)
     * @param x1	the x coordinate of one endpoint of the segment
     * @param y1	the y coordinate of one endpoint of the segment
     * @param x2	the x coordinate of the other endpoint of the segment
     * @param y2	the y coordinate of the other endpoint of the segment
     * @param x		the x coordinate of the point
     * @param y		the y coordinate of the point
     * @return		the distance from one point to a segment (not a line)
     */
    public double ptToSeg(long x1, long y1, long x2, long y2, long x, long y)
    {
        double cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
        if(cross <= 0)
        {
            return (x - x1) * (x - x1) + (y - y1) * (y - y1);
        }
        double d = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
        if(cross >= d)
        {
            return (x - x2) * (x - x2) + (y - y2) * (y - y2);
        }
        double r = cross / d;
        double px = x1 + (x2 - x1) * r;
        double py = y1 + (y2 - y1) * r;
        return (x - px) * (x - px) + (y - py) * (y - py);
    }

    /**
     * 4---KMP match, i.e. kmpMatch("abcd", "bcd") = 1, kmpMatch("abcd", "bfcd") = -1.
     * @param t:	String to match.
     * @param p:	String to be matched.
     * @return		if can match, first index; otherwise -1.
     */
    public int kmpMatch(char[] t, char[] p)
    {
        int n = t.length;
        int m = p.length;
        int[] next = new int[m + 1];
        next[0] = -1;
        int j = -1;
        for(int i = 1;i < m;++i)
        {
            while(j >= 0 && p[i] != p[j + 1])
            {
                j = next[j];
            }
            if(p[i] == p[j + 1])
            {
                ++j;
            }
            next[i] = j;
        }
        j = -1;
        for(int i = 0;i < n;++i)
        {
            while(j >= 0 && t[i] != p[j + 1])
            {
                j = next[j];
            }
            if(t[i] == p[j + 1])
            {
                ++j;
            }
            if(j == m - 1)
            {
                return i - m + 1;
            }
        }
        return -1;
    }

    /**
     * 5---Get the hash code of a String
     * @param	s:	input string
     * @return	hash code
     */
    public long hash(String s)
    {
        long key = 0, t = 1;
        for(int i = 0;i < s.length();++i)
        {
            key = (key + s.charAt(i) * t) % MODH;
            t = t * BASE % MODH;
        }
        return key;
    }

    /**
     * 6---Get x ^ n % MOD quickly.
     * @param	x:	base
     * @param 	n:	times
     * @return	x ^ n % MOD
     */
    public long quickMod(long x, long n)
    {
        long ans = 1;
        while(n > 0)
        {
            if(1 == n % 2)
            {
                ans = ans * x % MOD;
            }
            x = x * x % MOD;
            n >>= 1;
        }
        return ans;
    }

    /**
     * 7---judge if a point is located inside a polygon
     * @param x0	the x coordinate of the point
     * @param y0	the y coordinate of the point
     * @return true if it is inside the polygon, otherwise false
     */
	/*public boolean contains(double x0, double y0)
	{
		int cross = 0;
		for(int i = 0;i < n;++i)
		{
			double s = x[i + 1] == x[i] ? 100000000 : (double)(y[i + 1] - y[i]) / (x[i + 1] - x[i]);
			boolean b1 = x[i] <= x0 && x0 < x[i + 1];
			boolean b2 = x[i + 1] <= x0 && x0 < x[i];
			boolean b3 = y0 < s * (x0 - x[i]) + y[i];
			if((b1 || b2) && b3) ++cross;
		}
		return cross % 2 != 0;
	}*/

    /**
     * 8---judge if a point is located on the segment
     * @param	x1	the x coordinate of one point of the segment
     * @param	y1	the y coordinate of one point of the segment
     * @param 	x2	the x coordinate of another point of the segment
     * @param 	y2	the y coordinate of another point of the segment
     * @param	x	the x coordinate of the point
     * @param 	y	the y coordinate of the point
     * @return	true if it is located on the segment, otherwise false
     */
    public boolean isOnSeg(long x1, long y1, long x2, long y2, long x, long y)
    {
        return (x - x1) * (y2 - y1) == (x2 - x1) * (y - y1) &&
                x >= Math.min(x1, x2) && x <= Math.max(x1, x2) &&
                y >= Math.min(y1, y2) && y <= Math.max(y1, y2);
    }

    /**
     * 9---get the cross product
     * @param 	p1	point A
     * @param 	p2	point B
     * @param 	p	point O
     * @return	cross product of OA x OB
     */
	/*public long cross(Point p1, Point p2, Point p)
	{
		return (long)(p1.x - p.x) * (p2.y - p.y) - (long)(p2.x - p.x) * (p1.y - p.y);
	}*/

    /**
     * 10---implement topsort and tell if it is possible
     * @return true if it is possible to implement topsort, otherwise false
     */
	/*public boolean topsort()
	{
		Queue<Integer> q = new LinkedList<Integer>();
		StringBuilder ans = new StringBuilder();
		int[] in = new int[26];
		for(int i = 0;i < 26;++i)
		{
			if(0 == in[i]) 
			{
				ans.append((char)('a' + i));
				q.add(i);
			}
		}
		while(!q.isEmpty())
		{
			int u = q.poll();
			for(int i = 0;i < 26;++i)
			{
				if(map[u][i])
				{
					--in[i];
					if(0 == in[i])
					{
						ans.append((char)('a' + i));
						q.add(i);
					}
				}
			}
		}
		return 26 == ans.length();
	}*/

    class MyScanner
    {
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        BufferedInputStream bis = new BufferedInputStream(System.in);

        public int read()
        {
            if (-1 == numChars)
            {
                throw new InputMismatchException();
            }
            if (curChar >= numChars)
            {
                curChar = 0;
                try
                {
                    numChars = bis.read(buf);
                }
                catch (IOException e)
                {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do
            {
                if (c < '0' || c > '9')
                {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do
            {
                if (c < '0' || c > '9')
                {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9')
                {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c & 15;
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                    {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9')
                    {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c & 15) * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String next()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        private boolean isSpaceChar(int c)
        {
            return ' ' == c || '\n' == c || '\r' == c || '\t' == c || -1 == c;
        }
    }
}