You are given a string s, consisting of small Latin letters. Let's denote the length of the string as |s|. The characters in the string are numbered starting from 1. 

Your task is to find out if it is possible to rearrange characters in string s so that for any prime number p ≤ |s| and for any integer i ranging from 1 to |s| / p (inclusive) the following condition was fulfilled sp = sp × i. If the answer is positive, find one way to rearrange the characters.

Input

The only line contains the initial string s, consisting of small Latin letters (1 ≤ |s| ≤ 1000).

Output

If it is possible to rearrange the characters in the string so that the above-mentioned conditions were fulfilled, then print in the first line "YES" (without the quotes) and print on the second line one of the possible resulting strings. If such permutation is impossible to perform, then print the single string "NO".

Examples

Input

abc


Output

YES
abc


Input

abcd


Output

NO


Input

xxxyxxx


Output

YES
xxxxxxy

Note

In the first sample any of the six possible strings will do: "abc", "acb", "bac", "bca", "cab" or "cba".

In the second sample no letter permutation will satisfy the condition at p = 2 (s2 = s4).

In the third test any string where character "y" doesn't occupy positions 2, 3, 4, 6 will be valid.

import java.util.*;
import java.io.*;

/**
 *
 * @author usquare
 */

public class Problem {
    
    static int mod = (int) (1e9+7);
    static InputReader in;
    static PrintWriter out;
    static int[] rt = new int[1001];
    static int[] size = new int[1001];
            
    static void initialize(){
        for(int i=0;i<rt.length;i++){
            rt[i]=i;
            size[i]=1;
        }
    }
    
    static int root(int x){
        while(rt[x]!=x){
            rt[x]=rt[rt[x]];
            x=rt[x];
        }
        return x;
    }
    
    static void union(int x,int y){
        int root_x = root(x);
        int root_y = root(y);
        if(root_x==root_y) return;
        
        if(size[root_x]<size[root_y]){
            rt[root_x]=rt[root_y];
            size[root_y]+=size[root_x];
        }
        else{
            rt[root_y]=rt[root_x];
            size[root_x]+=size[root_y];            
        }
    }
    
    public static void main(String[] args) throws FileNotFoundException {
 
        in = new InputReader(System.in);
        out = new PrintWriter(System.out);            
        
        initialize();
        String s=in.readString();
        int n=s.length();
        boolean[] vis=new boolean[n+1];
        
        for(int i=2;i<=n;i++){
            if(!vis[i]){
                for(int j=2*i;j<=n;j+=i){
                    union(i, j);
                    vis[j]=true;
                }
            }
        }
        ArrayList<Pair> list=new ArrayList<>();
        for(int i=1;i<=n;i++)
            if(root(i)==i) list.add(new Pair(size[i],i));
        
        boolean ok=true;
        int[] a=new int[26];
        for(int i=0;i<n;i++){
            a[(int)(s.charAt(i)-'a')]++;
        }
        
        PriorityQueue<Pair> pq=new PriorityQueue<>(new Comparator() {
            @Override
            public int compare(Object t, Object t1) {
                Pair p1=(Pair) t;
                Pair p2=(Pair) t1;
                return Integer.compare(p1.x, p2.x);
            }
        });
        
        for(int i=0;i<26;i++)
            pq.add(new Pair(-a[i], (char)('a'+i)));

        Collections.sort(list);
        char[] b=new char[n+1];
        
        for(int i=list.size()-1;i>=0;i--){
            if(-pq.peek().x<list.get(i).x){
                ok=false;
                break;
            }
            else{
                Pair p=pq.poll();
                b[list.get(i).y]=p.c;
                int x=p.x+list.get(i).x;
                pq.add(new Pair(x, p.c));
            }
        }
        
        if(ok){
            out.println("YES");
            StringBuilder str=new StringBuilder();
            for(int i=1;i<=n;i++)
                str.append(b[root(i)]);
            out.println(str.toString());
        }
        else
            out.println("NO");
        out.close();
    }
    
    
   static class Pair implements Comparable<Pair>{

        int x,i,y;
        char c;
        Pair (int x,char c){
		this.x=x;
                this.c=c;
	}

        Pair (int x,int y){
		this.x=x;
                this.y=y;
	}
        
        Pair (int x,int y,int i){
		this.x=x;
                this.y=y;
                this.i=i;
	}
        
	public int compareTo(Pair o) {
            return Integer.compare(this.x,o.x);
		//return 0;
	}

            public boolean equals(Object o) {
            if (o instanceof Pair) {
                Pair p = (Pair)o;
                return p.x == x && p.y == y && p.i==i;
            }
            return false;
        }

        @Override
        public String toString() {
            return x+" "+y+" "+c;
        }
        
    } 
    
    static class Merge {
        
        public static void sort(int inputArr[]) {
            int length = inputArr.length;
            doMergeSort(inputArr,0, length - 1);
        }
        
        private static void doMergeSort(int[] arr,int lowerIndex, int higherIndex) {        
            if (lowerIndex < higherIndex) {
                int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
                doMergeSort(arr,lowerIndex, middle);
                doMergeSort(arr,middle + 1, higherIndex);
                mergeParts(arr,lowerIndex, middle, higherIndex);
            }
        }
        
        private static void mergeParts(int[]array,int lowerIndex, int middle, int higherIndex) {
            int[] temp=new int[higherIndex-lowerIndex+1];
            for (int i = lowerIndex; i <= higherIndex; i++) {
                temp[i-lowerIndex] = array[i];
            }
            int i = lowerIndex;
            int j = middle + 1;
            int k = lowerIndex;
            while (i <= middle && j <= higherIndex) {
                if (temp[i-lowerIndex] < temp[j-lowerIndex]) {
                    array[k] = temp[i-lowerIndex];
                    i++;
                } else {
                    array[k] = temp[j-lowerIndex];
                    j++;
                }
                k++;
            }
            while (i <= middle) {
                array[k] = temp[i-lowerIndex];
                k++;
                i++;
            }
            while(j<=higherIndex){
                array[k]=temp[j-lowerIndex];
                k++;
                j++;
            }
        }

    }
    
    static long add(long a,long b){
        long x=(a+b);
        while(x>=mod) x-=mod;
        return x;
    }

    static long sub(long a,long b){
        long x=(a-b);
        while(x<0) x+=mod;
        return x;
    }
    
    static long mul(long a,long b){
        a%=mod;
        b%=mod;
        long x=(a*b);
        return x%mod;
    }

    
    static boolean isPal(String s){
        for(int i=0, j=s.length()-1;i<=j;i++,j--){
                if(s.charAt(i)!=s.charAt(j)) return false;
        }
        return true;
    }
    static String rev(String s){
		StringBuilder sb=new StringBuilder(s);
		sb.reverse();
		return sb.toString();
    }
    
    static long gcd(long x,long y){
	if(x%y==0)
		return y;
	else
		return gcd(y,x%y);
    }
    
    static int gcd(int x,int y){
	if(x%y==0)
		return y;
	else 
		return gcd(y,x%y);
    }
    
    static long gcdExtended(long a,long b,long[] x){
        
        if(a==0){
            x[0]=0;
            x[1]=1;
            return b;
        }
        long[] y=new long[2];
        long gcd=gcdExtended(b%a, a, y);
        
        x[0]=y[1]-(b/a)*y[0];
        x[1]=y[0];
        
        return gcd;
    }
    

    static long mulmod(long  a,long b,long m) {
        if (m <= 1000000009) return a * b % m;
 
        long res = 0;
        while (a > 0) {
            if ((a&1)!=0) {
                res += b;
                if (res >= m) res -= m;
            }
            a >>= 1;
            b <<= 1;
            if (b >= m) b -= m;
        }
        return res;
    }
    
    static int abs(int a,int b){
	return (int)Math.abs(a-b);
    }

    public static long abs(long a,long b){
	return (long)Math.abs(a-b);
    }
    
    static int max(int a,int b){
	if(a>b)
		return a;
	else
		return b;
    }

    static int min(int a,int b){
	if(a>b)
		return b;
	else 
		return a;
    }
    
    static long max(long a,long b){
	if(a>b)
		return a;
	else
		return b;
    }

    static long min(long a,long b){
	if(a>b)
		return b;
	else 
		return a;
    }

    static long pow(long n,long p,long m){
	 long  result = 1;
	  if(p==0)
	    return 1;
          
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
    }
    
    static long pow(long n,long p){
	long  result = 1;
	  if(p==0)
	    return 1;
          
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;	    
	    p >>=1;
	    n*=n;	    
	}
	return result;
    }
    
    static void debug(Object... o) {
            System.out.println(Arrays.deepToString(o));
    }
     
    static class InputReader {
    
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
                this.stream = stream;
        }

        public int snext() {
                if (snumChars == -1)
                        throw new InputMismatchException();
                if (curChar >= snumChars) {
                        curChar = 0;
                        try {
                                snumChars = stream.read(buf);
                        } catch (IOException e) {
                                throw new InputMismatchException();
                        }
                        if (snumChars <= 0)
                                return -1;
                }
                return buf[curChar++];
        }

        public int ni() {
                int c = snext();
                while (isSpaceChar(c)) {
                        c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = snext();
                }
                int res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public long nl() {
                int c = snext();
                while (isSpaceChar(c)) {
                        c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                        sgn = -1;
                        c = snext();
                }
                long res = 0;
                do {
                        if (c < '0' || c > '9')
                                throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
        }

        public int[] nextIntArray(int n) {
                int a[] = new int[n];
                for (int i = 0; i < n; i++) {
                        a[i] = ni();
                }
                return a;
        }

        public long[] nextLongArray(int n) {
                long a[] = new long[n];
                for (int i = 0; i < n; i++) {
                        a[i] = nl();
                }
                return a;
        }

        public String readString() {
                int c = snext();
                while (isSpaceChar(c)) {
                        c = snext();
                }
                StringBuilder res = new StringBuilder();
                do {
                        res.appendCodePoint(c);
                        c = snext();
                } while (!isSpaceChar(c));
                return res.toString();
        }

        public String nextLine() {
                int c = snext();
                while (isSpaceChar(c))
                        c = snext();
                StringBuilder res = new StringBuilder();
                do {
                        res.appendCodePoint(c);
                        c = snext();
                } while (!isEndOfLine(c));
                return res.toString();
        }

        public boolean isSpaceChar(int c) {
                if (filter != null)
                        return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
                return c == '\n' || c == '\r' || c == -1;
        }

        public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
        }
        
    }
}    

