You have unlimited number of coins with values 1, 2, …, n. You want to select some set of coins having the total value of S. 

It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum S?

Input

The only line of the input contains two integers n and S (1 ≤ n ≤ 100 000, 1 ≤ S ≤ 10^9)

Output

Print exactly one integer — the minimum number of coins required to obtain sum S.

Examples

Input

5 11


Output

3

Input

6 16


Output

3

Note

In the first example, some of the possible ways to get sum 11 with 3 coins are: 

  * (3, 4, 4)
  * (2, 4, 5)
  * (1, 5, 5)
  * (3, 3, 5) 



It is impossible to get sum 11 with less than 3 coins.

In the second example, some of the possible ways to get sum 16 with 3 coins are: 

  * (5, 5, 6)
  * (4, 6, 6) 



It is impossible to get sum 16 with less than 3 coins.
import java.io.*;
import java.util.*;
import java.math.*;

public class Main {
	static final Random random = new Random();
	static PrintWriter out = new PrintWriter((System.out));
	static Reader sc = new Reader();

	public static void main(String args[]) throws IOException {
//		int t = sc.nextInt();
//		while (t-- > 0) {
//        	CODE START FROM HERE 
		int   n = sc.nextInt();
		int sum = sc.nextInt();
		boolean flag  = true;
		if(n==sum)
		{
			System.out.println(1);
		flag = false;
		}
		if(flag)
		{
			System.out.println(ceil(sum,n));
		}
            
//		}
            	
	}

// Fast Input Output
	static class Reader {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");

		public String next() {
			while (!st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		public String nextLine() {
			try {
				return br.readLine();
			} catch (Exception e) {
				e.printStackTrace();
			}
			return null;
		}

		public boolean hasNext() {
			String next = null;
			try {
				next = br.readLine();
			} catch (Exception e) {
			}
			if (next == null) {
				return false;
			}
			st = new StringTokenizer(next);
			return true;
		}

	}

	// EFFICIENT SORTING Ascending
	static void ruffleSortAsc(Integer[] a) {
		int n = a.length; // shuffle, then sort
		for (int i = 0; i < n; i++) {
			int oi = random.nextInt(n), temp = a[oi];
			a[oi] = a[i];
			a[i] = temp;
		}
		Arrays.sort(a);
	}

//	EFFICIENT SORTING Descending
	static void ruffleSortDesc(Integer[] a) {
		int n = a.length; // shuffle, then sort
		for (int i = 0; i < n; i++) {
			int oi = random.nextInt(n), temp = a[oi];
			a[oi] = a[i];
			a[i] = temp;
		}
		Arrays.sort(a, Collections.reverseOrder());
	}

	// Array Sum
	static long sum(Integer[] arr) {
		long sum = 0;
		for (int i : arr)
			sum += i;
		return sum;
	}

	// ArrayList Sum
	static long sumal(ArrayList<Integer> al) {
		long sum = 0;
		for (int i : al)
			sum += i;
		return sum;
	}

	// swap array elements
	static void swap(int arr1[], int arr2[], int i, int j) {
		int temp = arr1[i];
		arr1[i] = arr2[j];
		arr2[j] = temp;
	}

	// reading array value;
	static void read(Integer[] arr) {
		for (int i = 1; i < arr.length; i++)
			arr[i] = sc.nextInt();
		return;
	}

//    reading arraylistValue

	static void readal(ArrayList<Integer> al, int n) {
		for (int i = 0; i < n; i++)
			al.add(sc.nextInt());
		return;
	}

	// check for even odd
	static boolean isEven(long n) {
		return ((n & 1) != 1);
	}

	// max in a array
	static int max(Integer[] arr) {
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++)
			if (max < arr[i])
				max = arr[i];
		return max;
	}

//  print array
	static void printarr(Integer arr[]) {
		for (int i : arr)
			System.out.println(i);
	}

// ceil of two elements
	static int ceil(int a, int b) {
		return (int) Math.ceil(((double) a / (double) b));
	}

// floor of two elements
	static long floor(int a, int b) {
		return (long) Math.floor(((double) a / (double) b));
	}

}