#include <iostream>
#include <cstdio>
#include <vector>
#include <array>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <sstream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <random>
#include <bitset>
#include <cassert>
#include <tuple>
#include <list>
#include <iterator>
#include <unordered_set>
#include <unordered_map>
#include <numeric>

using namespace std;

typedef long long ll;
typedef long double ld;

template<class htpe, class cmp>
using heap = priority_queue<htpe, vector<htpe>, cmp>;

template<class htpe>
using min_heap = heap<htpe, greater<htpe> >;

template<class htpe>
using max_heap = heap<htpe, less<htpe> >;

#define mp make_pair
#define pb push_back
#define mt make_tuple
#define ff first
#define ss second

#define forn(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define forrn(i, s, n) for (int i = (int)(s); i < ((int)(n)); ++i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()

#define PYMOD(a, m) ((((a) % (m)) + (m)) % (m))

const int INF = 1791791791;
const ll INFLL = 1791791791791791791ll;

template<int input_buf_size, int output_buf_size>
class FastIO {
    char cbuf[input_buf_size + 1];
    int icur = 0;

    inline bool go_to_next_token() {
        while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
        while (cbuf[icur] == 0) {
            icur = 0;
            if (fgets(cbuf, sizeof(cbuf), stdin) != cbuf)
                return false;
            while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
        }
        return true;
    }
  public:
    string readString() {
        assert(go_to_next_token());
        string ans;
        while (cbuf[icur] != ' ' && cbuf[icur] != '\n' && cbuf[icur] != 0)
            ans.push_back(cbuf[icur++]);
        ans.shrink_to_fit();
        return ans;
    }

    template<class int_type>
    int_type readInt() {
        assert(go_to_next_token());
        int_type x = 0;
        bool m = cbuf[icur] == '-';
        if (m) icur++;
        while ('0' <= cbuf[icur] && cbuf[icur] <= '9') {
            x *= 10;
            x += (cbuf[icur] - '0');
            icur++;
        }
        if (m) x = -x;
        return x;
    }

    bool seekEof() {
        return !go_to_next_token();
    }

  private:
    char obuf[output_buf_size + 1];
    int ocur = 0;

    inline void write_string(const char *str, size_t sz = 0) {
        if (sz == 0)
            sz = strlen(str);
        if (ocur + sz > output_buf_size) {
            fputs(obuf, stdout);
            fputs(str, stdout);
            ocur = 0;
            obuf[0] = 0;
            return;
        }
        strcpy(obuf + ocur, str);
        ocur += sz;
        obuf[ocur] = 0;
   }

  public:
    template<class int_type>
    void writeInt(int_type x, bool sp = true) {
        char buf[21];
        int c = 0;
        if (x < 0) {
            buf[c++] = '-';
            x = -x;
        }
        int s = c;
        if (x == 0) {
            buf[c++] = '0';
        }
        while (x > 0) {
            buf[c++] = (x % 10) + '0';
            x /= 10;
        }
        for (int i = 0; 2 * i < c - s; i++) {
            swap(buf[s + i], buf[c - 1 - i]);
        }
        buf[c] = 0;
        write_string(buf, c);
        if (sp)
            write_string(" ", 1);
    }

    void writeString(string s, bool space = true) {
        write_string(s.c_str(), s.size());
        if (space)
            write_string(" ", 1);
    }

    void writeEndl() {
        write_string("\n", 1);
#ifdef LOCAL
        if (lflush)
            flush();
#endif
 
    }

    void flush() {
        fputs(obuf, stdout);
        ocur = 0;
        obuf[0] = 0;
    }

private:
    bool lflush;

public:

    FastIO(bool local_flush) { 
        obuf[0] = 0;
        lflush = local_flush;
    }
    
    ~FastIO() {
        fputs(obuf, stdout);
    }
};

FastIO<10000000, 10000000> IO(true);

const int maxw = 3000;
string construction[maxw];

void write_one_subiter(int i, int j, char c, int d) {
    assert(d % 2 == 0);
    forn(k, d / 2) {
        forn(t, d - 2 * k) {
            assert(construction[i + k][j + k + t] == ' ');
            construction[i + k][j + k + t] = c;
            if (k != 0)
                assert(construction[i - k][j + k + t] == ' ');
            construction[i - k][j + k + t] = c;
        }
    }
}

void write_one_iter(int i, int j, int d) {
    assert(d % 2 == 0);
    write_one_subiter(i, j, 'R', d);
    write_one_subiter(i, j + d, 'B', d);
    write_one_subiter(i + d / 2, j + d / 2, 'G', d);
    write_one_subiter(i - d / 2, j + d / 2, 'Y', d);
}

char use[2][3] = {{'B', 'R', 'G'}, {'G', 'Y', 'B'} };

void write_square_of_type(int x, int y, int d, int t) {
    assert(d % 2 == 1);
    forn(i, d / 2) {
        forn(j, d / 2 - i) {
            construction[x + i][y + j] = use[t][0];
            construction[x + d - 1 - i][y + d - 1 - j] = use[t][0];
            construction[x + i][y + d - 1 - j] = use[t][2];
            construction[x + d - 1 - i][y + j] = use[t][2];
        }
        forrn(j, d / 2 - i, d / 2 + i + 1) {
            construction[x + i][y + j] = use[t][1];
            construction[x + d - 1 - i][y + j] = use[t][1];
        }
    }
    forn(j, d) {
        construction[x + d / 2][y + j] = use[t][1];
    }
}

void solve_d(int d) {
    forn(i, maxw)
        construction[i].resize(maxw, ' ');
    if (d % 2 == 0) {
        for (int x = d - 1; x + d - 1 < maxw; x += 2 * d) {
            for (int y = 0; y + 2 * d - 1 < maxw; y += 2 * d) {
                write_one_iter(x, y, d);
            }
        }
        for (int x = 2 * d - 1; x + d - 1 < maxw; x += 2 * d) {
            for (int y = d; y + 2 * d - 1 < maxw; y += 2 * d) {
                write_one_iter(x, y, d);
            }
        }
    } else {
        for (int x = 0; x + d - 1 < maxw; x += d) {
            for (int y = 0; y + d - 1 < maxw; y += d) {
                write_square_of_type(x, y, d, ((x/d) + (y/d)) % 2);
            }
        }
    }
}


int main() {
    // Code here:
   
    int h, w, d;
    h = IO.readInt<int>();
    w = IO.readInt<int>();
    d = IO.readInt<int>();

    solve_d(d);

    forn(i, h) {
        IO.writeString(construction[i + d + 1].substr(d + 1, w), 0);
        IO.writeEndl();
    }

    return 0;
}



Measured memory_bytes: 11264