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.text.DecimalFormat;
import java.util.*;
import java.io.*;
import java.math.*;

public class Main {
	public static long mod = (long) (1e9 + 7);
	static InputReader s;
	static PrintWriter out;
	static int n,a[][];
	public static void main(String args[]) {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					solve();
					out.flush();
					out.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, "1", 1 << 26).start();
	}

	public static void solve() throws IOException {
		s = new InputReader(System.in);
		OutputStream outputStream = System.out;
		out = new PrintWriter(outputStream);
		Scanner sc = new Scanner(System.in);
		int k = s.nextInt();
		char a[] = s.next().toCharArray();
		Arrays.sort(a);
		int sum = 0;
		int n = a.length;
		for(int i=0;i<n;i++){
			sum+= a[i] - '0';
		}
		int diff = k - sum;
		int ans=0;
		for(int i=0;i<n;i++){
			if(diff<=0)
				break;
			diff-= 9 - (a[i] - '0');
			ans++;	
		}
		System.out.println(ans);
	}
	
	static long combinations(long n, long r) { // O(r)
		if (r == 0 || r == n)
			return 1;
		r = Math.min(r, n - r);
		long ans = n; // nC1=n;
		for (int i = 1; i < r; i++) {
			ans = (ans * (n - i));
			 ans= ans/(i+1);
//			ans = (ans * modulo(i + 1, mod - 2, mod)) % mod;
		}
		return ans;
	}

	static long modulo(long x, long y, long p) {
		long res = 1;
		x = x % p;

		while (y > 0) {
			if (y % 2 == 1)
				res = (res * x) % p;

			y = y >> 1;
			x = (x * x) % p;
		}
		return res;
	}

	static HashMap<Integer,Integer> primeFactors(int n) // O(sqrt(n))
	{
		// Print the number of 2s that divide n
		HashMap<Integer,Integer> hm = new HashMap<>();
		while (n % 2 == 0) {
			if(hm.containsKey(2))
				hm.put(2, hm.get(2)+1);
			else
				hm.put(2, 1);
			n = n / 2;
		}

		// n must be odd at this point. So we can skip one element (Note i = i
		// +2)
		for (int i = 3; i <= Math.sqrt(n); i = i + 2) {
			// While i divides n, print i and divide n
			while (n % i == 0) {
				if(hm.containsKey(i))
					hm.put(i, hm.get(i)+1);
				else
					hm.put(i, 1);
				n = n / i;
			}
		}
		// This condition is to handle the case when n is a prime number
		// greater than 2
		if (n > 2)
			hm.put(n, 1);

		return hm;
	}

	public static long expo(long a, long b) {
		if (b == 0)
			return 1;
		if (b == 1)
			return a;
		if (b == 2)
			return a * a;

		if (b % 2 == 0) {
			return expo(expo(a, (b / 2)), 2);
		} else {
			return a * expo(expo(a, (b - 1) / 2), 2);
		}
	}
	
	static class Pair implements Comparable<Pair> {
		int a;
		int b;
		
		Pair(int aa, int bb) {
			a = aa;
			b = bb;
		}

		public int compareTo(Pair o) {
			return Integer.compare(this.a, o.a);
			
			// return ans==0 ? -Integer.compare(this.b, o.b):ans;
			// if(Long.compare(this.x, o.x)!=0)
			// return -Long.compare(this.x, o.x);
			// else
			// return Long.compare(this.y, o.y);
			// return Integer.compare(this.x, o.x);
			// return Long.compare(this.x, o.x);
		}

//		public int hashCode() {
//			int hu = (int) (a ^ (a >>> 32));
//			int hv = (int) (b ^ (b >>> 32));
//			return 31 * hu + hv;
//		}

		//
		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return a == other.a && b == other.b;
		}

		public String toString() {
			return "[x=" + a + ", y=" + b + "]";
		}

	}

	public static int[] sieve(int N) { // O(n*log(logn))
		int arr[] = new int[N + 1];
		for (int i = 2; i <= Math.sqrt(N); i++) {
			if (arr[i] == 0) {
				for (int j = i * i; j <= N; j = j + i) {
					arr[j] = 1;
				}
			}
		}
		return arr;
		// All the i for which arr[i]==0 are prime numbers.
	}

	static int gcd(int a, int b) { // O(logn)
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	public static void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}

	static void catalan_numbers(int n) {
		long catalan[] = new long[n + 1];
		catalan[1] = 1;
		for (int i = 2; i <= n; i++) {
			for (int j = 1; j <= i - 1; j++) {
				catalan[i] = catalan[i] + ((catalan[j]) * catalan[i - j]);
			}
		}
	}

	static final class InputReader {
		private final InputStream stream;
		private final byte[] buf = new byte[1024];
		private int curChar;
		private int Chars;

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

		private int read() throws IOException {
			if (curChar >= Chars) {
				curChar = 0;
				Chars = stream.read(buf);
				if (Chars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public final int nextInt() throws IOException {
			return (int) nextLong();
		}

		public final long nextLong() throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
				if (c == -1)
					throw new IOException();
			}
			boolean negative = false;
			if (c == '-') {
				negative = true;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += (c - '0');
				c = read();
			} while (!isSpaceChar(c));
			return negative ? (-res) : (res);
		}

		public final int[] nextIntBrray(int size) throws IOException {
			int[] arr = new int[size];
			for (int i = 0; i < size; i++)
				arr[i] = nextInt();
			return arr;
		}

		public final String next() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public final String nextLine() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (c != '\n' && c != -1);
			return res.toString();
		}

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