Some natural number was written on the board. Its sum of digits was not less than k. But you were distracted a bit, and someone changed this number to n, replacing some digits with others. It's known that the length of the number didn't change.

You have to find the minimum number of digits in which these two numbers can differ.

Input

The first line contains integer k (1 ≤ k ≤ 109).

The second line contains integer n (1 ≤ n < 10100000).

There are no leading zeros in n. It's guaranteed that this situation is possible.

Output

Print the minimum number of digits in which the initial number and n can differ.

Examples

Input

3
11


Output

1


Input

3
99


Output

0

Note

In the first example, the initial number could be 12.

In the second example the sum of the digits of n is not less than k. The initial number could be equal to n.
import java.io.*;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;

import javax.management.relation.RelationServiceNotRegisteredException;


public class hehehe {

	static int count=0;
	static int flag=0;
	static double eps=(double)1e-6;
	static long mod=(long)1e9+7;
	static int maxcount=0;
	static int index=0;
	static int fac[]=new int[10];
	static int end_time[]=new int[100001];
	static int bit[]=new int[100001];
	static int vis_time[]=new int[100001];
	static int flat_tree[]=new int[200001];
	static ArrayList<ArrayList<Integer>> tree=new ArrayList<>();
	static ArrayList<ArrayList<Integer>> table=new ArrayList<>();
	static int traverser[]=new int[100001];
	static int par[]=new int[100001];
	static boolean vis[]=new boolean[100001];
	static int tim = 0;

	//li, ri and index are stored in queries vector
	//in that order, as the sort function will use
	//the value li for comparison
	static ArrayList< pair1 > queries=new ArrayList<>();

	//ans[i] stores answer to ith query
	static int ans[]=new int[100001];
	static HashSet<String> hm;

	public static void main(String args[]){
		InputReader in = new InputReader(System.in);
		OutputStream outputStream = System.out;
		PrintWriter out = new PrintWriter(outputStream);
		Scanner sc=new Scanner(System.in);
		//----------My Code----------
		int k=in.nextInt();
		String s=in.nextLine();
		int sum=0;
		int a[]=new int[10];
		for(int i=0;i<s.length();i++){
			sum+=s.charAt(i)-'0';
			a[s.charAt(i)-'0']++;
		}
		int ans=0;
		if(sum<k){
			int diff=k-sum;
			for(int i=0;i<=9;i++){
			while(diff!=0&&a[i]!=0){
				int val=diff/(Math.min(9, diff+i)-i);
				ans+=Math.min(a[i], val);
				diff-=(Math.min(9, diff+i)-i)*Math.min(a[i], val);
				a[i]-=Math.min(a[i], val);
			}
			
			
			}
			System.out.println(ans);
		}
		else{
			System.out.println(0);
		}
		
		
		
		
		
		//-- -------------The End----------------- 	-
		out.close();
	}
	
	static int rec(String ans,int length){
		if(length<=2){
			return 0;
		}
		else{
			
			int flag=0;
		char start=ans.charAt(0);
		for(int i=1;i<ans.length()-1;i++){
       	 if(start=='0'&&ans.charAt(i+1)=='0'){
                if(ans.charAt(i)=='0'){
                    flag=1;
                  //  System.out.println(ans.substring(0, i)+ans.substring(i+1));
                   count=count^rec(ans.substring(0, i)+ans.substring(i+1),ans.length()-1);
                }
                else if (ans.charAt(i)=='1'){
                     flag=1;
                   //  System.out.println(ans.substring(0, i)+ans.substring(i+1));
                	 count=count^rec(ans.substring(0, i)+ans.substring(i+1),ans.length()-1);
                 
                }
               
            }
       	 start=ans.charAt(i);
        }
		if(flag==0)
			return count^1;
		return count;
		}	
	}
	
	static int recursiveBinarySearch(int[] sortedArray, int start, int end, int key) {

		while (start < end) {
			int mid = start + (end - start) / 2; 
			if (key < sortedArray[mid]) {
				end=mid-1;

			} else if (key >=sortedArray[mid]) {
				start=mid+1;
			}
		}
		return (start); 
	}

	static long modulo(long a,long b,long c) {
		long x=1;
		long y=a;
		while(b > 0){
			if(b%2 == 1){
				x=(x*y)%c;
			}

			y = (y*y)%c; // squaring the base
			b /= 2;
		}
		return  x%c;
	}


	static long gcd(long x, long y)

	{
		if(x==0||y==0)
			return 0;
		long r=0, a, b;
		a = (x > y) ? x : y; // a is greater number
		b = (x < y) ? x : y; // b is smaller number
		r = b;
		while(a % b != 0)
		{
			r = a % b;
			a = b;
			b = r;
		}
		return r;
	}
	static class Pair implements Comparable<Pair> {
		int x;
		int y;
		//int i;
		Pair(int  xx,int yy){

			x=xx;
			y=yy;
			//i=ii;
		}
		@Override
		public int compareTo(Pair arg0) {

			return Integer.compare(10*x+y,10*y+x);


		}

	}
	static class pair1 implements Comparable<pair1>{
		Pair p;
		int x;
		pair1(Pair p,int x){
			this.p=p;
			this.x=x;
		}
		public int compareTo(pair1 arg0) {



			return Integer.compare(p.x, arg0.p.x);


		}

	}
	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());
		}
	}
} 