Kostya likes Codeforces contests very much. However, he is very disappointed that his solutions are frequently hacked. That's why he decided to obfuscate (intentionally make less readable) his code before upcoming contest.

To obfuscate the code, Kostya first looks at the first variable name used in his program and replaces all its occurrences with a single symbol a, then he looks at the second variable name that has not been replaced yet, and replaces all its occurrences with b, and so on. Kostya is well-mannered, so he doesn't use any one-letter names before obfuscation. Moreover, there are at most 26 unique identifiers in his programs.

You are given a list of identifiers of some program with removed spaces and line breaks. Check if this program can be a result of Kostya's obfuscation.

Input

In the only line of input there is a string S of lowercase English letters (1 ≤ |S| ≤ 500) — the identifiers of a program with removed whitespace characters.

Output

If this program can be a result of Kostya's obfuscation, print "YES" (without quotes), otherwise print "NO".

Examples

Input

abacaba


Output

YES


Input

jinotega


Output

NO

Note

In the first sample case, one possible list of identifiers would be "number string number character number string number". Here how Kostya would obfuscate the program:

  * replace all occurences of number with a, the result would be "a string a character a string a",
  * replace all occurences of string with b, the result would be "a b a character a b a",
  * replace all occurences of character with c, the result would be "a b a c a b a",
  * all identifiers have been replaced, thus the obfuscation is finished.
import java.util.*;
import java.io.*;
import java.math.*;
import java.math.BigInteger;
import java.text.DecimalFormat;
  public class Tester {
	//static long sum=0,sum1=Long.MAX_VALUE;
	//DecimalFormat df = new DecimalFormat("#.#####");
		static int visited[] = new int[100005];
		//Stack s=new Stack();
	public static final long MOD = (long) (1e9 + 7);
		static long h[];
		static long j;
			// Driver program to test above function
		    public static void main(String args[])
		     {
		    	Scanner sc=new Scanner(System.in);
		    	InputReader in = new InputReader(System.in);
		  	  	OutputStream outputStream = System.out;
		  	  	PrintWriter out = new PrintWriter(outputStream);
		  	  	String s=in.next();
		  	  	int min='a';
		  	  	if(s.charAt(0)!=min)
		  	  		out.println("NO");
		  	  	else
		  	  	{
		  	  		int i;
		  	  		for(i=1;i<s.length();i++)
		  	  		{
		  	  			if(s.charAt(i)>min)
		  	  			{
		  	  				if(s.charAt(i)!=min+1)
		  	  				{
		  	  					break;
		  	  				}
		  	  				else
		  	  				{
		  	  					min=min+1;
		  	  				}
		  	  			}
		  	  		}
		  	  		if(i==s.length())
		  	  			out.println("YES");
		  	  		else
		  	  			out.println("NO");
		  	  		
		  	  	}
		  	  	out.close();	
		     }
		    static int count(long arr[],long arr1[],HashMap<Long,Integer> h,HashMap<Long,Integer> h1)
		    {
		    	int count=0;
		  	  	for(int i=0;i<arr.length;i++)
		  	  	{
		  	  		//System.out.println("sdfsdfsdf");
		  	  		int s_i=h.get(arr1[i]);
		  	  		//int o_i=h.get(arr1[i]);
		  	  		//System.out.println(arr[i]+"   "+arr1[i]);
		  	  		if(arr[i]!=arr1[i])
		  	  		{
		  	  			//System.out.println("asdasd");
		  	  			count++;
		  	  			h.put(arr[i],s_i);
		  	  			long temp=arr[i];
		  	  			arr[i]=arr1[i];
		  	  			arr[s_i]=temp;
		  	  		}
		  	  	}
		  	  	return count;
		    }
		    static int lcs(String s,String s1,int m,int n)
		    {
		    	int arr[][]=new int[m+1][n+1];
		    	for(int i=0;i<=m;i++)
		    	{
		    		for(int j=0;j<=n;j++)
		    		{
		    			if(i==0||j==0)
		    			{
		    				arr[i][j]=0;
		    			}
		    			else
		    			{
		    				if(s.charAt(i-1)==s1.charAt(j-1))
		    				{
		    					arr[i][j]=arr[i-1][j-1]+1;
		    				}
		    				else
		    				{
		    					arr[i][j]=Integer.max(arr[i][j-1],arr[i-1][j]);
		    				}
		    			}
		    		}
		    	}
		    	return arr[m][n];
		    }
		    static int getInvCount(int arr[], int n)
		    {
		      int inv_count = 0;
		      for (int i = 0; i < n - 1; i++)
		        for (int j = i+1; j < n; j++)
		          if (arr[i] > arr[j])
		            inv_count++;
		     
		      return inv_count;
		    }
		    static int dfs(char arr[][],int i,int j,int n,int m,int p,int q)
		    {
		    	
		    	if(i<0||i>=n||j<0||j>=m||arr[i][j]=='X')
		    	{
		    		return 0;
		    	}
		    	if(i==p&&j==q)
		    	{
		    		for(int g=0;g<n;g++)
		    		{
		    			for(int h=0;h<m;h++)
		    			{
		    				arr[g][h]='X';
		    			}
		    		}
		    		return 0;
		    	}
		    	else
		    	{
		    		int count=0;
		    		arr[i][j]='X';
		    		System.out.println("i j"+i+" "+j);
		    		if(arr[i][j-1]=='.'&&i>=0&&i<n&&j-1>=0&&j-1<m)
		    			count++;
		    		if(arr[i][j+1]=='.'&&i>=0&&i<n&&j+1>=0&&j+1<m)
		    			count++;
		    		if(arr[i-1][j]=='.')
		    			count++;
		    		if(arr[i+1][j]=='.')
		    			count++;
		    		if(count>1)
		    		{
		    			System.out.println("AAYAYAYA");
		    			return 1+dfs(arr,i,j-1,n,m,p,q)+dfs(arr,i,j+1,n,m,p,q)+dfs(arr,i-1,j,n,m,p,q)+dfs(arr,i+1,j,n,m,p,q);
		    		}
		    		else
		    			return dfs(arr,i,j-1,n,m,p,q)+dfs(arr,i,j+1,n,m,p,q)+dfs(arr,i-1,j,n,m,p,q)+dfs(arr,i+1,j,n,m,p,q);
		    	}
		    }
		    static int BFS(ArrayList<ArrayList<Integer>> adj, int root)
		    {
		    	    Queue<Integer> q=new LinkedList<Integer>();
		    	    visited[1]=1;
				 	visited[root]=1;
				 	//dis[root]=0;
				    q.add(root);
				    int count=1;
				 	while(!q.isEmpty())
				 	{
				 		int element=q.remove();
				 		System.out.println("element is "+element);
				 		for (int i : adj.get(element)) {
							if (visited[i] == 0) {
				 			{	
					 			System.out.println("i is "+i);
				 				visited[i]=1;
				 				q.add(i);
				 				//dis[i]=dis[element]+6;
				 				count++;
				 			}
				 				
				 			}
				 	    }
				 	}
				 	return count;
		    }
		    public static long power(long base, long exp) {
		        long res=1;
		        while(exp>0) {
		           if(exp%2==1) res=(res*base)%MOD;
		           base=(base*base)%MOD;
		           exp/=2;
		        }
		        return res%MOD;
		    }
	public static long power(long i)
	{
		long c=1;
		while(i>1)
		{
			c=((c%MOD)*(2%MOD))%MOD;
			i--;
		}
		return c;
	}
	public static long gcd(long p, long q) {
        if (q == 0) {
                return p;
        }
        return gcd(q, p % q);
}
	private static int[] nextIntArray(InputReader in,int n)	
	{
		int[] a=new int[n];
		for(int i=0;i<n;i++)
			a[i]=in.nextInt();
		return a;
	}
 static class LengthComparator implements Comparator<String> {
	    public int compare(String arg0, String arg1) {
		// Use Integer.compare to compare the two Strings' lengths.
		return (arg0+arg1).compareTo(arg1+arg0);
	    }
	}
/*static class Graph {
    	
    	private static Deque<Integer> stack = new ArrayDeque<Integer>();
 		private int least,count,v;
 		
		Set<Integer>[] cities;
    	private int[] risk;
    	
    	Graph(int n,String[] risk){
    		
    		cities = new HashSet[n];
    		this.risk = new int[n];
    		for(int i =0;i<n;i++){
    			cities[i] = new HashSet<>();
    		}
    		for(int i =0;i<n;i++){
    			this.risk[i] = Integer.parseInt(risk[i]);
    		}
    		visited = new boolean[n];
    	}
    	
    	
    	public void add(int x,int y){
    		cities[x].add(y);
    		cities[y].add(x);
    	}
}*/
	static int root(int arr[],int i)
	{
		while(arr[i]!=i)
		{
			i=arr[i];
		}
		return i;
	}
	static boolean find(int arr[],int a,int b)
	{
		if(root(arr,a)==root(arr,b))
		{
			return true;
		}
		else
			return false;
	}
	static void weighted_union(int arr[],int size[],int a,int b)
	{
		int root_a=root(arr,a);
		int root_b=root(arr,b);
		if(root_a!=root_b)
		{
			//if(size[root_a]<size[root_b])
			{
				arr[root_a]=arr[root_b];
				size[root_b]+=size[root_a];
			}
//			else
//			{
//				arr[root_b]=arr[root_a];
//				size[root_a]+=size[root_b];
//			}
		//	count--;
		}
	}
	static class Pair implements Comparable<Pair>
	{
		private long first;
		private long index;
		private long row;
 
		public Pair(long i, long j) 
		{ 
			this.first = i;
			this.index = j;
		}
		public Pair() {
			// TODO Auto-generated constructor stub
		}
		public long getFirst() { return first; }
		//public long getSecond() { return second; }
		public long getIndex() { return index ;}
		public void setFirst(long k) { this.first=k ; }
		public void setIndex(long k) { this.index=k ;}
		//public void setSecond(long k) { this.second=k ;}
		@Override
		public int compareTo(Pair o) 
		{
			return Long.compare(this.row, o.row);
		}
		
	}
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
 
		public InputReader(InputStream inputstream) {
			reader = new BufferedReader(new InputStreamReader(inputstream));
			tokenizer = null;
		}
 
		public String nextLine(){
			String fullLine=null;
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					fullLine=reader.readLine();
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				return fullLine;
			}
			return fullLine;
		}
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}
class Graph
{
	static int ans=0;
	private int V;
	private static ArrayList<Integer> adj[];
	Graph(int v)
	{
		V=v;
		adj=new ArrayList[V];
		for(int i=0;i<V;i++)
		{
			adj[i]=new ArrayList();
		}
	}
	void addEdge(int v,int w)
	{
		adj[v].add(w);
	}
	static boolean isbipartite(int s,int color[],boolean visited[])
    {
    	Queue<Integer> q=new LinkedList();
    	q.add(s);
    	color[s]=1;
    	int baap=1;
    	while(!q.isEmpty())
    	{
    		int k=q.poll();
    		Iterator<Integer> i=adj[k].listIterator();
    		if(color[k]==1)
    			baap=1;
    		else
    			baap=2;
    		while(i.hasNext())
    		{
    				int j=i.next();
    				if(visited[j]==false)
    				{
    					visited[j]=true;
    					q.add(j);
    				}
    				if(baap==1)
    				{
    					if(color[j]==1)
    						return false;
    					color[j]=2;
    				}
    				else
    				{
    					if(color[j]==2)
    						return false;
    					color[j]=1;
    				}
    				//q.add(j);    			
    		}
    	}
    	return true;
    }
	void topologicalSortUtil(int v, boolean visited[],
            Stack s)
		{
		// Mark the current node as visited.
			visited[v] = true;
			Integer i;

// Recur for all the vertices adjacent to this
// vertex
			Iterator<Integer> it = adj[v].iterator();
			while (it.hasNext())
			{
				i = it.next();
				if (!visited[i])
					topologicalSortUtil(i, visited, s);
			}

		// 	Push current vertex to stack which stores result
			s.push(new Integer(v));
		}
	void BFS(int s)
	{
		Queue<Integer> q=new LinkedList();
		boolean visited[]=new boolean[V];
		q.add(s);
		int r=0;
		while(!q.isEmpty())
		{
				r=q.poll();
				visited[r]=true;
				System.out.println("queue me nikla "+r);
				Iterator<Integer> i=adj[r].listIterator();
				while(i.hasNext())
				{
					int n=i.next();
					if(visited[n]==false)
					{
						q.add(n);
						visited[n]=true;
					}
				}
		}
	}
	static void DFS(int v,boolean visited[],HashMap<String,Integer>h)
	{
		visited[v]=true;
		Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext())
        {
            int n = i.next();
            System.out.println(n);
            if(visited[n]==false)
            {
            	
            	if(n<=v)
            		ans+=h.get(n+" "+v);
            	else
            		ans+=h.get(v+" "+n);
            	//System.out.println("AYAYA "+ans);
            	visited[n]=true;
                DFS(n,visited,h);
            }
        }
        //return ans;
	}
}