One day Alex was creating a contest about his friends, but accidentally deleted it. Fortunately, all the problems were saved, but now he needs to find them among other problems.

But there are too many problems, to do it manually. Alex asks you to write a program, which will determine if a problem is from this contest by its name.

It is known, that problem is from this contest if and only if its name contains one of Alex's friends' name exactly once. His friends' names are "Danil", "Olya", "Slava", "Ann" and "Nikita".

Names are case sensitive.

Input

The only line contains string from lowercase and uppercase letters and "_" symbols of length, not more than 100 — the name of the problem.

Output

Print "YES", if problem is from this contest, and "NO" otherwise.

Examples

Input

Alex_and_broken_contest


Output

NO

Input

NikitaAndString


Output

YES

Input

Danil_and_Olya


Output

NO
import java.util.*;
import java.io.*;
import java.math.*;
public final class Solution 
{
    public static void main(String[] args)
    {
   	 Reader input = new Reader();
     PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
     String s = input.next();
     int temp = s.indexOf("Danil");
     int temp2 = s.indexOf("Olya");
     int temp3 = s.indexOf("Slava");
     int temp4 = s.indexOf("Ann");
     int temp5 = s.indexOf("Nikita");
     if(temp != -1 && temp == s.lastIndexOf("Danil"))
     {
    	 if(!s.contains("Olya") && !s.contains("Slava") && !s.contains("Ann") && !s.contains("Nikita"))
    	 {
    		 out.println("YES");
    	 }
    	 else
    		 out.println("NO");
     }
     else if(temp2 != -1 && temp2 == s.lastIndexOf("Olya"))
     {
    	 if(!s.contains("Danil")  && !s.contains("Slava") && !s.contains("Ann") && !s.contains("Nikita"))
    	 {
    		 out.println("YES");
    	 }
    	 else
    		 out.println("NO");
     }
     else if(temp3 != -1 && temp3 == s.lastIndexOf("Slava"))
     {
    	 if(!s.contains("Danil") && !s.contains("Olya")  && !s.contains("Ann") && !s.contains("Nikita"))
    	 {
    		 out.println("YES");
    	 }
    	 else
    		 out.println("NO");
     }
     else if(temp4 != -1 && temp4 == s.lastIndexOf("Ann"))
     {
    	 if(!s.contains("Danil") && !s.contains("Olya") && !s.contains("Slava")  && !s.contains("Nikita"))
    	 {
    		 out.println("YES");
    	 }
    	 else
    		 out.println("NO");
     }
     else if(temp5 != -1 && temp5 == s.lastIndexOf("Nikita"))
     {
    	 if(!s.contains("Danil") && !s.contains("Olya") && !s.contains("Slava") && !s.contains("Ann"))
    	 {
    		 out.println("YES");
    	 }
    	 else
    		 out.println("NO");
     }
     else
    	 out.println("NO");
	 out.close();	 
    }  
    public static int z(int n)
    {
    	/*finds the number of trailing zeros in factorial */
    	int count = 0;
    	for(int i = 5 ; i <= n ; i *= 5)
    	{
    		count += n / i;
    	}
    	return count;
    }
    public static int gcd(int a , int b)
    {
    	if(b == 0)
    		return a;
    	return gcd(b , a %b);
    }
    public static class UnionFind
    {
    	/* this class uses zeroIndexing and gives the result back in zero indexing*/
    	int[] parent;
    	int[] size;
    	int maxSize = 0;
    	public UnionFind(int n)
    	{
    		size = new int[n];
    		parent = new int[n];
    		for(int i = 0 ; i < n ; i++)
    		{
    			parent[i] = i;
    			size[i] = 1;
    		}
    		maxSize = 1;
    	}
    	public int find(int pos)
    	{
    		if(parent[pos] == pos)
    			return pos;
    		return parent[pos] = find(parent[pos]);
    	}
    	public void unify(int x , int y)
    	{
    		int xParent = find(x);
    		int yParent = find(y);
    		if(xParent == yParent)
    			return;
    		else if(size[xParent] > size[yParent]) 
    		{
    			size[xParent] += size[yParent];
    			if(size[xParent] > maxSize)
    				maxSize = size[xParent];
    			parent[yParent] = xParent;
    		}
    		else
    		{
    			size[yParent] += size[xParent];
    			if(size[yParent] > maxSize)
    				maxSize = size[yParent];
    			parent[xParent] = yParent;
    		}
    	}
    	public int maxSize()
    	{
    		return maxSize;
    	}
    }
    public static class Pair implements Comparable<Pair>
    {
    	int a ,  b;
    	public Pair(int a , int b)
    	{
    		this.a = a;
    		this.b = b;
    	}
		@Override
		public int compareTo(Pair t) {
			// TODO Auto-generated method stub
    		if(t.a == this.a)
    		{
    			if(this.b < t.b)
    				return -1;
    			else if(this.b > t.b)
    				return 1;
    			else
    				return 0;
    		}
    		else if(this.a < t.a)
    			return -1;
    		else
    			return 1;
		}
    }
    public static class Reader
    {
    	BufferedReader br;
    	StringTokenizer st;
    	public Reader()
    	{
    		br = new BufferedReader(new InputStreamReader(System.in));    		
    	}
    	public String next()
    	{
    		try
    		{
        		if(st == null || !st.hasMoreTokens())
        			st = new StringTokenizer(br.readLine());
    		}
    		catch(IOException ex)
    		{
    			ex.printStackTrace();
    			System.exit(1);
    		}    		
    		return st.nextToken();
    	}
    	public int nextInt()
    	{
    		return Integer.parseInt(next());
    	}
    	public double nextDouble()
    	{
    		return Double.parseDouble(next());
    	}
    	public long nextLong()
    	{
    		return Long.parseLong(next());
    	}
    	public String nextLine()
    	{
    		try
    		{
    			return br.readLine();
    		}
    		catch(IOException ex)
    		{
    			ex.printStackTrace();
    			System.exit(1);
    		}
    		return "";
    	}
    }
}