#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pi2 = pair<int, int>;
using pll2 = pair<ll, ll>;
using vs = vector<string>;
using vi = vector<int>;
using vi2 = vector<vi>;
using vi3 = vector<vi2>;
using vll = vector<ll>;
using vll2 = vector<vll>;
using vll3 = vector<vll2>;
using vd = vector<db>;
using vd2 = vector<vd>;
using vd3 = vector<vd2>;
static const ll inf = 1LL << 60;
static const ll MOD = 1e9 + 7;
class BIT {
 public:
  vll d;
  vll v;
  ll size;
  BIT(ll _size) {
    size = _size;
    d.assign(size + 1, 0);
    v.assign(size, 0);
  }
  BIT(vll vec) { copy(vec); }
  void add(ll idx, ll N) {
    v[idx] += N;
    idx++;
    while (idx <= size) {
      d[idx] += N;
      idx += ((idx) & (-(idx)));
    }
  }
  ll sum(ll idx = inf) {
    idx++;
    idx = min(idx, size);
    ll ans = 0;
    while (idx) {
      ans += d[idx];
      idx -= ((idx) & (-(idx)));
    }
    return ans;
  }
  void copy(vll vec) {
    size = vec.size();
    d.assign(size + 1, 0);
    v.assign(size, 0);
    for (long long i = (0); i <= ((size)-1); i++) {
      add(i, vec[i]);
    }
  }
};
class UnionFind {
 public:
  vll arr;
  UnionFind(ll sz) : arr(sz, -1) {}
  ll root(ll node) {
    return arr[node] < 0 ? node : arr[node] = root(arr[node]);
  }
  ll size(ll x) { return -arr[root(x)]; }
  bool union_set(ll x, ll y) {
    x = root(x);
    y = root(y);
    if (x != y) {
      if (arr[x] < arr[y]) {
        swap(x, y);
      }
      arr[x] += arr[y];
      arr[y] = x;
    }
    return x != y;
  }
  bool find_set(ll x, ll y) { return root(x) == root(y); }
};
class Vertex {
 public:
  ll idx;
  ll param = -1;
  ll dist = inf;
  vector<pair<Vertex *, ll> > e;
  ll size() { return e.size(); }
  bool operator==(const Vertex *o) { return dist == o->dist; }
  bool operator!=(const Vertex *o) { return dist != o->dist; }
  bool operator>(const Vertex *o) { return dist > o->dist; }
  bool operator<(const Vertex *o) { return dist < o->dist; }
  bool operator>=(const Vertex *o) { return dist >= o->dist; }
  bool operator<=(const Vertex *o) { return dist <= o->dist; }
};
class Graph {
 public:
  vector<Vertex *> V;
  typedef tuple<Vertex *, Vertex *, ll> Edge;
  vector<Edge> E;
  Graph(ll sz) {
    for (long long i = (0); i <= ((sz)-1); i++) {
      auto v = new Vertex();
      v->idx = i;
      V.push_back(v);
    }
  }
  static bool comp(const Edge &e1, const Edge &e2) {
    return get<2>(e1) < get<2>(e2);
  }
  Vertex *getVertex(long long idx) { return V[idx]; }
  void unite(ll from, ll to, ll w = 1, bool digraph = true) {
    E.push_back(make_tuple(V[from], V[to], w));
    V[from]->e.push_back(make_pair(V[to], w));
    if (!digraph) {
      E.push_back(make_tuple(V[to], V[from], w));
      V[to]->e.push_back(make_pair(V[from], w));
    }
  }
  void dijkstra(ll start) {
    priority_queue<Vertex *, vector<Vertex *>, greater<Vertex *> > pq;
    Vertex *s = getVertex(start);
    s->dist = 0;
    pq.push(s);
    while (!pq.empty()) {
      Vertex *v = pq.top();
      pq.pop();
      for (auto &u : v->e) {
        if (u.first->dist > v->dist + u.second) {
          u.first->dist = v->dist + u.second;
          pq.push(u.first);
        }
      }
    }
  }
};
ll isPrime(ll n) {
  if (n <= 1) return 0;
  for (long long i = (2); i <= ((ll)sqrt(n)); i++) {
    if (n % i == 0) return 0;
  }
  return 1;
}
void vout(vll v) {
  cout << ("{");
  ;
  for (long long i = (0); i <= ((v.size()) - 1); i++) {
    cout << (v[i]);
    ;
    if (i != v.size() - 1) {
      cout << (", ");
      ;
    }
  }
  cout << ("}") << endl;
  ;
}
ll DigS10(ll n) {
  ll m = 0;
  for (long long i = (0);
       i <= (((llabs(n) == 0 ? 1 : ((ll)(log10(db(llabs(n)))) + 1))) - 1);
       i++) {
    m += (ll)((llabs(n) % ((ll)(pow(10.0, db(i + 1)))))) /
         ((ll)(pow(10.0, db(i))));
  }
  return m;
}
ll PowMod(ll a, ll b) {
  ll ans = 1, x = a % MOD;
  for (long long i = (0);
       i <= (((llabs(b) == 0 ? 1 : ((ll)(log2(db(llabs(b)))) + 1))) - 1); i++) {
    if ((((b) >> (i)) & 1) == 1) {
      ans = (ans * x) % MOD;
    }
    if (i != ((llabs(b) == 0 ? 1 : ((ll)(log2(db(llabs(b)))) + 1)) - 1)) {
      x = (x * x) % MOD;
    }
  }
  return ans;
}
vll FactMod(1, 1);
vll FactModInv(1, 1);
ll Mod(ll n) {
  n %= MOD;
  n = (n + MOD) % MOD;
  return n;
}
ll InvM(ll n) {
  n = Mod(n);
  n = PowMod(n, MOD - 2);
  return n;
}
void CFactMod(ll n) {
  if (FactMod.size() <= n) {
    for (long long i = (FactMod.size()); i <= (n); i++) {
      FactMod.push_back((FactMod[i - 1] * (i % MOD)) % MOD);
    }
  }
}
void CFactModInv(ll n) {
  CFactMod(n);
  if (FactModInv.size() < (n + 1)) {
    FactModInv.resize(n + 1, -1);
  }
  if (FactModInv[n] == -1) {
    FactModInv[n] = PowMod(FactMod[n], MOD - 2);
  }
  for (long long i = n - 1; i >= 1; i--) {
    if (FactModInv[i] != -1) break;
    FactModInv[i] = ((FactModInv[i + 1] * ((i + 1) % MOD)) % MOD);
  }
}
ll CombMod(ll n, ll k) {
  if (n < 0 || k < 0 || n < k) return 0;
  if (n + 1 > FactModInv.size()) CFactModInv(n);
  return ((((FactModInv[k] * FactModInv[n - k]) % MOD) * FactMod[n]) % MOD);
}
tuple<long long, long long> factor_sub(long long n, long long m) {
  long long i = 0;
  while (n % m == 0) {
    i++;
    n /= m;
  }
  return make_tuple(i, n);
}
vector<tuple<long long, long long> > factorization(long long n) {
  vector<tuple<long long, long long> > a;
  long long c, m;
  tie(c, m) = factor_sub(n, 2);
  if (c > 0) a.push_back(make_tuple(2, c));
  for (long long i = 3; m >= i * i; i += 2) {
    tie(c, m) = factor_sub(m, i);
    if (c > 0) a.push_back(make_tuple(i, c));
  }
  if (m > 1) a.push_back(make_tuple(m, 1));
  return a;
}
signed main() {
  string(S);
  cin >> S;
  ;
  string k = "keyence";
  ll j = 0;
  bool f = false;
  for (long long n = (1); n <= (7); n++) {
    string p = k.substr(0, n);
    string q = k.substr(n, 7 - n);
    for (long long i = (0); i <= ((S.size()) - 1); i++) {
      ll j = 0;
      ll a = i;
      if (S[a] == p[j]) {
        while (S[a] == p[j] && j < p.size() && a < S.size()) {
          a++;
          j++;
        }
        if (j != p.size()) {
          break;
        }
        j = 0;
        if (n == 7) {
          f = true;
          break;
        }
        while (S[a] != q[j] && j < q.size() && a < S.size()) {
          a++;
        }
        while (S[a] == q[j] && j < q.size() && a < S.size()) {
          a++;
          j++;
        }
        if (j == q.size()) {
          f = true;
        }
      }
    }
  }
_end:;
  if (f) {
    cout << ("YES") << endl;
    ;
  } else {
    cout << ("NO") << endl;
    ;
  }
}
