#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-5;
const long long INFLL = (long long)(1e9) * (long long)(1e9);
const int INF = 1e9 + 7;
template <class T>
void chmin(T& a, const T b) {
  if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T b) {
  if (a < b) a = b;
}
const long long powLL(const long long p, const long long q) {
  long long t = 1;
  for (int i = 0; i < q; i++) t *= p;
  return t;
}
template <typename T>
struct has_iter {
 private:
  template <typename U>
  static constexpr true_type check(typename U::iterator*);
  template <typename U>
  static constexpr false_type check(...);

 public:
  static constexpr bool value = decltype(check<T>(nullptr))::value;
};
template <typename T, typename U = typename T::iterator>
void print(const T& container) {
  auto &&first = begin(container), last = end(container);
  auto&& back = prev(last);
  for (auto e = first; e != last; e = next(e)) cout << *e << " \n"[e == back];
}
extern void* enabler;
template <typename Head,
          typename enable_if<!has_iter<Head>::value>::type*& = enabler>
void print(const Head& head) {
  cout << head << "\n";
}
template <>
void print<string>(const string& container) {
  cout << container << "\n";
}
template <typename Head, typename... Tail>
void print(const Head& head, const Tail&... tail) {
  cout << head << " ";
  print(tail...);
}
template <typename... Args>
void printd(const Args&... args) {
  print(args...);
}
template <typename Head>
void input(Head& head) {
  cin >> head;
}
template <typename Head, typename... Tail>
void input(Head& head, Tail&... tail) {
  cin >> head;
  input(tail...);
}
void io_speedup() {
  cin.tie(0);
  cout.tie(0);
  ios::sync_with_stdio(false);
}
template <typename T>
istream& operator>>(istream& is, vector<T>& vec) {
  for (T& x : vec) is >> x;
  return is;
}
template <typename T, typename U>
istream& operator>>(istream& is, pair<T, U>& t) {
  is >> t.first >> t.second;
  return is;
}
template <int N, typename... Ts,
          typename enable_if<N == sizeof...(Ts) - 1>::type*& = enabler>
void tuple_in(istream& is, tuple<Ts...>& t) {
  is >> get<N>(t);
}
template <int N, typename... Ts,
          typename enable_if<N<sizeof...(Ts) - 1>::type*& = enabler> void
              tuple_in(istream& is, tuple<Ts...>& t) {
  is >> get<N>(t);
  tuple_in<N + 1, Ts...>(is, t);
}
template <typename... Ts>
istream& operator>>(istream& is, tuple<Ts...>& t) {
  tuple_in<0, Ts...>(is, t);
  return is;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& t) {
  os << '(' << t.first << ", " << t.second << ')';
  return os;
}
template <int N, typename... Ts,
          typename enable_if<N == sizeof...(Ts) - 1>::type*& = enabler>
void tuple_out(ostream& os, const tuple<Ts...>& t) {
  os << get<N>(t);
}
template <int N, typename... Ts,
          typename enable_if<N<sizeof...(Ts) - 1>::type*& = enabler> void
              tuple_out(ostream& os, const tuple<Ts...>& t) {
  os << get<N>(t) << ", ";
  tuple_out<N + 1, Ts...>(os, t);
}
template <typename... Ts>
ostream& operator<<(ostream& os, const tuple<Ts...>& t) {
  os << '(';
  tuple_out<0, Ts...>(os, t);
  os << ')';
  return os;
}
template <typename T>
vector<T> read(int n) {
  vector<T> t(n);
  cin >> t;
  return t;
}
template <typename T>
T read() {
  T t;
  cin >> t;
  return t;
}
template <typename Head, typename... Tail>
struct vector_demensions {
  using type = vector<typename vector_demensions<Tail...>::type>;
};
template <typename Head>
struct vector_demensions<Head> {
  using type = Head;
};
template <typename T>
vector<T> make_vectors(int size, T val) {
  return vector<T>(size, val);
}
template <typename T = int, typename... Args>
auto make_vectors(int size, Args... tail) ->
    typename vector_demensions<Args..., T>::type {
  auto val = make_vectors<T>(forward<Args>(tail)...);
  return vector<decltype(val)>(size, val);
}
int main() {
  string s = read<string>();
  string t = "keyence";
  bool f = 0;
  for (int i = (0); i < (int)(s.size() - t.size() + 1); ++i) {
    bool fl = 1;
    for (int j = (0); j < (int)(i); ++j)
      if (s[j] != t[j]) fl = 0;
    if (!fl) continue;
    for (int j = (i); j < (int)(t.size()); ++j)
      if (s[s.size() - t.size() + j] != t[j]) fl = 0;
    if (!fl) continue;
    f = 1;
    break;
  }
  if (f)
    print("YES");
  else
    print("NO");
}
