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:
//package codechef;
import java.io.*;
import java.math.*;
import java.util.*;
/**
 *
 * @author Pradyumn Agrawal coderbond007
 */
public class Codechef{ 
	public static InputStream inputStream = System.in;
	public static OutputStream outputStream = System.out;
	public static FastReader in = new FastReader(inputStream);
	public static PrintWriter out = new PrintWriter(outputStream);
	public static void main(String[] args)throws java.lang.Exception
	{
		new Codechef().run();
		out.close();
	}

	void run() throws java.lang.Exception 
	{
		int n = ni();
		String s = "ROYGBIV";
		char[] str = new char[n];
		for(int i=0;i<n;i++){
			if(i<7){
				str[i] = s.charAt(i%7);
				out.print(s.charAt(i%7));
			}else{
				str[i] = str[i-4];
				out.print(str[i]);
			}
		}
	}
	
    private static int ni(){
		return in.nextInt();
	}
	private static long nl(){
		return in.nextLong();
	}
	private static String ns(){
		return in.nextString();
	}
	private static char nc(){
		return in.nextCharacter();
	}
	private static double nd(){
		return in.nextDouble();
	}
	
	private static char[] ns(int n)
	{
		char[] a = new char[n];
		for(int i=0;i<n;i++) a[i] = nc();
		return a;
	}
	
	private static 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 static int[] na(int n)
	{
		int[] a = new int[n];
		for(int i=0;i<n;i++) a[i] = ni();
		return a;
	}
	
	private static long[] nal(int n)
	{
		long[] a = new long[n];
		for(int i=0;i<n;i++) a[i] = nl();
		return a;
	}
}

class FastReader{
	private boolean finished = false;
 
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;
 
	public FastReader(InputStream stream){
		this.stream = stream;
	}
 
	public int read(){
		if (numChars == -1){
			throw new InputMismatchException ();
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				throw new InputMismatchException ();
			}
			if (numChars <= 0){
				return -1;
			}
		}
		return buf[curChar++];
	}
 
	public int peek(){
		if (numChars == -1){
			return -1;
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				return -1;
			}
			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==','){
				c = read();
			}
			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 String nextString(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		StringBuilder res = new StringBuilder ();
		do{
			res.appendCodePoint (c);
			c = read ();
		} while (!isSpaceChar (c));
		return res.toString ();
	}
 
	public boolean isSpaceChar(int c){
		if (filter != null){
			return filter.isSpaceChar (c);
		}
		return isWhitespace (c);
	}
 
	public static boolean isWhitespace(int c){
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private String readLine0(){
		StringBuilder buf = new StringBuilder ();
		int c = read ();
		while (c != '\n' && c != -1){
			if (c != '\r'){
				buf.appendCodePoint (c);
			}
			c = read ();
		}
		return buf.toString ();
	}

	public String nextLine(){
		String s = readLine0 ();
		while (s.trim ().length () == 0)
			s = readLine0 ();
		return s;
	}
 
	public String nextLine(boolean ignoreEmptyLines){
		if (ignoreEmptyLines){
			return nextLine ();
		}else{
			return readLine0 ();
		}
	}
 
	public BigInteger nextBigInteger(){
		try{
			return new BigInteger (nextString());
		} catch (NumberFormatException e){
			throw new InputMismatchException ();
		}
	}
 
	public char nextCharacter(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		return (char) c;
	}
	
	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 - '0';
			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 - '0') * m;
				c = read ();
			}
		}
		return res * sgn;
	}
 
	public boolean isExhausted(){
		int value;
		while (isSpaceChar (value = peek ()) && value != -1)
			read ();
		return value == -1;
	}
 
	public String next(){
		return nextString();
	}
 
	public SpaceCharFilter getFilter(){
		return filter;
	}
 
	public void setFilter(SpaceCharFilter filter){
		this.filter = filter;
	}
 
	public interface SpaceCharFilter{
		public boolean isSpaceChar(int ch);
	}
}