//Written By:Jason_Root
//Time Limit : 1000 MS
//Memory Limit : 65536 KB
#pragma GCC optimize(3)
#include<bits/stdc++.h>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string.h>
#include<limits.h>
#include<iostream>
#include<stdio.h>
#include<ctype.h>
#include<iomanip>
#include<cstdlib>
#include<cstring>
#include<utility>
#include<math.h>
#include<time.h>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#define For(i,s,e) for(int i = s;i <= e;i++)
#define Rof(i,s,e) for(int i = s;i >= e;i--)
#define File(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)
#define Close fclose(stdin);fclose(stdout);
#define mp(a,b) make_pair(a,b)
#define inc(a,b) a+= b
#define dec(a,b) a-= b
using namespace std;
typedef unsigned usd;
typedef long long ll;
typedef unsigned long long ull;
const int inf = 0x3f3f3f3f;
namespace bign {
#define L 100001
//////////////////////////////////////////////////////
	string add(string a,string b) { //只限两个非负整数相加,不支持负数
		string ans;
		int na[L]= {0},nb[L]= {0};
		int la=a.size(),lb=b.size();
		for(int i=0; i<la; i++) na[la-1-i]=a[i]-'0';
		for(int i=0; i<lb; i++) nb[lb-1-i]=b[i]-'0';
		int lmax=la>lb?la:lb;
		for(int i=0; i<lmax; i++) na[i]+=nb[i],na[i+1]+=na[i]/10,na[i]%=10;
		if(na[lmax]) lmax++;
		for(int i=lmax-1; i>=0; i--) ans+=na[i]+'0';
		return ans;
	}
//////////////////////////////////////////////////////
	string sub(string a,string b) { //只限大的非负整数减小的非负整数
		string ans;
		int la=a.size(),lb=b.size();
		if(la < lb) {
			ans = sub(b,a);
			cout << '-';
			return ans;
		}
		int na[L]= {0},nb[L]= {0};
		for(int i=0; i<la; i++) na[la-1-i]=a[i]-'0';
		for(int i=0; i<lb; i++) nb[lb-1-i]=b[i]-'0';
		int lmax=la>lb?la:lb;
		for(int i=0; i<lmax; i++) {
			na[i]-=nb[i];
			if(na[i]<0) na[i]+=10,na[i+1]--;
		}
		while(!na[--lmax]&&lmax>0)  ;
		lmax++;
		for(int i=lmax-1; i>=0; i--) ans+=na[i]+'0';
		return ans;
	}
//////////////////////////////////////////////////////
	string mul(string a,string b) { //同上
		string s;
		if(a == "0" || b == "0") {
			s = "0";
			return s;
		}
		int na[L],nb[L],nc[L],La=a.size(),Lb=b.size();
		fill(na,na+L,0);
		fill(nb,nb+L,0);
		fill(nc,nc+L,0);
		for(int i=La-1; i>=0; i--) na[La-i]=a[i]-'0';
		for(int i=Lb-1; i>=0; i--) nb[Lb-i]=b[i]-'0';
		for(int i=1; i<=La; i++)
			for(int j=1; j<=Lb; j++)
				nc[i+j-1]+=na[i]*nb[j];
		for(int i=1; i<=La+Lb; i++)
			nc[i+1]+=nc[i]/10,nc[i]%=10;
		if(nc[La+Lb]) s+=nc[La+Lb]+'0';
		for(int i=La+Lb-1; i>=1; i--)
			s+=nc[i]+'0';
		return s;
	}
//////////////////////////////////////////////////////
	string mulint(string a,int b) { //高精度a乘单精度b
		string ans;
		int na[L];
		int La=a.size();
		fill(na,na+L,0);
		for(int i=La-1; i>=0; i--) na[La-i-1]=a[i]-'0';
		int w=0;
		for(int i=0; i<La; i++) na[i]=na[i]*b+w,w=na[i]/10,na[i]=na[i]%10;
		while(w) na[La++]=w%10,w/=10;
		La--;
		while(La>=0) ans+=na[La--]+'0';
		return ans;
	}
//////////////////////////////////////////////////////
	int sub(int *a,int *b,int La,int Lb) {
		if(La<Lb) return -1;//如果a小于b，则返回-1
		if(La==Lb) {
			for(int i=La-1; i>=0; i--)
				if(a[i]>b[i]) break;
				else if(a[i]<b[i]) return -1;//如果a小于b，则返回-1

		}
		for(int i=0; i<La; i++) { //高精度减法
			a[i]-=b[i];
			if(a[i]<0) a[i]+=10,a[i+1]--;
		}
		for(int i=La-1; i>=0; i--)
			if(a[i]) return i+1;//返回差的位数
		return 0;//返回差的位数

	}
	string div(string n1,string n2,int nn) { //n1,n2是字符串表示的被除数，除数,nn是选择返回商还是余数
		string s,v;//s存商,v存余数
		int a[L],b[L],r[L],La=n1.size(),Lb=n2.size(),i,tp=La;//a，b是整形数组表示被除数，除数，tp保存被除数的长度
		fill(a,a+L,0);
		fill(b,b+L,0);
		fill(r,r+L,0);//数组元素都置为0
		for(i=La-1; i>=0; i--) a[La-1-i]=n1[i]-'0';
		for(i=Lb-1; i>=0; i--) b[Lb-1-i]=n2[i]-'0';
		if(La<Lb || (La==Lb && n1<n2)) {
			//cout<<0<<endl;
			return n1;
		}//如果a<b,则商为0，余数为被除数
		int t=La-Lb;//除被数和除数的位数之差
		for(int i=La-1; i>=0; i--) //将除数扩大10^t倍
			if(i>=t) b[i]=b[i-t];
			else b[i]=0;
		Lb=La;
		for(int j=0; j<=t; j++) {
			int temp;
			while((temp=sub(a,b+j,La,Lb-j))>=0) { //如果被除数比除数大继续减
				La=temp;
				r[t-j]++;
			}
		}
		for(i=0; i<L-10; i++) r[i+1]+=r[i]/10,r[i]%=10; //统一处理进位
		while(!r[i]) i--;//将整形数组表示的商转化成字符串表示的
		while(i>=0) s+=r[i--]+'0';
		//cout<<s<<endl;
		i=tp;
		while(!a[i]) i--;//将整形数组表示的余数转化成字符串表示的</span>
		while(i>=0) v+=a[i--]+'0';
		if(v.empty()) v="0";
		//cout<<v<<endl;
		if(nn==1) return s;
		if(nn==2) return v;
	}
//////////////////////////////////////////////////////
	string div(string a,int b) { //高精度a除以单精度b
		string r,ans;
		int d=0;
		if(a=="0") return a;//特判
		for(int i=0; i<a.size(); i++) {
			r+=(d*10+a[i]-'0')/b+'0';//求出商
			d=(d*10+(a[i]-'0'))%b;//求出余数
		}
		int p=0;
		for(int i=0; i<r.size(); i++)
			if(r[i]!='0') {
				p=i;
				break;
			}
		return r.substr(p);
	}
//////////////////////////////////////////////////////
	int mod(string a,int b) { //高精度a除以单精度b取模
		int d=0;
		for(int i=0; i<a.size(); i++) d=(d*10+(a[i]-'0'))%b; //求出余数
		return d;
	}
//////////////////////////////////////////////////////
	string fac(int n) { //阶乘模板
		string ans;
		int na[L];
		if(n==0) return "1";
		fill(na,na+L,0);
		int s=0,m=n;
		while(m) na[++s]=m%10,m/=10;
		for(int i=n-1; i>=2; i--) {
			int w=0;
			for(int j=1; j<=s; j++) na[j]=na[j]*i+w,w=na[j]/10,na[j]=na[j]%10;
			while(w) na[++s]=w%10,w/=10;
		}
		while(!na[s]) s--;
		while(s>=1) ans+=na[s--]+'0';
		return ans;
	}
//////////////////////////////////////////////////////
	inline bool compare(string a,string b) { //比较模板
		int i,la,lb;
		la=a.length();
		lb=b.length();
		if(a[0]=='-'&&b[0]!='-')return 1;
		if(a[0]!='-'&&b[0]=='-')return 0;
		if(a[0]=='-'&&b[0]=='-') {
			string x=a,y=b;
			x[0]='0';
			y[0]='0';
			return !compare(x,y);
		}
		if (la>lb) return 0;
		if (la<lb) return 1;
		for(i=la-1; i>=0; i--) {
			if (a[i]>b[i]) return 0;
			if (a[i]<b[i]) return 1;
		}
		return 0;
	}
}
class Stack {
		int s[100001];
		int maxn;
	public:
		bool push(int x) {
			if(maxn==100000)return 0;
			s[++maxn]=x;
			return 1;
		}
		bool pop() {
			if(maxn==0)return 0;
			maxn--;
			return 1;
		}
		int get() {
			return maxn;
		}
		int gettop() {
			return s[maxn];
		}
		void clear() {
			for(int i=0; i<=100000; i++) {
				s[i]=0;
			}
			maxn=0;
		}
		void visit() {
			for(int i=1; i<=maxn; i++) {
				cout<<s[i]<<' ';
			}
			cout<<endl;
		}
		bool isin(int x) {
			for(int i=1; i<=maxn; i++) {
				if(s[i]==x)return 0;
			}
			return 1;
		}
		void Sort() {
			sort(s+1,s+maxn+1);
		}
		void Unique() {
			sort(s+1,s+maxn+1);
			maxn=unique(s+1,s+maxn+1)-s-1;
		}
		bool empty() {
			return maxn==0;
		}
};
template <typename T>
__attribute__((optimize("O2")))
inline void read(T &x) {
	char ch = getchar();
	T f = 1;
	x = 0;
	while(ch < '0' || ch > '9') {
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = x*10 + ch-'0';
		ch = getchar();
	}
	x*= f;
}
__attribute__((optimize("O2")))
inline void print(int x) {
	if(x < 0) putchar('-'),x = -x;
	if(x > 9) print(x/10);
	putchar(x%10+'0');
}
__attribute__((optimize("O2")))
inline int gcd(int a,int b) {
	return b==0 ? a : gcd(b,a%b);
}
__attribute__((optimize("O2")))
inline int lcm(int a,int b) {
	return a/gcd(a, b)*b;
}
__attribute__((optimize("O2")))
inline int max(int x1,int x2) {
	return x1>x2 ? x1 : x2;
}
__attribute__((optimize("O2")))
inline int min(int x1,int x2) {
	return x1<x2 ? x1 : x2;
}
bool prime(int x) {
	if(x == 2 || x == 3) {
		return true;
	}
	if(x == 1 || (x%6 != 1 && x%6 != 5)) {
		return false;
	}
	for(int i = 5; i <= sqrt(x); i+= 6) {
		if(x%i == 0 || x%(i+2) == 0) {
			return false;
		}
	}
	return true;
}
__attribute__((optimize("O2")))
void quickSort(int a[],int Len,int R) {
	if(Len > R) return;
	int i = Len,j = R;
	int temp = a[Len];
	while(i != j) {
		while(a[j] >= temp && i < j)
			j--;
		while(a[i] <= temp && i < j)
			i++;
		if(i < j)
			swap(a[i],a[j]);
	}
	swap(a[Len],a[i]);
	quickSort(a,Len,i-1);
	quickSort(a,i+1,R);
}
__attribute__((optimize("O2")))
ll Power(ll x,ll y,ll p) {
	ll ans;
	ans = 1;
	while(y) {
		if(y&1) {
			ans = ans * x % p;
		}
		y>>=1;
		x = x * x % p;
	}
	return ans;
}
#define glibcxx_requires_valid_range(_First,_Lenast)
#define glibcxx_function_requires(...)
template<typename _BidirectionalIterator, typename _Compare>
inline bool next_permutation(_BidirectionalIterator __first,_BidirectionalIterator __last, _Compare __comp) {
	glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
	glibcxx_function_requires(_BinaryPredicateConcept<_Compare,typename iterator_traits<_BidirectionalIterator>::value_type,typename iterator_traits<_BidirectionalIterator>::value_type>)
	glibcxx_requires_valid_range(__first, __last);
	return std::__next_permutation(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
}
/*
struct Fenwick_tree{
    int c[1001];
    int lowbit(int x) {return x&(-x);}
    void add(int x) {
        while (x<=n) {
          c[x]++;
          x+=lowbit(x);
        }
    }
    int sum(int x) {
        if (x<=0) return 0;
        int ret=0;
        while (x) {
          ret+=c[x];
          x-=lowbit(x);
        }
        return ret;
    }
}t;*/
string str;
bool flag = false;
__attribute__((optimize("O2")))
void func() {
	ios_base::sync_with_stdio(false);
	cin >> str;
	For(i,0,str.length()-1) {
		if(str[i] == 'C') {
			flag = true;
		} else if(str[i] == 'F' && flag) {
			putchar('Y'),putchar('e'),putchar('s'),putchar('\n');
			return;
		}
	}
	putchar('N'),putchar('o'),putchar('\n');
	return;
}
int main(int argc, char const *argv[]) {
	func();
	return 0;
}


Measured memory_bytes: 256