Problem: The Easter Rabbit laid n eggs in a circle and is about to paint them. 

Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:

  * Each of the seven colors should be used to paint at least one egg. 
  * Any four eggs lying sequentially should be painted different colors. 



Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.

Input

The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).

Output

Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.

If there are several answers, print any of them.

Examples

Input

8


Output

ROYGRBIV


Input

13


Output

ROYGBIVGBIVYG

Note

The way the eggs will be painted in the first sample is shown on the picture: 

<image>

Solution (in JAVA):

Solution:
import java.io.*;
import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

import static java.lang.Math.sqrt;

public class EasterEggs {

    public void run() throws Exception {
        String[] array = {
                "R", "O", "Y", "G", "B", "I", "V"
        };
        int numberOfEggs = nextInt();
        String result = "ROYGBIV";

        if (numberOfEggs >= 8) {
            String[] resultArray = new String[numberOfEggs];
            fillTheArrayWithBasic(resultArray);
            String constant = "ROYG";
            int counter = 0;
            for (int i = 4; i < numberOfEggs - 3; i++) {
                if (counter > 3)
                    counter = 0;
                resultArray[i] = constant.split("")[counter++];

            }
            String stringValue = String.join("", resultArray);
            System.out.println(stringValue);
        } else {
            System.out.println("ROYGBIV");
        }

    }

    private void fillTheArrayWithBasic(String[] resultArray) {
        resultArray[0] = "R";
        resultArray[1] = "O";
        resultArray[2] = "Y";
        resultArray[3] = "G";

        resultArray[resultArray.length - 1] = "V";
        resultArray[resultArray.length - 2] = "I";
        resultArray[resultArray.length - 3] = "B";

    }

    public static void main(String... args) throws Exception {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedOutputStream(System.out));
        new EasterEggs().run();
        br.close();
        pw.close();
        System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
        long gct = 0, gcc = 0;
        for (GarbageCollectorMXBean garbageCollectorMXBean : ManagementFactory.getGarbageCollectorMXBeans()) {
            gct += garbageCollectorMXBean.getCollectionTime();
            gcc += garbageCollectorMXBean.getCollectionCount();
        }
        System.err.println("[GC time : " + gct + " ms, count = " + gcc + "]");
    }

    static long startTime = System.currentTimeMillis();
    static BufferedReader br;
    static PrintWriter pw;
    StringTokenizer stok;

    String nextToken() throws IOException {
        while (stok == null || !stok.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null) {
                return null;
            }
            stok = new StringTokenizer(s);
        }
        return stok.nextToken();
    }

    void print(byte b) {
        print("" + b);
    }

    void print(int i) {
        print("" + i);
    }

    void print(long l) {
        print("" + l);
    }

    void print(double d) {
        print("" + d);
    }

    void print(char c) {
        print("" + c);
    }

    void print(Object o) {
        if (o instanceof int[]) {
            print(Arrays.toString((int[]) o));
        } else if (o instanceof long[]) {
            print(Arrays.toString((long[]) o));
        } else if (o instanceof char[]) {
            print(Arrays.toString((char[]) o));
        } else if (o instanceof byte[]) {
            print(Arrays.toString((byte[]) o));
        } else if (o instanceof short[]) {
            print(Arrays.toString((short[]) o));
        } else if (o instanceof boolean[]) {
            print(Arrays.toString((boolean[]) o));
        } else if (o instanceof float[]) {
            print(Arrays.toString((float[]) o));
        } else if (o instanceof double[]) {
            print(Arrays.toString((double[]) o));
        } else if (o instanceof Object[]) {
            print(Arrays.toString((Object[]) o));
        } else {
            print("" + o);
        }
    }

    void printsp(int[] a) {
        for (int i = 0, n = a.length; i < n; print(a[i] + " "), i++)
            ;
    }

    void printsp(long[] a) {
        for (int i = 0, n = a.length; i < n; print(a[i] + " "), i++)
            ;
    }

    void print(String s) {
        pw.print(s);
    }

    void println() {
        println("");
    }

    void println(byte b) {
        println("" + b);
    }

    void println(int i) {
        println("" + i);
    }

    void println(long l) {
        println("" + l);
    }

    void println(double d) {
        println("" + d);
    }

    void println(char c) {
        println("" + c);
    }

    void println(Object o) {
        print(o);
        println();
    }

    void println(String s) {
        pw.println(s);
    }

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

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

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

    char nextChar() throws IOException {
        return (char) (br.read());
    }

    String next() throws IOException {
        return nextToken();
    }

    String nextLine() throws IOException {
        return br.readLine();
    }

    int[] readInt(int size) throws IOException {
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = nextInt();
        }
        return array;
    }

    long[] readLong(int size) throws IOException {
        long[] array = new long[size];
        for (int i = 0; i < size; i++) {
            array[i] = nextLong();
        }
        return array;
    }

    double[] readDouble(int size) throws IOException {
        double[] array = new double[size];
        for (int i = 0; i < size; i++) {
            array[i] = nextDouble();
        }
        return array;
    }

    String[] readLines(int size) throws IOException {
        String[] array = new String[size];
        for (int i = 0; i < size; i++) {
            array[i] = nextLine();
        }
        return array;
    }

    int gcd(int a, int b) {
        if (a == 0)
            return Math.abs(b);
        if (b == 0)
            return Math.abs(a);
        a = Math.abs(a);
        b = Math.abs(b);
        int az = Integer.numberOfTrailingZeros(a), bz = Integer.numberOfTrailingZeros(b);
        a >>>= az;
        b >>>= bz;
        while (a != b) {
            if (a > b) {
                a -= b;
                a >>>= Integer.numberOfTrailingZeros(a);
            } else {
                b -= a;
                b >>>= Integer.numberOfTrailingZeros(b);
            }
        }
        return (a << Math.min(az, bz));
    }

    long gcd(long a, long b) {
        if (a == 0)
            return Math.abs(b);
        if (b == 0)
            return Math.abs(a);
        a = Math.abs(a);
        b = Math.abs(b);
        int az = Long.numberOfTrailingZeros(a), bz = Long.numberOfTrailingZeros(b);
        a >>>= az;
        b >>>= bz;
        while (a != b) {
            if (a > b) {
                a -= b;
                a >>>= Long.numberOfTrailingZeros(a);
            } else {
                b -= a;
                b >>>= Long.numberOfTrailingZeros(b);
            }
        }
        return (a << Math.min(az, bz));
    }

    boolean isPrime(int v) {
        if (v <= 1) {
            return false;
        }
        if (v <= 3) {
            return true;
        }
        if (((v & 1) == 0) || ((v % 3) == 0)) {
            return false;
        }
        for (int m = 5, n = (int) sqrt(v); m <= n; m += 6) {
            if (((v % m) == 0) || ((v % (m + 2)) == 0)) {
                return false;
            }
        }
        return true;
    }

    void rshuffle(int[] a) { // RANDOM shuffle
        Random r = new Random();
        for (int i = a.length - 1, j, t; i >= 0; j = r.nextInt(a.length), t = a[i], a[i] = a[j], a[j] = t, i--)
            ;
    }

    void qshuffle(int[] a) { // QUICK shuffle
        int m = new Random().nextInt(10) + 2;
        for (int i = 0, n = a.length, j = m % n, t; i < n; t = a[i], a[i] = a[j], a[j] = t, i++, j = (i * m) % n)
            ;
    }

    void shuffle(long[] a) {
        Random r = new Random();
        for (int i = a.length - 1; i >= 0; i--) {
            int j = r.nextInt(a.length);
            long t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }

    void shuffle(Object[] a) {
        Random r = new Random();
        for (int i = a.length - 1; i >= 0; i--) {
            int j = r.nextInt(a.length);
            Object t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }

    int[] sort(int[] a) {
        final int SHIFT = 16, MASK = (1 << SHIFT) - 1, SIZE = (1 << SHIFT) + 1;
        int n = a.length, ta[] = new int[n], ai[] = new int[SIZE];
        for (int i = 0; i < n; ai[(a[i] & MASK) + 1]++, i++)
            ;
        for (int i = 1; i < SIZE; ai[i] += ai[i - 1], i++)
            ;
        for (int i = 0; i < n; ta[ai[a[i] & MASK]++] = a[i], i++)
            ;
        int[] t = a;
        a = ta;
        ta = t;
        ai = new int[SIZE];
        for (int i = 0; i < n; ai[(a[i] >> SHIFT) + 1]++, i++)
            ;
        for (int i = 1; i < SIZE; ai[i] += ai[i - 1], i++)
            ;
        for (int i = 0; i < n; ta[ai[a[i] >> SHIFT]++] = a[i], i++)
            ;
        return ta;
    }

    void flush() {
        pw.flush();
    }

    void pause() {
        flush();
        System.console().readLine();
    }

}