Eleven wants to choose a new name for herself. As a bunch of geeks, her friends suggested an algorithm to choose a name for her. Eleven wants her name to have exactly n characters. 

<image>

Her friend suggested that her name should only consist of uppercase and lowercase letters 'O'. More precisely, they suggested that the i-th letter of her name should be 'O' (uppercase) if i is a member of Fibonacci sequence, and 'o' (lowercase) otherwise. The letters in the name are numbered from 1 to n. Fibonacci sequence is the sequence f where

  * f1 = 1, 
  * f2 = 1, 
  * fn = fn - 2 + fn - 1 (n > 2). 



As her friends are too young to know what Fibonacci sequence is, they asked you to help Eleven determine her new name.

Input

The first and only line of input contains an integer n (1 ≤ n ≤ 1000).

Output

Print Eleven's new name on the first and only line of output.

Examples

Input

8


Output

OOOoOooO


Input

15


Output

OOOoOooOooooOoo
import java.util.*;
import java.awt.RenderingHints.Key;
import java.io.*;
			import java.lang.*;
			
			public class codeforces
			{
				public static void main(String[] args)
				{
					InputReader in = new InputReader(System.in);
					PrintWriter pw = new PrintWriter(System.out);
					
					//Code starts..
				
					
					long n = in.nextLong();
					boolean[] ans = new boolean[1006];
					ans[1] = true;
					ans[2] = true;
					int a = 1; 
					int b = 1;
					for(int i=3; a+b<=n; i++)
					{
						if(a+b<=10006)
							ans[a+b] = true;
						int tmp = b;
						b = a+b;
						a = tmp;
						
					}
					
					for(int i=1; i<=n; i++)
						if(ans[i])
							pw.print("O");
						else
							pw.print("o");
					
					
					pw.flush();
					pw.close();
				}
				
				static class InputReader 
				{
					 
					private final InputStream stream;
					private final byte[] buf = new byte[8192];
					private int curChar, snumChars;
					private SpaceCharFilter filter;
			 
					public InputReader(InputStream stream) 
					{
						this.stream = stream;
					}
			 
					public int snext() 
					{
						if (snumChars == -1)
							throw new InputMismatchException();
						if (curChar >= snumChars) 
						{
							curChar = 0;
							try 
							{
								snumChars = stream.read(buf);
							} 
							catch (IOException e) 
							{
								throw new InputMismatchException();
							}
							if (snumChars <= 0)
								return -1;
						}
						return buf[curChar++];
					}
			 
					public int nextInt() 
				    {
						int c = snext();
						while (isSpaceChar(c)) 
						{
							c = snext();
						}
						int sgn = 1;
						if (c == '-')
					    {
							sgn = -1;
							c = snext();
						}
						int res = 0;
						do 
						{
							if (c < '0' || c > '9')
								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
							c = snext();
						} while (!isSpaceChar(c));
						return res * sgn;
					}
			 
					public long nextLong()
				    {
						int c = snext();
						while (isSpaceChar(c)) 
						{
							c = snext();
						}
						int sgn = 1;
						if (c == '-') 
						{
							sgn = -1;
							c = snext();
						}
						long res = 0;
						do 
						{
							if (c < '0' || c > '9')
								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
							c = snext();
						} while (!isSpaceChar(c));
						return res * sgn;
					}
			 
					public int[] nextIntArray(int n) 
					{
						int a[] = new int[n];
						for (int i = 0; i < n; i++) 
						{
							a[i] = nextInt();
						}
						return a;
					}
			 
					public String readString()
				    {
						int c = snext();
						while (isSpaceChar(c)) 
						{
							c = snext();
						}
						StringBuilder res = new StringBuilder();
						do 
						{
							res.appendCodePoint(c);
							c = snext();
						} while (!isSpaceChar(c));
						return res.toString();
					}
			 
					public String nextLine() 
					{
						int c = snext();
						while (isSpaceChar(c))
							c = snext();
						StringBuilder res = new StringBuilder();
						do 
						{
							res.appendCodePoint(c);
							c = snext();
						} while (!isEndOfLine(c));
						return res.toString();
					}
			 
					public boolean isSpaceChar(int c) 
					{
						if (filter != null)
							return filter.isSpaceChar(c);
						return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
					}
			 
					private boolean isEndOfLine(int c) 
					{
						return c == '\n' || c == '\r' || c == -1;
					}
			 
					public interface SpaceCharFilter
				    {
						public boolean isSpaceChar(int ch);
					}
				}
				public static long c = 0;
				
				public static long mod = 1000000007;
				public static int d;
				public static int p;
				public static int q;
				
				
				
						
				public static  int gcd(int p2, int p22)
				{
				    if (p2 == 0)
				        return (int) p22;
				    return gcd(p22%p2, p2);
				}
				
					
				
				public static int findGCD(int arr[], int n)
				{
				    int result = arr[0];
				    for (int i=1; i<n; i++)
				        result = gcd(arr[i], result);
				 
				    return result;
				}
				
				
				
				
			
			    public static long lcm(int[] numbers) {
			        long lcm = 1;
			        int divisor = 2;
			        while (true) {
			            int cnt = 0;
			            boolean divisible = false;
			            for (int i = 0; i < numbers.length; i++) {
			                if (numbers[i] == 0) {
			                    return 0;
			                } else if (numbers[i] < 0) {
			                    numbers[i] = numbers[i] * (-1);
			                }
			                if (numbers[i] == 1) {
			                    cnt++;
			                }
			                if (numbers[i] % divisor == 0) {
			                    divisible = true;
			                    numbers[i] = numbers[i] / divisor;
			                }
			            }
			            if (divisible) {
			                lcm = lcm * divisor;
			            } else {
			                divisor++;
			            }
			            if (cnt == numbers.length) {
			                return lcm;
			            }
			        }
			    }
				public static long fact(long n) {
					
					long factorial = 1;
					 for(int i = 1; i <= n; i++)
				        {
				            factorial *= i;
				        }
					 return factorial;
				}
				
				
				
				public static int lowerLimit(int[] a, int n) {
					int ans = 0;
					
					int ll = 0;
					int rl = a.length-1;
				//	System.out.println(a[rl]+" "+n);
					if(a[0]>n)
						return 0;
					if(a[0]==n)
						return 1;
					else if(a[rl]<=n)
						return rl+1;
				
					while(ll<=rl)
					{
						
						int mid = (ll+rl)/2;
						if(a[mid]==n)
						{
							ans = mid + 1;
							break;
						}
						
						else if(a[mid]>n)
						{
							rl = mid-1;
							
						}
						else
						{
							ans = mid+1;
							ll = mid+1;
						}
					}
					
					return ans; 
				}
				
				
				public static long choose(long total, long choose){
				    if(total < choose)
				        return 0;
				    if(choose == 0 || choose == total)
				        return 1;
				    return (choose(total-1,choose-1)+choose(total-1,choose))%mod;
				}
				
				public static int[] suffle(int[] a,Random gen)
				{
					int n = a.length;
					for(int i=0;i<n;i++)
					{
						int ind = gen.nextInt(n-i)+i;
						int temp = a[ind];
						a[ind] = a[i];
						a[i] = temp;
					}
					return a;
				}
				
				public static int floorSearch(int arr[], int low, int high, int x)
				{
				    if (low > high)
				        return -1;
				 
				    if (x > arr[high])
				        return high;
				    int mid = (low+high)/2;
				 
				 
				    if (mid > 0 && arr[mid-1] < x && x < arr[mid])
				        return mid-1;
				 
				    if (x < arr[mid])
				        return floorSearch(arr, low, mid-1, x);
				 
				    return floorSearch(arr, mid+1, high, x);
				}
				
				
				public static void swap(int a, int b){
					int temp = a;
					a = b;
					b = temp;
				}
				
				
				
				public static long power(long x, long y)
				{
				    long temp;
				    if( y == 0)
				       return 1;
				    temp = power(x, y/2)%mod;       
				    if (y%2 == 0)
				        return (temp*temp)%mod;
				    else
				    {
				        if(y > 0)
				            return ((x*temp)%mod*(temp)%mod)%mod;
				        else
				            return ((temp*temp)%mod/x)%mod;
				    }
				}  
				
				public static ArrayList<Integer> primeFactorization(int n)
				{
					ArrayList<Integer> a =new ArrayList<Integer>();
					for(int i=2;i*i<=n;i++)
					{
						while(n%i==0)
						{
							a.add(i);
							n/=i;
						}
					}
					if(n!=1)
						a.add(n);
					return a;
				}
				
				public static void sieve(boolean[] isPrime,int n)
				{
					for(int i=1;i<n;i++)
						isPrime[i] = true;
					
					isPrime[0] = false;
					isPrime[1] = false;
					
					for(int i=2;i*i<n;i++)
					{
						if(isPrime[i] == true)
						{
							for(int j=(2*i);j<n;j+=i)
								isPrime[j] = false;
						}
					}
				}
				
				public static int GCD(int a,int b)
				{
					if(b==0)
						return a;
					else
						return GCD(b,a%b);
				}
				
				public static long GCD(long a,long b)
				{
					if(b==0)
						return a;
					else
						return GCD(b,a%b);
				}
				
				public static void extendedEuclid(int A,int B)
				{
					if(B==0)
					{
						d = A;
						p = 1 ;
						q = 0;
					}
					else
					{
						extendedEuclid(B, A%B);
						int temp = p;
						p = q;
						q = temp - (A/B)*q;
					}
				}
				
				public static long LCM(long a,long b)
				{
					return (a*b)/GCD(a,b);
				}
				
				public static int LCM(int a,int b)
				{
					return (a*b)/GCD(a,b);
				}
				
				public static int binaryExponentiation(int x,int n)
				{
				    int result=1;
				    while(n>0)
				    {
				        if(n % 2 ==1)
				            result=result * x;
				        x=x*x;
				        n=n/2;
				    }
				    return result;
				}
				
				public static long binaryExponentiation(long x,long n)
				{
				    long result=1;
				    while(n>0)
				    {
				        if(n % 2 ==1)
				            result=result * x;
				        x=(x%mod * x%mod)%mod;
				        n=n/2;
				    }
				    return result;
				}
				
				public static int modularExponentiation(int x,int n,int M)
				{
				    int result=1;
				    while(n>0)
				    {
				        if(n % 2 ==1)
				            result=(result * x)%M;
				        x=(x*x)%M;
				        n=n/2;
				    }
				    return result;
				}
				
				public static long modularExponentiation(long x,long n,long M)
				{
				    long result=1;
				    while(n>0)
				    {
				        if(n % 2 ==1)
				            result=(result * x)%M;
				        x=(x*x)%M;
				        n=n/2;
				    }
				    return result;
				}
				
				public static int modInverse(int A,int M)
				{
				    return modularExponentiation(A,M-2,M);
				}
				
				public static long modInverse(long A,long M)
				{
				    return modularExponentiation(A,M-2,M);
				}
				
				public static boolean isPrime(int n)
				{
				    
				    if (n <= 1)  return false;
				    if (n <= 3)  return true;
				    
				    if (n%2 == 0 || n%3 == 0) 
				    	return false;
				 
				    for (int i=5; i*i<=n; i=i+6)
				    {
				        if (n%i == 0 || n%(i+2) == 0)
				           return false;
				    }
				    
				    return true;
				}
				
				static class pair implements Comparable<pair>
		
				{
					Integer x, y;
					pair(int x,int y)
					{
						this.x=x;
						this.y=y;
					}
					
					public int compareTo(pair o) {
						int result = x.compareTo(o.x);
						if(result==0)
							result = y.compareTo(o.y);
						
						return result;
					}  
					
					public String toString()
					{
						return x+" "+y;
					}
					
					public boolean equals(Object o)
					{
						if (o instanceof pair)
					    {
							pair p = (pair)o;
							return p.x == x && p.y == y ;
						}
						return false;
					}
					
					public int hashCode()
					{
						return new Long(x).hashCode()*31 + new Long(y).hashCode();
					}
				}
			
		
				static class pairLong implements Comparable<pairLong>
				
				{
					Long x, y;
					pairLong(long x,long y)
					{
						this.x=x;
						this.y=y;
					}
					
					public int compareTo(pairLong o) {
						int result = x.compareTo(o.x);
						if(result==0)
							result = y.compareTo(o.y);
						
						return result;
					}  
					
					public String toString()
					{
						return x+" "+y;
					}
					
					public boolean equals(Object o)
					{
						if (o instanceof pair)
					    {
							pairLong p = (pairLong)o;
							return p.x == x && p.y == y ;
						}
						return false;
					}
					
					public int hashCode()
					{
						return new Long(x).hashCode()*31 + new Long(y).hashCode();
					}
				}
				
				public static int binarysearchPair(pair[] a, long n)
				{
					int idx = 0;
					int start = 0;
					int end = a.length-1;
					while(start <= end)
					{
						//System.out.println("--");
						
						int mid = (end + start)/2;
						if(n==a[mid].y)
							return mid;
						else if(n<a[mid].y)
							end = mid -1;
						else
							start = mid +1;
					}
					
					
					
					
					return -1;
				}
		
				
				public static int binarysearchPair(pairLong[] a, long n)
				{
					int idx = 0;
					int start = 0;
					int end = a.length-1;
					while(start <= end)
					{
						//System.out.println("--");
						
						int mid = (end + start)/2;
						if(n==a[mid].x)
							return mid;
						else if(n<a[mid].x)
							end = mid -1;
						else
							start = mid +1;
					}
					
					
					
					
					return -1;
				}
		
				static class node implements Comparable<node>
		
				{
					Integer x, y, z;
					node(int x,int y, int z)
					{
						this.x=x;
						this.y=y;
						this.z=z;
					}
					
					public int compareTo(pair o) {
						int result = x.compareTo(o.x);
						if(result==0)
							result = y.compareTo(o.y);
						if(result==0)
							result = z.compareTo(z); 
						return result;
					}
		
					@Override
					public int compareTo(node o) {
						// TODO Auto-generated method stub
						return 0;
					}  
				}
			}
				
			   