Buggy python submission (verdict: Runtime Error):
def make_divisor_list(num):
    if num < 1:
        return []
    elif num == 1:
        return [1]
    else:
        divisor_list = []
        i = 1
        while i*i <= num:
            if num%i == 0:
                divisor_list.append(i)
                divisor_list.append(num//i)

            i += 1
        divisor_list.append(num)

        return sorted(set(divisor_list))


def bin_search(L,Target):
    left = 0
    righ = len(L)

    i = 0
    while left < righ:

        mid  = (left + righ) //2

        if L[mid] <= Target <= L[mid+1]:
            break
        elif L[mid] <= Target:
            left = mid
            righ = righ
        else:
            left = left
            righ = mid

    return mid

N,M = map(int,input().split())

Target = N
L = make_divisor_list(M)

mid = bin_search(L,Target)

ans = M//L[mid+1]
print(ans)


Fixed submission:
N,M = map(int,input().split())
ans = 1
i = 1
while i*i <= M:
    if M%i == 0 and M//N >= i:
        ans = max(ans,i)
        if M //i *N <= M:
            ans = max(ans,M//i)
    i += 1
print(ans)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
import math

def make_divisor_list(num,tar):
    if num < 1:
        return []
    elif num == 1:
        return [1]
    else:
        divisor_list = []
        divisor_list.append(1)
        i = 2
        while i*i <= num:

            if num % i == 0 and i*i <= num:
                divisor_list.append(i)
                divisor_list.append(num//i)
            i += 1
        divisor_list.append(num)
        return divisor_list
def binary_search_loop(li,tar):
    arry = li
    target = tar

    left = 0
    right = len(arry)

    while left <= right:

        mid = (left + right) // 2
        if arry[mid] ==  target:
            break
        elif arry[mid] > target:
            right = mid
        else:
            left = mid
        if right - left == 1:
            mid += 1
            break

#    print(mid)
    return mid

N,M = map(int,input().split())

li = make_divisor_list(M,M//N)
li = sorted(li)
mid = binary_search_loop(li,M//N)


ans = 0
i = max(0,mid-10)
while True:
    if li[i]>=N:
        tmp = M//li[i]
        if tmp >= ans:
            ans = tmp
        else:
            break

    i += 1
print(ans)
# print(li)

# ans = 1
# for l in li[::-1]:
#     if l >= N:
#         ans = max(ans,M//l)
#     if ans >= l:
#         break

# i = 1
# ans = 0
# tmp = 1000000000

# if M%N == 0:
#     ans = max(ans,M//N)
#     print(ans)
#     exit()

# while M//i >= i and N > i and i <= tmp:
#     if M%i == 0:
#         if tmp == 1000000000:
#             tmp = M//i
#         if M//i >= N:
#             ans = max(ans,i)
#     i += 1

#print(ans)


Fixed submission:
N,M = map(int,input().split())
ans = 1
i = 1
while i*i <= M:
    if M%i == 0 and M//N >= i:
        ans = max(ans,i)
        if M //i *N <= M:
            ans = max(ans,M//i)
    i += 1
print(ans)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
import math

def make_divisor_list(num,tar):
    if num < 1:
        return []
    elif num == 1:
        return [1]
    else:
        divisor_list = []
        divisor_list.append(1)
        i = 2
        while i*i <= num:

            if num % i == 0 and i*i <= num:
                divisor_list.append(i)
                divisor_list.append(num//i)
            i += 1
        divisor_list.append(num)
        return divisor_list
def binary_search_loop(li,tar):
    arry = li
    target = tar

    left = 0
    right = len(arry)

    while left <= right:

        mid = (left + right) // 2
        if arry[mid] ==  target:
            break
        elif arry[mid] > target:
            right = mid
        else:
            left = mid
        if right - left == 1:
            mid += 1
            break

#    print(mid)
    return mid

N,M = map(int,input().split())

li = make_divisor_list(M,M//N)
li = sorted(li)
mid = binary_search_loop(li,M//N)


ans = 0
i = mid
while True:
    if li[i]>=N:
        tmp = M//li[i]
        if tmp >= ans:
            ans = tmp
        else:
            break

    i += 1
print(ans)
# print(li)

# ans = 1
# for l in li[::-1]:
#     if l >= N:
#         ans = max(ans,M//l)
#     if ans >= l:
#         break

# i = 1
# ans = 0
# tmp = 1000000000

# if M%N == 0:
#     ans = max(ans,M//N)
#     print(ans)
#     exit()

# while M//i >= i and N > i and i <= tmp:
#     if M%i == 0:
#         if tmp == 1000000000:
#             tmp = M//i
#         if M//i >= N:
#             ans = max(ans,i)
#     i += 1

#print(ans)


Fixed submission:
N,M = map(int,input().split())
ans = 1
i = 1
while i*i <= M:
    if M%i == 0 and M//N >= i:
        ans = max(ans,i)
        if M //i *N <= M:
            ans = max(ans,M//i)
    i += 1
print(ans)

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
import math

def make_divisor_list(num,tar):
    if num < 1:
        return []
    elif num == 1:
        return [1]
    else:
        divisor_list = []
        divisor_list.append(1)
        i = 2
        while i*i <= num:

            if num % i == 0 and i*i <= num:
                divisor_list.append(i)
                divisor_list.append(num//i)
            i += 1
        divisor_list.append(num)
        return divisor_list
def binary_search_loop(li,tar):
    arry = li
    target = tar

    left = 0
    right = len(arry)

    while left <= right:

        mid = (left + right) // 2
        if arry[mid] ==  target:
            break
        elif arry[mid] > target:
            right = mid
        else:
            left = mid
        if right - left == 1:
            mid += 1
            break

#    print(mid)
    return mid

N,M = map(int,input().split())

li = make_divisor_list(M,M//N)
li = sorted(li)
mid = binary_search_loop(li,M//N)

print(M//li[mid])

# print(li)

# ans = 1
# for l in li[::-1]:
#     if l >= N:
#         ans = max(ans,M//l)
#     if ans >= l:
#         break

# i = 1
# ans = 0
# tmp = 1000000000

# if M%N == 0:
#     ans = max(ans,M//N)
#     print(ans)
#     exit()

# while M//i >= i and N > i and i <= tmp:
#     if M%i == 0:
#         if tmp == 1000000000:
#             tmp = M//i
#         if M//i >= N:
#             ans = max(ans,i)
#     i += 1

#print(ans)


Fixed submission:
N,M = map(int,input().split())
ans = 1
i = 1
while i*i <= M:
    if M%i == 0 and M//N >= i:
        ans = max(ans,i)
        if M //i *N <= M:
            ans = max(ans,M//i)
    i += 1
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-
def make_divisor_list(num):
    if num < 1:
        return []
    elif num == 1:
        return [1]
    else:
        divisor_list = []
        divisor_list.append(1)
        for i in range(2, num // 2 + 1):
            if num % i == 0:
                divisor_list.append(i)
        divisor_list.append(num)

        return divisor_list

N,M = map(int,input().split())

li = make_divisor_list(M)

ans = 1
for l in li[::-1]:
    if l >= N:
        ans = max(ans,M//l)
    if ans >= l:
        break

# i = 1
# ans = 0
# tmp = 1000000000

# if M%N == 0:
#     ans = max(ans,M//N)
#     print(ans)
#     exit()

# while M//i >= i and N > i and i <= tmp:
#     if M%i == 0:
#         if tmp == 1000000000:
#             tmp = M//i
#         if M//i >= N:
#             ans = max(ans,i)
#     i += 1

print(ans)


Fixed submission:
N,M = map(int,input().split())
ans = 1
i = 1
while i*i <= M:
    if M%i == 0 and M//N >= i:
        ans = max(ans,i)
        if M //i *N <= M:
            ans = max(ans,M//i)
    i += 1
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-
def make_divisor_list(num):
    if num < 1:
        return []
    elif num == 1:
        return [1]
    else:
        divisor_list = []
        divisor_list.append(1)
        for i in range(2, num // 2 + 1):
            if num % i == 0:
                divisor_list.append(i)
        divisor_list.append(num)

        return divisor_list

N,M = map(int,input().split())

li = make_divisor_list(M)

ans = 1
for l in li:
    if l >= N:
        ans = max(ans,M//l)

# i = 1
# ans = 0
# tmp = 1000000000

# if M%N == 0:
#     ans = max(ans,M//N)
#     print(ans)
#     exit()

# while M//i >= i and N > i and i <= tmp:
#     if M%i == 0:
#         if tmp == 1000000000:
#             tmp = M//i
#         if M//i >= N:
#             ans = max(ans,i)
#     i += 1

print(ans)


Fixed submission:
N,M = map(int,input().split())
ans = 1
i = 1
while i*i <= M:
    if M%i == 0 and M//N >= i:
        ans = max(ans,i)
        if M //i *N <= M:
            ans = max(ans,M//i)
    i += 1
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-
N,M = map(int,input().split())

# j = M
# I=int(j)
# s=0
# R=int(I)
# L=[]

# while s==0:
#     for i in range(2,R+1):
#         if I%i==0:
#             I=I/i
#             if I==1:
#                 s=1
#             L.append(i)
#             break
# print(L)
# ans = 1
# for l in L:
#     if l >= N:
#         ans = max(M//l,ans)

i = 1
ans = 0

if M%N == 0:
    ans = max(ans,M//N)

while M//N >= i:
    if M%i == 0:
        if M//i >= N:
            ans = max(ans,i)
    i += 1

print(ans)


Fixed submission:
N,M = map(int,input().split())
ans = 1
i = 1
while i*i <= M:
    if M%i == 0 and M//N >= i:
        ans = max(ans,i)
        if M //i *N <= M:
            ans = max(ans,M//i)
    i += 1
print(ans)