codeparrot/codecomplex huggingface dataset:
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class Edu23 {

	public static int sum(String s){
		int tot=0;
		for(int i =0; i<s.length();i++){
			tot+=(s.charAt(i)-'0');
		}
		return tot;
	}
	public static BigInteger comb(int n, int k){
		if(k==0)
			return new BigInteger("1");
		else
			return comb(n,k-1).multiply(new BigInteger(n-k+1+"")).divide(new BigInteger(k+""));
	}
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		long s = sc.nextLong();
		long i;
		for(i =s ; i-sum(i+"")<s;i++)
			if(i%10==0)i+=9;
		System.out.println(Math.max(0, n-i+1));
		
	}
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(String f) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(f));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

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

		public int[] nextIntArray1(int n) throws IOException {
			int[] a = new int[n + 1];
			for (int i = 1; i <= n; i++)
				a[i] = nextInt();
			return a;
		}

		public int[] shuffle(int[] a, int n) {
			int[] b = new int[n];
			for (int i = 0; i < n; i++)
				b[i] = a[i];
			Random r = new Random();
			for (int i = 0; i < n; i++) {
				int j = i + r.nextInt(n - i);
				int t = b[i];
				b[i] = b[j];
				b[j] = t;
			}
			return b;
		}

		public int[] nextIntArraySorted(int n) throws IOException {
			int[] a = nextIntArray(n);
			a = shuffle(a, n);
			Arrays.sort(a);
			return a;
		}

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

		public long[] nextLongArray1(int n) throws IOException {
			long[] a = new long[n + 1];
			for (int i = 1; i <= n; i++)
				a[i] = nextLong();
			return a;
		}

		public long[] nextLongArraySorted(int n) throws IOException {
			long[] a = nextLongArray(n);
			Random r = new Random();
			for (int i = 0; i < n; i++) {
				int j = i + r.nextInt(n - i);
				long t = a[i];
				a[i] = a[j];
				a[j] = t;
			}
			Arrays.sort(a);
			return a;
		}
	}
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn

import java.util.Scanner;

/**
 * 
 * 作者：张宇翔 创建日期：2017年6月16日 上午9:00:48 描述：写字楼里写字间，写字间里程序员； 程序人员写程序，又拿程序换酒钱。
 * 酒醒只在网上坐，酒醉还来网下眠； 酒醉酒醒日复日，网上网下年复年。 但愿老死电脑间，不愿鞠躬老板前； 奔驰宝马贵者趣，公交自行程序员。
 * 别人笑我忒疯癫，我笑自己命太贱； 不见满街漂亮妹，哪个归得程序员？
 */

public class Main {

	private final static int Max = (int) (1e5 + 10);
	private static long n,s;

	public static void main(String[] args) {
		InitData();
		GetAns();
	}

	private static void InitData() {
		Scanner cin = new Scanner(System.in);
		n=cin.nextLong();
		s=cin.nextLong();
	};
	private static void GetAns() {
		long i;
		long ans=0;
		for(i=s;i<=n;i++){
			
			long k=i-sum(i);
			if(k>=s){
				if(i%10==9){
					break;
				}
				ans++;
			}
		}
		if(n>=s){
			System.out.println(ans-i+n+1);
		}else{
			System.out.println(0);
		}
	};
	private static long sum(long ans){
		long sum=0;
		while(ans>0){
			sum+=(ans%10);
			ans/=10;
		}
		return sum;
	}
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.util.Scanner;

public class C {
	
	public static void main(String[] args) {
		new C();
	}

	C() {
		
		Scanner in = new Scanner(System.in);
		
		long n = in.nextLong(), s = in.nextLong();
		long lo = 1, hi = 1000000000000000000L;
		
		while(lo<hi){
			//System.out.println(lo+" "+hi);
			//STUPID STUPID DUMB
			long mid = (lo+hi)/2;
			if(reallyBig(mid,s))
				hi = mid;
			else
				lo = mid+1;
		}
		
		//System.out.println(lo+" "+hi);
		if(!reallyBig(lo,s))
			System.out.println(0);
		else
			System.out.println(Math.max(n-lo+1,0));
			
		//System.out.println(reallyBig(100000000000000009L,100000000000000000L));

		in.close();

	}
	
	boolean reallyBig(long n, long s){
		int sum = 0;
		long temp = n;
		while(temp>0){
			sum += temp%10;
			temp/=10;
		}
		return n-sum>=s;
	}
	
}

/*

12 1

25 20

10 9

1000000000000000000 1000000000000000000

1000000000000000000 100000000000000000

 */
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.*;
import java.util.*;

/**
 * Road to 1600 raiting
 */
public class Main {
    static class Task {
        PrintWriter out;

        int[] num = new int[3];

        public void solve(MyScanner in, PrintWriter out) {
            this.out = out;

            long n = in.nextLong();
            long s = in.nextLong();

            long l = 1;

            long r = n;

            while (r - l > 5) {
                long x = (l + r) / 2;

                long ans = ans(x);

                if (ans >= s) {
                    r = x;
                } else {
                    l = x;
                }
            }

            for (long i = l; i <= r; i++) {
                if (ans(i) >= s) {
                    out.println((n - i + 1));
                    return;
                }
            }

            out.println(0);

        }

        long ans(long n) {
            long res = n;

            while (n > 9) {
                res -= n % 10;
                n /= 10;
            }

            res -= n;

            return res;
        }

    }

    public static void main(String[] args) {
        MyScanner in = new MyScanner();
        PrintWriter out = new PrintWriter(System.out);
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.util.Scanner;

public class Probram3 {

	public static int get(long n) {
		int sum = 0;
		while(n != 0) {
			sum += n % 10;
			n = n / 10;
		}
		return sum;
	}
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		long n = scanner.nextLong();
		long s = scanner.nextLong();
		long l = 1;
		long r = Long.MAX_VALUE;
		long index = 0;
		while(l <= r) {
			long mid = (l + r) / 2;
			if(mid - get(mid) >= s) {
				index = mid;
				r = mid - 1;
			}else{
				l = mid + 1;
			}
		}
		System.out.println(Math.max(0, n-index+1));
	}
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		long n = sc.nextLong();
		Long S = sc.nextLong();
		
		long l = 0;
		long h = n;
		
		long ans = n;
		
		while(l <= h) {
			long mid = (l + h) / 2;
			long t = mid;
			long sum = 0;
			
			while(t > 0) {
				sum += t % 10;
				t /= 10;
			}
			
			if(mid - sum < S) {
				ans = mid;
				l = mid + 1;
			}else
				h = mid - 1;
		}
		
		out.println(n - ans);

		out.flush();
		out.close();
	}



	static class Scanner 
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream System){br = new BufferedReader(new InputStreamReader(System));}
		public String next() throws IOException 
		{
			while (st == null || !st.hasMoreTokens()) 
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public String nextLine()throws IOException{return br.readLine();}
		public int nextInt() throws IOException {return Integer.parseInt(next());}
		public double nextDouble() throws IOException {return Double.parseDouble(next());}
		public char nextChar()throws IOException{return next().charAt(0);}
		public Long nextLong()throws IOException{return Long.parseLong(next());}
		public boolean ready() throws IOException{return br.ready();}
		public void waitForInput(){for(long i = 0; i < 3e9; i++);}
	}


}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.math.BigInteger;
import java.util.*;
public class C {
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long s = sc.nextLong();
        
        BigInteger k = findFirst(BigInteger.valueOf(s));
        if (BigInteger.valueOf(n).compareTo(k) >= 0)
        {
            System.out.println(n - k.longValue() + 1);
        }
        else
        {
            System.out.println("0");
        }
    }
    
    public static BigInteger findFirst(BigInteger s) // first number where sum of digs >= s
    {
        BigInteger b = BigInteger.ZERO;
        while (cd(b).compareTo(b.subtract(s)) > 0)
        {
            BigInteger c = BigInteger.ONE;
            while (cd(b.add(c)).compareTo(b.add(c).subtract(s)) > 0) {
                c = c.multiply(BigInteger.TEN);
            }
            // possibly overshot
            c = c.divide(BigInteger.TEN);
            if (c.compareTo(BigInteger.TEN) < 0) c = BigInteger.TEN; // always add at least 10
            b = b.add(c);
        }
        return b;
    }
    
    public static BigInteger cd(BigInteger n)
    {
        BigInteger t = BigInteger.ZERO;
        while (n.compareTo(BigInteger.ZERO) > 0)
        {
            t = t.add(n.mod(BigInteger.TEN));
            n = n.divide(BigInteger.TEN);
        }
        return t;
    }
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.util.Scanner;

public class ReallyBigNumbers {

	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		long s  = sc.nextLong();
		
		long m = s;
		
		while(m-digitAdd(m)<s && m<=n){
			m++;
		}
		System.out.println(Math.max(n-m+1, 0));
	}
	
	private static int digitAdd(long s){
		int sum = 0;
		
		for(long i = 0,j=1L;i<(int)Math.log10(s)+1; i++,j*=10){
			sum += (s/j)%10;
		}
		
		return sum;
	}

}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.util.Scanner;

public class Test {
	
	private static long sum(long value) {
		long ans = 0;
		while (value > 0) {
			ans += value % 10;
			value /= 10;
		}
		return ans;
	}
	
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		long n , s , ans = 0;
		n = scan.nextLong();
		s = scan.nextLong();
		long current = s;
		while (current <= n && current <= s + 20 * 9) {
			// current - sum(current) >= s
			long temp = sum(current);
			if (current - temp >= s) {
				ans ++;
			}
			current ++;
		}
		if (current <= n) {
			ans += (n - current + 1);
		}
		System.out.println(ans);
		
	}
	
		
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.*;
import java.util.*;

public class Main{
	public static void main(String[] args)throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		long n = Long.parseLong(st.nextToken());
		long s = Long.parseLong(st.nextToken());
		long posible = binarySearch(n,s);
		long dig, answer;
		long i, cmed;
		for (i = posible; i >= 0; i--) {
			dig = 0;
			cmed = i;
			while (cmed > 0) {
				dig = dig+cmed%10;
				cmed/=10;
			}
			if (i-dig < s) {
				break;
			}
		}
		answer = n-i;
		System.out.println(answer);
	}
	private static  long binarySearch(long n, long s){
		long med=n, l = 0, r = n, cmed, dig;
		while(l<=r){
			med = (l+r)/2;
			cmed = med;
			dig = 0;
			while (cmed > 0) {
				dig = dig+cmed%10;
				cmed/=10;
			}
			if (med-dig == s) {
				break;
			}else {
				if (med-dig > s) {
					r = med-1;
				}else {
					l = med+1;
				}
			}
			//System.out.println(med);
		}
		return med;
	}

}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.*;
import java.util.*;

public class ReallyBigNumbers817c {

    static long sd(String s) {
        long c = 0;
        for (int i = 0; i < s.length(); i++) {
            c += s.charAt(i);
        }
        return c - s.length() * 0x30;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(in.readLine());
        long n = Long.parseLong(st.nextToken());
        long s = Long.parseLong(st.nextToken());
        long i = (s / 10 + 1) * 10;
        if (n < 10 || n - sd(n + "") < s) {
            System.out.println(0);
            return;
        }
        while (!(i - sd(""+i) >= s)) {
            i += 10;
        }
        System.out.println(n - i + 1);
    }
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.math.BigDecimal;
import java.util.Scanner;

public class ReallyBigNumbers {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		long n = scan.nextLong();
		long s = scan.nextLong();
		long ans = 0;
		long l = 0;
        long r = n;
        while (l <= r) {
            // Key is in a[lo..hi] or not present.
            long mid = l + (r - l) / 2;
            if(isReallyBig(mid, s)){
            	ans = mid;
            	r = mid-1;
            }
            else l = mid+1;
        }
        if(ans == 0) System.out.println(ans);
        else
        	System.out.println(n-ans+1);
	}
	
	static boolean isReallyBig(long m, long s){
		String x = m+"";
		long sum = 0;
		for(int i = 0; i < x.length(); i++){
			sum += x.charAt(i)-'0';
		}
		if(m-sum >= s) return true;
		return false;
	}
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.io.*;

public class Main {
    boolean[] b;
    int[] r;
    ArrayList<ArrayList<Integer>> q;

    public void dfs(int u, int p) {
        for (int i = 0; i < q.get(u).size(); i++) {
            int v = q.get(u).get(i);
            if (v != p) {
                r[v] = r[u] + 1;
                if (b[u]) {
                    b[v] = b[u];
                }
                dfs(v, u);
            }
        }
    }

    public void solve() throws IOException {
        long n = nextLong();
        long s = nextLong();
        long t = 0;
        if(s + 200 < n){
            t = n - s - 200;
        }
        for(long i = s; i <= Math.min(s + 200,n); i++){
            long p = 0;
            long u = i;
            while (u > 0){
                p += u % 10;
                u /= 10;
            }
            if(i - p >= s){
                t++;
            }
        }
        out.print(t);
    }

    BufferedReader br;
    StringTokenizer sc;
    PrintWriter out;

    public String nextToken() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return sc.nextToken();
    }

    public Integer nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public Long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    public static void main(String[] args) throws IOException {
        try {
            Locale.setDefault(Locale.US);
        } catch (Exception e) {
        }
        new Main().run();
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
//            br = new BufferedReader(new FileReader("lesson.in"));
//            out = new PrintWriter(new File("lesson.out"));
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;

public class C817{

	void solve()
	{
		long n = nl(), s = nl();
		long l = 0, r = n;
		while(l < r)
		{
			long mid = (l + r)/2;
			if(mid - digSum(mid) < s)
				l = mid + 1;
			else
				r = mid;
		}
		out.println(l - digSum(l) >= s ? (n - l + 1) : 0);
	}
	
	int digSum(long k)
	{
		int sum = 0;
		while(k != 0)
		{
			sum += k % 10;
			k /= 10;
		}
		return sum;
	}
	
	public static void main(String[] args){new C817().run();}
	
	private byte[] bufferArray = new byte[1024];
	private int bufLength = 0;
	private int bufCurrent = 0;
	InputStream inputStream;
	PrintWriter out;
	
	public void run()
	{
		inputStream = System.in;
		out = new PrintWriter(System.out);
		solve();
		out.flush();
	}
	
	int nextByte()
	{
		if(bufLength==-1)
			throw new InputMismatchException();
		if(bufCurrent>=bufLength)
		{
			bufCurrent = 0;
			try
			{bufLength = inputStream.read(bufferArray);}
			catch(IOException e)
			{ throw new InputMismatchException();}
			if(bufLength<=0)
				return -1;
		}
		return bufferArray[bufCurrent++];
	}
	
	boolean isSpaceChar(int x)
	{return (x<33 || x>126);}
	
	boolean isDigit(int x)
	{return (x>='0' && x<='9');}
	
	int nextNonSpace()
	{
		int x;
		while((x=nextByte())!=-1 && isSpaceChar(x));
		return x;
	}
	
	int ni()
	{
		long ans = nl();
		if ( Integer.MIN_VALUE <= ans && ans <= Integer.MAX_VALUE )
			return (int)ans;
		throw new InputMismatchException();
	}
	
	long nl()
	{
		long ans = 0;
		boolean neg = false;
		int x = nextNonSpace();
		if(x=='-') 
		{
			neg = true;
			x = nextByte();
		}
		while(!isSpaceChar(x))
		{
			if(isDigit(x))
			{
				ans = ans*10 + x -'0';
				x = nextByte();
			}
			else
				throw new InputMismatchException();
		}
		return neg ? -ans:ans;
	}
	
	String ns()
	{
		StringBuilder sb = new StringBuilder();
		int x = nextNonSpace();
		while(!isSpaceChar(x))
		{
			sb.append((char)x);
			x = nextByte();
		}
		return sb.toString();
	}
	
	char nc()
	{ return (char)nextNonSpace();}
	
	double nd()
	{ return (double)Double.parseDouble(ns()); }
	
	char[] ca()
	{ return ns().toCharArray();}
	
	char[] ca(int n)
	{
		char[] ans = new char[n];
		int p =0;
		int x = nextNonSpace();
		while(p<n)
		{
			ans[p++] = (char)x;
			x = nextByte();
		}
		return ans;
	}
	
	int[] ia(int n)
	{
		int[] ans = new int[n];
		for(int i=0;i<n;i++)
			ans[i]=ni();
		return ans;
	}
	
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Ds {
	
	static long lim;
	
	public static void main(String[] args) throws NumberFormatException, IOException {

		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		
		String[] line = in.readLine().split("\\s+");
		
		long n = Long.parseLong(line[0]);
		
		lim = Long.parseLong(line[1]);
	
		
		long pos = -1;
		
		for(int i=61; i>=0; i--) {
			
			long shift = (long) Math.pow(2, i);
			
			if(pos + shift - sumOfDigits(pos + shift) < lim) {
				pos += shift;
			}
		}
		
		pos++;
		
		if(pos <= n && pos- sumOfDigits(pos) >= lim) {
			System.out.println(n - pos + 1);
		}
		else {
			System.out.println(0);
		}
		
	}

	private static long sumOfDigits(long d) {
		
		long sum = 0;
		long num = d;
		
		while(num != 0) {
			sum += (num%10);
			num /= 10;
		}
		
		return sum;
	}
}
// Problem: 817_C. Really Big Numbers
// Time complexity: logn
import java.io.*;
import java.util.*;

/**
 *
 * @author Jishnu_T
 */
public class ReallyBigNums {
    
    private static long[] factorArray(long s)
    {
        int d=0;
        long n=s;
        long f=1;
        while(n>0)
        {
            n=n/10;
            d++;
            f = f*10;
        }
        
        long[] fact = new long[d+1];
        n=s;
        for(int i=d;i>=0;i--)
        {
            if(f==1)
                fact[i] = n;
            else
            {
                fact[i] = n/(f-1);
                n = n%(f-1);
                f=f/10;
            }
        }
        int carry=0;
        for(int i=0;i<=d;i++)
        {
            fact[i] = fact[i]+carry;
            if(fact[i]>9 || (i==0 && fact[i]>0))
            {
                fact[i] = 0;
                carry = 1;
                for(int j=i-1;j>=0;j--)
                {
                    fact[j] =0;
                }
            }
            else
            {
                carry = 0;
            }
        }
        
        return fact;
    }
    
    private static long bigNumCount(long n, long s)
    {
        if(s>=n)
            return 0;
        if(s==0)
            return n;
        long[] fact = factorArray(s);
        
        long startNum = 0;
        int len = fact.length;
        long tenPow = 1;
        for(int i=0;i<len;i++)
        {
            startNum = startNum+tenPow*fact[i];
            tenPow = tenPow*10;
        }
        
        return(Math.max(0,n-startNum+1));
    }
    private static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static void main(String args[])
    {
        FastReader r = new FastReader();
        long n = r.nextLong();
        long s=  r.nextLong();
        System.out.println(bigNumCount(n,s));
    }
    
}