Problem:
Score : 700 points

Problem Statement

We have a grid with H rows and W columns of squares.
We will represent the square at the i-th row from the top and j-th column from the left as (i,\ j).
Also, we will define the distance between the squares (i_1,\ j_1) and (i_2,\ j_2) as |i_1 - i_2| + |j_1 - j_2|.

Snuke is painting each square in red, yellow, green or blue.
Here, for a given positive integer d, he wants to satisfy the following condition:

No two squares with distance exactly d have the same color.

Find a way to paint the squares satisfying the condition.
It can be shown that a solution always exists.

Constraints

2 ≤ H, W ≤ 500

1 ≤ d ≤ H + W - 2

Input

Input is given from Standard Input in the following format:

H W d

Output

Print a way to paint the squares satisfying the condition, in the following format. If the square (i,\ j) is painted in red, yellow, green or blue, c_{ij} should be R, Y, G or B, respectively.

c_{11}c_{12}...c_{1W}
:
c_{H1}c_{H2}...c_{HW}

Sample Input 1

2 2 1

Sample Output 1

RY
GR

There are four pairs of squares with distance exactly 1.
As shown below, no two such squares have the same color.

(1,\ 1), (1,\ 2) : R, Y

(1,\ 2), (2,\ 2) : Y, R

(2,\ 2), (2,\ 1) : R, G

(2,\ 1), (1,\ 1) : G, R

Sample Input 2

2 3 2

Sample Output 2

RYB
RGB

There are six pairs of squares with distance exactly 2.
As shown below, no two such squares have the same color.

(1,\ 1) , (1,\ 3) : R , B

(1,\ 3) , (2,\ 2) : B , G

(2,\ 2) , (1,\ 1) : G , R

(2,\ 1) , (2,\ 3) : R , B

(2,\ 3) , (1,\ 2) : B , Y

(1,\ 2) , (2,\ 1) : Y , R

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
 
class Main
{
	static class Pair implements Comparable
	{
		int first;
		double second;
		
		public Pair(int f, double s)
		{
			first = f;
			second = s;
		}
		
		public String toString()
		{
			return first + " " + second;
		}
		
		public int compareTo(Object o)
		{
			Pair p2 = (Pair)o;
			if(this.first < p2.first)
				return -1;
			if(this.first > p2.first)
				return 1;
			if(this.second < p2.second)
				return -1;
			if(this.second > p2.second)
				return 1;
			return 0;
		}
	}
	
	static int log2(double a)
	{
		return (int)(Math.log(a) / Math.log(2));
	}
	
	static long gcd(long a, long b)
	{
		long r;
		while((r = a % b) > 0)
		{
			a = b;
			b = r;
		}
		return b;
	}
	
	static int distance(int i1, int j1, int i2, int j2)
	{
		return Math.abs(i1 - i2) + Math.abs(j1 - j2);
	}
	
	public static void main(String[] args) throws IOException
	{
		int h = in.nextInt();
		int w = in.nextInt();
		int d = in.nextInt();
		int[][] ans = new int[h][w];
		for(int i = 0; i < h; i ++)
			Arrays.fill(ans[i], -1);
		for(int i = 0; i < h; i ++)
		{
			for(int j = 0; j < w; j ++)
			{
				boolean[] not = new boolean[4];
				int x = j + d;
				int y = i;
				for(; y <= i + d; x --, y ++)
				{
					if(x >= w)
						continue;
					if(y >= h)
						continue;
					if(ans[y][x] != -1)
					{
						not[ans[y][x]] = true;
					}
				}
				x = j + d;
				y = i;
				for(; y >= i - d; x --, y --)
				{
					if(x >= w)
						continue;
					if(y < 0)
						continue;
					if(ans[y][x] != -1)
					{
						not[ans[y][x]] = true;
					}
				}
				x = j - d;
				y = i;
				for(; y <= i + d; x ++, y ++)
				{
					if(x < 0)
						continue;
					if(y >= h)
						continue;
					if(ans[y][x] != -1)
					{
						not[ans[y][x]] = true;
					}
				}
				x = j - d;
				y = i;
				for(; y >= i - d; x ++, y --)
				{
					if(x < 0)
						continue;
					if(y < 0)
						continue;
					if(ans[y][x] != -1)
					{
						not[ans[y][x]] = true;
					}
				}
				for(int z = 0; z < 4; z ++)
				{
					if(!not[z])
					{
						ans[i][j] = z;
						break;
					}
				}
			}
		}
		char[] c = {'R', 'Y', 'G', 'B'};
		for(int i = 0; i < h; i ++)
		{
			for(int j = 0; j < w; j ++)
			{
				sop(c[ans[i][j] != -1 ? ans[i][j] : 0]);
			}
			sop("\n");
		}
	}
    
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
	
    static FastReader in = new FastReader();
  
    public static void sop(Object o)
    {
    	System.out.print(o);
    }
}