Problem:
Score : 400 points

Problem Statement

You are given integers N and M.

Consider a sequence a of length N consisting of positive integers such that a_1 + a_2 + ... + a_N = M. Find the maximum possible value of the greatest common divisor of a_1, a_2, ..., a_N.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

N \leq M \leq 10^9

Input

Input is given from Standard Input in the following format:

N M

Output

Print the maximum possible value of the greatest common divisor of a sequence a_1, a_2, ..., a_N that satisfies the condition.

Sample Input 1

3 14

Sample Output 1

2

Consider the sequence (a_1, a_2, a_3) = (2, 4, 8). Their greatest common divisor is 2, and this is the maximum value.

Sample Input 2

10 123

Sample Output 2

3

Sample Input 3

100000 1000000000

Sample Output 3

10000

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
*/public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
static class TaskD   {
public void solve(int testNumber, Scanner in, PrintWriter out) {
        int N = in.nextInt();
        int M = in.nextInt();
        int[] factor = factor(M);
        out.println(M/factor[binary_search(N, factor)]);
    }

public   static int[] factor(long n) {
        int[] ret = new int[(int)Math.sqrt(n) + 6];
        int pos = 0;
        for(int i = 1; i*i <= n; i++){
            if(n%i==0) ret[pos++] = i;
        }
        int max = pos;
        if(ret[max-1] == Math.sqrt(n)) max-=1;
        for(int i = max-1; i >= 0; i--){
            ret[pos++] = (int)(n/ret[i]);
        }
        return Arrays.copyOf(ret, pos);
    }

boolean isOK(int index, int key, int[] a) {
        if (a[index] >= key) return true;
        else return false;
    }

int binary_search(int key, int[] a) {
        int ng = -1;
        int ok = (int)a.length - 1;
        if(!isOK(ok, key, a)){
            return 1 << 29;
        }
        while (Math.abs(ok - ng) > 1) {
            int mid = (ok + ng) / 2;

            if (isOK(mid, key, a)) ok = mid;
            else ng = mid;
        }
        return ok;
    }

}
}