Problem: You are given two integers n and k. Find k-th smallest divisor of n, or report that it doesn't exist.

Divisor of n is any such natural number, that n can be divided by it without remainder.

Input

The first line contains two integers n and k (1 ≤ n ≤ 1015, 1 ≤ k ≤ 109).

Output

If n has less than k divisors, output -1.

Otherwise, output the k-th smallest divisor of n.

Examples

Input

4 2


Output

2


Input

5 3


Output

-1


Input

12 5


Output

6

Note

In the first example, number 4 has three divisors: 1, 2 and 4. The second one is 2.

In the second example, number 5 has only two divisors: 1 and 5. The third divisor doesn't exist, so the answer is -1.

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*; 
import java.nio.charset.Charset;
public class Main{
 
 public static void main(String[] args) {
  Charset charset = Charset.forName("ascii");
     FastIO rd = new FastIO(System.in, System.out, charset);
    
    ArrayList<Long> a= new ArrayList<Long>(); 
  
  long n = rd.readLong();
  int k = rd.readInt();
  for(long i=1;i<=Math.sqrt(n);i++){
    if (n%i==0){
           
               if (n/i == i) 
                 a.add((long)i);
      
               else{
                 a.add((long)i);
                 a.add((long)n/i);
               }
    }
  }
    Collections.sort(a);
    if( k>a.size())
      System.out.println(-1); 
    else
    System.out.println(a.get(k-1));                  
           
 
 }
 
}
 
class FastIO {
  public final StringBuilder cache = new StringBuilder(1 << 20);
  private final InputStream is;
  private final OutputStream os;
  private final Charset charset;
  private StringBuilder defaultStringBuf = new StringBuilder(1 << 8);
  private byte[] buf = new byte[1 << 13];
  private int bufLen;
  private int bufOffset;
  private int next;
 
  public FastIO(InputStream is, OutputStream os, Charset charset) {
    this.is = is;
    this.os = os;
    this.charset = charset;
  }
 
  public FastIO(InputStream is, OutputStream os) {
    this(is, os, Charset.forName("ascii"));
  }
 
  private int read() {
    while (bufLen == bufOffset) {
      bufOffset = 0;
      try {
        bufLen = is.read(buf);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
      if (bufLen == -1) {
        return -1;
      }
    }
    return buf[bufOffset++];
  }
 
  public void skipBlank() {
    while (next >= 0 && next <= 32) {
      next = read();
    }
  }
 
  public int readInt() {
    int sign = 1;
 
    skipBlank();
    if (next == '+' || next == '-') {
      sign = next == '+' ? 1 : -1;
      next = read();
    }
 
    int val = 0;
    if (sign == 1) {
      while (next >= '0' && next <= '9') {
        val = val * 10 + next - '0';
        next = read();
      }
    } else {
      while (next >= '0' && next <= '9') {
        val = val * 10 - next + '0';
        next = read();
      }
    }
 
    return val;
  }
 
  public long readLong() {
    int sign = 1;
 
    skipBlank();
    if (next == '+' || next == '-') {
      sign = next == '+' ? 1 : -1;
      next = read();
    }
 
    long val = 0;
    if (sign == 1) {
      while (next >= '0' && next <= '9') {
        val = val * 10 + next - '0';
        next = read();
      }
    } else {
      while (next >= '0' && next <= '9') {
        val = val * 10 - next + '0';
        next = read();
      }
    }
 
    return val;
  }
 
  public double readDouble() {
    boolean sign = true;
    skipBlank();
    if (next == '+' || next == '-') {
      sign = next == '+';
      next = read();
    }
 
    long val = 0;
    while (next >= '0' && next <= '9') {
      val = val * 10 + next - '0';
      next = read();
    }
    if (next != '.') {
      return sign ? val : -val;
    }
    next = read();
    long radix = 1;
    long point = 0;
    while (next >= '0' && next <= '9') {
      point = point * 10 + next - '0';
      radix = radix * 10;
      next = read();
    }
    double result = val + (double) point / radix;
    return sign ? result : -result;
  }
 
  public String readString(StringBuilder builder) {
    skipBlank();
 
    while (next > 32) {
      builder.append((char) next);
      next = read();
    }
 
    return builder.toString();
  }
 
  public String readString() {
    defaultStringBuf.setLength(0);
    return readString(defaultStringBuf);
  }
 
  public int readLine(char[] data, int offset) {
    int originalOffset = offset;
    while (next != -1 && next != '\n') {
      data[offset++] = (char) next;
      next = read();
    }
    return offset - originalOffset;
  }
 
  public int readString(char[] data, int offset) {
    skipBlank();
 
    int originalOffset = offset;
    while (next > 32) {
      data[offset++] = (char) next;
      next = read();
    }
 
    return offset - originalOffset;
  }
 
  public int readString(byte[] data, int offset) {
    skipBlank();
 
    int originalOffset = offset;
    while (next > 32) {
      data[offset++] = (byte) next;
      next = read();
    }
 
    return offset - originalOffset;
  }
 
  public char readChar() {
    skipBlank();
    char c = (char) next;
    next = read();
    return c;
  }
 
  public void flush() {
    try {
      os.write(cache.toString().getBytes(charset));
      os.flush();
      cache.setLength(0);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
 
  public boolean hasMore() {
    skipBlank();
    return next != -1;
  }
}