You are given a string s consisting of lowercase Latin letters. Character c is called k-dominant iff each substring of s with length at least k contains this character c.

You have to find minimum k such that there exists at least one k-dominant character.

Input

The first line contains string s consisting of lowercase Latin letters (1 ≤ |s| ≤ 100000).

Output

Print one number — the minimum value of k such that there exists at least one k-dominant character.

Examples

Input

abacaba


Output

2


Input

zzzzz


Output

1


Input

abcde


Output

3
// package com.company;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.sql.SQLOutput;
import java.util.*;
public class Main {

    public static void main(String[] args) throws IOException {
        Scanner s = new Scanner(System.in);
        //BufferedReader s=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb1 = new StringBuilder();//int n=Integer.parseInt(s.readLine());
      int[] lp=new int[123];
      for(int i=97;i<123;i++){
          lp[i]=-1;
      }int[] max=new int[123];
      char[] a=s.next().toCharArray();
      for(int i=0;i<a.length;i++){
          if(lp[a[i]]!=-1){
              max[a[i]]=Math.max(max[a[i]],i-lp[a[i]]);
              lp[a[i]]=i;
          }else{
              max[a[i]]=i+1;lp[a[i]]=i;
          }
      }int ans=Integer.MAX_VALUE;
      for(int i=97;i<123;i++){
          max[i]=Math.max(max[i],a.length-lp[i]);
      }
      for(int i=97;i<123;i++){
          if(max[i]!=00)ans=Math.min(ans,max[i]);
      }
        System.out.println(ans);
   }



    static int ans1=Integer.MAX_VALUE;static int[] vis;
    static   int[] dp;static Queue<Integer>q;
    static void newdfs(int i1,char[][] a,int k,int n,int val){
        while(!q.isEmpty()){
            int i=q.poll();
            vis[i]=1;

            for(int j=i;j<=Math.min(n-1,i+k);j++){
                if(a[i][j]=='1'&&(vis[j]==0)&&dp[i]+1<dp[j]){
                    dp[j]=dp[i]+1;
                    q.add(j);
                }
            }for(int j=i;j>=Math.max(0,i-k);j--){
                if(a[i][j]=='1'&&(vis[j]==0)&&dp[j]+1<dp[i]){
                    dp[j]=dp[i]+1;
                    q.add(j);
                }
            }}
    }
    static  void computeLPSArray(String pat, int M, int lps[])
    {
        int len = 0;
        int i = 1;
        lps[0] = 0;
        while (i < M) {
            if (pat.charAt(i) == pat.charAt(len)) {
                len++;
                lps[i] = len;
                i++;
            }
            else // (pat[i] != pat[len])
            {
                if (len != 0) {
                    len = lps[len - 1];
                }
                else // if (len == 0)
                {
                    lps[i] = len;
                    i++;
                }
            }
        }
    }
    static boolean isPrime(int n)
    {
        // Corner cas
        if (n <= 1) return false;
        if (n <= 3) return true;

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n % 2 == 0 || n % 3 == 0) return false;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;

        return true;
    }
    static boolean isPrime(int n, int k)
    {
        // Corner cases
        if (n <= 1 || n == 4) return false;
        if (n <= 3) return true;

        // Try k times
        while (k > 0)
        {
            // Pick a random number in [2..n-2]
            // Above corner cases make sure that n > 4
            int a = 2 + (int)(Math.random() % (n - 4));

            // Fermat's little theorem
            if (power(a, n - 1, n) != 1)
                return false;

            k--;
        }

        return true;
    }
    static double power(double x, long y, int p) {
        double res = 1;
        x = x % p;
        while (y > 0) {
            if ((y & 1) == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }
    public static void fracion(double x) {
        String a = "" + x;
        String spilts[] = a.split("\\."); // split using decimal
        int b = spilts[1].length(); // find the decimal length
        int denominator = (int) Math.pow(10, b); // calculate the denominator
        int numerator = (int) (x * denominator); // calculate the nerumrator Ex
        // 1.2*10 = 12
        int gcd = (int)gcd((long)numerator, denominator); // Find the greatest common
        // divisor bw them
        String fraction = "" + numerator / gcd + "/" + denominator / gcd;
        // System.out.println((denominator/gcd));
        long x1=modInverse(denominator / gcd,998244353  );
        //  System.out.println(x1);
        System.out.println((((numerator / gcd )%998244353 *(x1%998244353  ))%998244353  ) );
    }static int max=Integer.MIN_VALUE;
    static int max1=Integer.MIN_VALUE;static int[][] c;static int k=1;static int bhoo=0;
    static int[] car;static int ans;static HashMap<Integer,Integer>[] ha;
    public static void dfs(int ans2,int papa, int i, ArrayList<Integer>[] h, int[] vis,HashMap<Integer,Integer>[] bad) {
        vis[i] = 1;
        if(i!=1&&h[i].size()==1){
            if(ans2!=-1)  {ans++;  sb1.append(ans2+" ");}
        }
        if(h[i]==null) return;
        int hu=0;int hai=0;
        for(Integer j:h[i]){
            if(vis[j]==0&&bad[i].containsKey(j)) {
                hai=1;break;
            }
        }int khi=0;
        for(Integer j:h[i]) {//if(vis[j]==0) flag=1;
            if(vis[j]==0){
                if(!bad[i].containsKey(j)){
                    if(hai==0&&khi==0){khi=1;    dfs(ans2,papa,j,h,vis,bad);}
                    else dfs(-1,papa,j,h,vis,bad);
                }else{
                    if(hu==0){
                        if(papa==0){//ans++;//sb1.append(j+" ");
                            dfs(j,1,j,h,vis,bad);
                        }else{
                            hu=1;
                            dfs( j,1,j,h,vis,bad);}
                    }else{
                        //    ans++;//sb1.append(j+" ");
                        dfs(j,1,j,h,vis,bad);
                    }
                }
            }
        }//if(flag==1) bhoo=-1;
    }static StringBuilder sb1=new StringBuilder();
    public static void bfs(int i, HashMap<Integer, Integer>[] h, int[] vis, int len, int papa) {
        Queue<Integer> q = new LinkedList<Integer>();
        q.add(i);
    }
    static int i(String a) {
        return Integer.parseInt(a);
    }
    static long l(String a) {
        return Long.parseLong(a);
    }
    static String[] inp() throws IOException {
        BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
        return s.readLine().trim().split("\\s+");
    }


    static long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
    static long modInverse(int a, int m)
    {


        {
            // If a and m are relatively prime, then modulo inverse
            // is a^(m-2) mode m
            return (power(a, m - 2, m));
        }
    }

    // To compute x^y under modulo m
    static long power(int x, int y, int m)
    {
        if (y == 0)
            return 1;

        long p = power(x, y / 2, m) % m;
        p = (p * p) % m;

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }

    // Function to return gcd of a and b

}
class Student
{
    int l;int r;int i;
    public Student(int l, int r,int i) {
        this.l = l;
        this.r = r;this.i=i;
    }
    // Constructor


    // Used to print student details in main()
    public String toString()
    {
        return this.l+" ";
    }
}

class Sortbyroll implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student a, Student b){
        return a.l-b.l;  }
} class Sortbyroll1 implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student a, Student b){
        return a.l-b.l;
    }
}