qyliang/CodeNanoFix huggingface dataset:
Buggy code:
m,d=map(int,input().split())

a=0
if d>=22:
    for i in range(d-21):
        day=d-i
        d1=int(str(day)[1])
        d10=int(str(day)[0])
        if int(str(day)[1])!=1:
            if d1*d10<=m and d1!=0:
                print(d10,d1)
                a+=1

print(a)


Fixed code:
m,d=map(int,input().split())

a=0
if d>=22:
    for i in range(d-21):
        day=d-i
        d1=int(str(day)[1])
        d10=int(str(day)[0])
        if int(str(day)[1])!=1:
            if d1*d10<=m and d1!=0:
                #print(d10,d1)
                a+=1

print(a)
Buggy code:
m,d=map(int,input().split())
ans=0
for i in range(1,m+1):
  for j in range(1,d+1):
    if i>=2 and j>=20 and j//10>=2 and j%10>=2 and m==(j//10)*(j%10):
      ans+=1
print(ans)

Fixed code:

m,d=map(int,input().split())
ans=0
for i in range(1,m+1):
  for j in range(1,d+1):
    if j%10>=2 and j//10>=2:
      if (j%10)*(j//10)==i:
        ans+=1
print(ans)
Buggy code:
m,d=input().split()
m,d=int(m),int(d)

c=0
if d<22:
    print(0)
else:
    for j in range(m):
        for i in range(d-22):
            d1,d10=int(str(i+22)[1]),int(str(i+22)[0])
            #print(d1)
            #print(d10)
            if d1>1 and d10>1 and d1*d10==j+1:
                c+=1
                print(j+1,i+22)
    print(c)


Fixed code:
m,d=input().split()
m,d=int(m),int(d)

c=0
if d<22:
    print(0)
else:
    for j in range(m):
        for i in range(d-21):
            d1,d10=int(str(i+22)[1]),int(str(i+22)[0])
            #print(d1)
            #print(d10)
            if d1>1 and d10>1 and d1*d10==j+1:
                c+=1
                #print(j+1,i+22)
    print(c)
Buggy code:
M, D = map(int, input().split())
c=0
for m in range(1,M+1):
  for d in range(1,D+1):
    d1 = d%10
    d10 = d//10
    if d1>1 and d10>1 and d1*d2=m: c+=1
print(c)

Fixed code:
M, D = map(int, input().split())
c=0
for m in range(1,M+1):
  for d in range(1,D+1):
    d1 = d%10
    d10 = d//10
    if d1>1 and d10>1 and d1*d10==m:
      c+=1
print(c)
Buggy code:
def takahashi_cal(m: int, d: int) -> int:
    res = 0
    for mm in range(1, m + 1):
        for dd in range(1, d + 1):
            d1 = dd % 10
            d10 = dd // 10
            if any([d1 < 2, d10 < 2]):
                continue
            if d1 * d10 == mm:
                res += 1
    return res
  
  m, d = input().split(" ")
  print(takahashi_cal(m, d))

Fixed code:
def takahashi_cal(m: int, d: int) -> int:
    res = 0
    for mm in range(1, m + 1):
        for dd in range(1, d + 1):
            d1 = dd % 10
            d10 = dd // 10
            if any([d1 < 2, d10 < 2]):
                continue
            if d1 * d10 == mm:
                res += 1
    return res
    
m, d = input().split(" ")
print(takahashi_cal(int(m), int(d)))
Buggy code:
input_data = input().split(" ")
M = int(input_data[0])
D = input_data[1]
d1 = int(D[1])
d10 = int(D[0])
cnt = 0
for i in range(1,M + 1):
  for j in range(22, int(D) + 1):
    if i == int(str(j)[0]) * int(str(j)[1]) and int(str(j)[1]) != 0  and int(str(j)[1]) != 1:
      cnt += 1
    else:
      pass

print(cnt)

Fixed code:
input_data = input().split(" ")
M = int(input_data[0])
D = input_data[1]

cnt = 0
for i in range(1,M + 1):
  for j in range(22, int(D) + 1):
    if i == int(str(j)[0]) * int(str(j)[1]) and int(str(j)[1]) != 0  and int(str(j)[1]) != 1:
      cnt += 1
    else:
      pass

print(cnt)
Buggy code:
S = input().split()
M = int(S[0])
D = int(S[1])
count = 0

for m in range(1, M + 1):
    for d in range(1, D + 1):
        d1  = d %  10
        d10 = d // 10
        if d1 >= 2 and d10 >= 2:
            if d1 * d10 == m:
                count += 1
                print(m, d)

print(count)

Fixed code:
S = input().split()
M = int(S[0])
D = int(S[1])
count = 0

for m in range(1, M + 1):
    for d in range(1, D + 1):
        d1  = d %  10
        d10 = d // 10
        if d1 >= 2 and d10 >= 2:
            if d1 * d10 == m:
                count += 1

print(count)
Buggy code:
m, d = [int(i) for i in input().split()]

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
month_list = range(0, m+1, 1)
days_list = range(0, d+1, 1)
seki_list =[]
for m in month_list:
    for d in days_list:
        if d >=20 :
            day_list = digit(d)
            print(day_list)
            print(int(day_list[0]))
            print(int(day_list[1]))
            if int(day_list[0]) >= 2 and int(day_list[1]) >= 2:
                print("hoge1")
                if (int(day_list[0])* int(day_list[1])) == m:
                    print("hoge2")
                    seki_list.append("hoge")

print(len(seki_list))

Fixed code:
m, d = [int(i) for i in input().split()]

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
month_list = range(0, m+1, 1)
days_list = range(0, d+1, 1)
seki_list =[]
for m in month_list:
    for d in days_list:
        if d >=20 :
            day_list = digit(d)
            if int(day_list[0]) >= 2 and int(day_list[1]) >= 2:
                if (int(day_list[0])* int(day_list[1])) == m:
                    seki_list.append("hoge")

print(len(seki_list))
Buggy code:
m,d = map(int,input().split())
if d<21:
    print(0)

cnt=0
for i in range(1,m+1):
    for j in range(22,d+1):
        d10,d1=divmod(j, 10)
        if d1>=2 and i==d1*d10:
            cnt = cnt+1
print(cnt)

Fixed code:
import sys
m,d = map(int,input().split())
if d<21:
    print(0)
    sys.exit()
cnt=0
for i in range(1,m+1):
    for j in range(22,d+1):
        d10,d1=divmod(j, 10)
        if d1>=2 and i==d1*d10:
            cnt = cnt+1
print(cnt)
Buggy code:
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

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

cand = set()
for m in range(1, M+1):
    i = 2
    while i*i <= D:
        if m % i == 0:
            ma = m//i
            mi = i
            if mi <= 1 or ma <= 1:
                pass
            elif int(str(mi)+str(ma)) <= D:
                cand.add(int(str(m)+str(mi)+str(ma)))
                print("mi,ma->", mi, ma)
            elif int(str(ma)+str(mi)) <= D:
                cand.add(int(str(m)+str(ma)+str(mi)))
                print("ma,mi->", ma, mi)

        i += 1
print(len(cand))


Fixed code:
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

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

cand = set()
for m in range(1, M+1):
    i = 2
    while i*i <= D:
        if m % i == 0:
            ma = m//i
            mi = i
            if mi <= 1 or ma <= 1:
                pass
            elif int(str(mi)+str(ma)) <= D:
                cand.add(int(str(m)+str(mi)+str(ma)))
            elif int(str(ma)+str(mi)) <= D:
                cand.add(int(str(m)+str(ma)+str(mi)))

        i += 1
print(len(cand))
Buggy code:
M, D = map(int,input().split())

count = 0
for m in range(M+1):
    for d in range(D):
        d_1 = d % 10
        d_10 = d // 10
        print(m, d_10, d_1)
        if (d_10 >= 2 and d_1 >= 2 and m == d_10*d_1):
            count += 1

print(count)

Fixed code:
M, D = map(int,input().split())

count = 0
for m in range(M+1):
    for d in range(D+1):
        d_1 = d % 10
        d_10 = d // 10
        if (d_10 >= 2 and d_1 >= 2 and m == d_10*d_1):
            count += 1

print(count)
Buggy code:
m, d = map(int, input().split())
ans = 0

for mon in m:
  for day in d:
    d1 = day%10
    d10 = int(day/10)
    if d1 >= 2 and d10 >= 2:
      if d1*d10 == mon:
        ans+=1
print(ans)

Fixed code:
m, d = map(int, input().split())
ans = 0

for mon in range(1,m+1):
  for day in range(1, d+1):
    d1 = day%10
    d10 = int(day/10)
    if d1 >= 2 and d10 >= 2:
      if d1*d10 == mon:
        ans+=1
print(ans)
Buggy code:
m,d= map(int, input().split())

ans=0
for mon in range(1,m+1):
	for day in range(1,d+1):
    	if day<22:
        	continue
        d1,d2=str(day)
  		if d1*d2==mon:
            ans+=1
print(ans)

Fixed code:
m,d= map(int, input().split())

ans=0
for mon in range(1,m+1):
    for day in range(1,d+1):
        if day<22:
            continue
        d1,d2=str(day)
        d1,d2=int(d1),int(d2)
        if d1<2 or d2<2:
            continue
        if d1*d2==mon:
            ans+=1

print(ans)
Buggy code:
M,D = map(int, input().split())
if M < 4 or D < 22:
    print(0)
else:
    result=0
    for m in range(4,M+1):
        for d in range(22,D+1):
            if str(d)[0] >= 2 and str(d)[1] >= 2 and int(str(d)[0])*int(str(d)[1])==m:
                result += 1
    print(result)

Fixed code:
M,D = map(int, input().split())
if M < 4 or D < 22:
    print(0)
else:
    result=0
    for m in range(4,M+1):
        for d in range(22,D+1):
            if int(str(d)[0]) >= 2 and int(str(d)[1]) >= 2 and int(str(d)[0])*int(str(d)[1])==m:
                result += 1
    print(result)
Buggy code:
m,d = map(int(input().split()))
count = 0
for month in range(1,m+1):
  for day in range(1,d):
    if (day%10) >= 2 and (day//10) >= 2:
      if (day%10)*(day//10) == m:
        count += 1
print(count)

Fixed code:
m,d = map(int,input().split())
count = 0
for month in range(1,m+1):
  for day in range(1,d+1):
    if (day%10) >= 2 and (day//10) >= 2:
      if (day%10)*(day//10) == month:
        #print(month,day)
        count += 1
print(count)
Buggy code:
M_D = list(map(int,input().split()))
answer=0
for m in range(1,M_D[0]+1):
    for d in range(1,M_D[1]+1):
        d1 = d%10
        d10 = d//10

        if d1*d10==m and d1>=2 and d10>=2:
            print(d1,d10)
            answer+=1
print(answer)


Fixed code:
M_D = list(map(int,input().split()))
answer=0
for m in range(1,M_D[0]+1):
    for d in range(1,M_D[1]+1):
        d1 = d%10
        d10 = d//10

        if d1*d10==m and d1>=2 and d10>=2:
            #print(d1,d10)
            answer+=1
print(answer)
Buggy code:
m,d=map(int,input().split())
count=0
for i in range(1,m+1):
  for j in range(1,d+1):
    d1=int(str(d)[-1])
    d2>=2
    if d>=10 and d1>=2 and d2>=2 and d1*d2==m:
      count+=1
print(count)

Fixed code:
m,d=map(int,input().split())
count=0
for i in range(1,m+1):
    for j in range(1,d+1):
        if j>=10:
            d1=int(str(j)[-1])
            d2=int(str(j)[0])
            if d1>=2 and d2>=2 and d1*d2==i:
                count+=1
print(count)
Buggy code:
M, D =  map(int, input().split())
count = 0
for d in range(D - 1):
    d += 2
    d1 = int(d/10)
    d2 = d - d1 * 10
    if d1 * d2 <= M and d1 > 1 and d2 > 1:
        print(d1, d2)
        count += 1
print(count)

Fixed code:
M, D =  map(int, input().split())
count = 0
for d in range(D - 1):
    d += 2
    d1 = int(d/10)
    d2 = d - d1 * 10
    if d1 * d2 <= M and d1 > 1 and d2 > 1:
        count += 1
print(count)
Buggy code:
M, D = [int(x) for x in input().split()]
dates = list(range(22,D+1))
c = 0
 
for i in range(len(dates)):
  d1 = int(str(dates[i])[-1])
  d2 = int(str(dates[i])[-2])
  if d1*d2 <= M and d1 > 1 and d2 > 1:
    print(d1,d2)
    c += 1
print(c)

Fixed code:
M, D = [int(x) for x in input().split()]
dates = list(range(22,D+1))
c = 0
 
for i in range(len(dates)):
  d1 = int(str(dates[i])[-1])
  d2 = int(str(dates[i])[-2])
  if d1*d2 <= M and d1 > 1 and d2 > 1:
    #print(d2,d1)
    c += 1
print(c)
Buggy code:
from sys import stdin
import numpy as np
from operator import itemgetter

M, D = [int(x) for x in stdin.readline().rstrip().split()]

D10=D//10
D1=D%10

ans=0
for i in range(2,D10):
    for j in range(2,10):
        if i*j<=M:
            ans+=1
i=D10
if i < 2:
    print(0)
else:
    for j in range(2,D1):
        if i*j<=M:
            ans+=1
    j=D1
    if i*j<=M:
        ans+=1
    print(ans)


Fixed code:
from sys import stdin
import numpy as np
from operator import itemgetter

M, D = [int(x) for x in stdin.readline().rstrip().split()]

D10=D//10
D1=D%10

ans=0
for i in range(2,D10):
    for j in range(2,10):
        if i*j<=M:
            ans+=1
i=D10
if i < 2:
    print(0)
else:
    for j in range(2,D1):
        if i*j<=M:
            ans+=1

    j=D1
    if j>1:
        if i*j<=M:
            ans+=1
    print(ans)
Buggy code:
m,d  =map(int,input().split())
count = 0
for i in range(1,m+1):
    for j in range(d+1):
        if j < 22 or j%10<2:
            continue
        else:
            a = str(j)
            if int(a[0])*int(a[1])==i:
                count += 1
                print(i,j)
print(count)

Fixed code:
m,d  =map(int,input().split())
count = 0
for i in range(1,m+1):
    for j in range(d+1):
        if j < 22 or j%10<2:
            continue
        else:
            a = str(j)
            if int(a[0])*int(a[1])==i:
                count += 1
print(count)
Buggy code:
m,d=map(int, input().split())
count=0
if d <= 10:
  print(0)
else:
  for i in range(1,m+1):
    for j in range(11,d+1):
      dl = list(str(j))
      if int(dl[0]) >=2 and int(dl[1]) >= 2 and int(dl[0])*int(dl[1]) == i:
        print(str(i)+ ' ' + str(j))
        count+=1

  print(count)

Fixed code:
m,d=map(int, input().split())
count=0
if d <= 10:
  print(0)
else:
  for i in range(1,m+1):
    for j in range(11,d+1):
      dl = list(str(j))
      if int(dl[0]) >=2 and int(dl[1]) >= 2 and int(dl[0])*int(dl[1]) == i:
        count+=1

  print(count)
Buggy code:
m,d = map(int,input().split())

ans = 0

for i in range(2,m+1):
  for i in range(22,d+1):
     if m == ((d//10) * (d%10)):
        ans += 1


print(ans)

Fixed code:
m,d = map(int,input().split())

ans = 0

for i in range(2,m+1):
  for j in range(22,d+1):
    if j%10 <= 1:
      continue
    if i == ((j//10) * (j%10)):
       ans += 1


print(ans)
Buggy code:
M = int(input())
D = int(input())
D_array = list(map(int, str(D)))

ans = 0
for i in range(2,M+1):
  for d10 in range(2,int(D_array[0])+1):
    for d1 in range(2,10):
      if int(str(d10)+str(d1)) <= D:
        if int(d1)*int(d10) == i:
          ans += 1
print(ans)

Fixed code:
M,D = map(int,input().split())
D_array = list(map(int, str(D)))

ans = 0
for i in range(2,M+1):
  for d10 in range(2,int(D_array[0])+1):
    for d1 in range(2,10):
      if int(str(d10)+str(d1)) <= D:
        if int(d1)*int(d10) == i:
          ans += 1
print(ans)
Buggy code:
m,d=map(int,input().split())
cnt=0
for i in range(d//10+1):
  for j in range(d%10+1):
    if i>=2 and j>=2 and m==i*j:
      cnt+=1
print(cnt)


Fixed code:
m,d = map(int,input().split())

ans = 0

for i in range(2,m+1):
    for j in range(2,d+1):
        if j//10 >=2 and j%10 >=2 and i == (j//10) * (j%10):
            ans += 1

print(ans)
Buggy code:
m,d=map(int,input().split())
cnt=0
for j in range(1,m+1):
  for i in range(1,d+1):
    a=i//10
    b=i%10
    if a*b==j:
      cnt+=1
print(cnt)
    
  


Fixed code:
m,d=map(int,input().split())
cnt=0
for j in range(1,m+1):
  for i in range(1,d+1):
    a=i//10
    b=i%10
    if a>1 and b>1:
      if a*b==j:
        cnt+=1
print(cnt)
Buggy code:
M, D = map(int, input().split())
ans = 0
for i in range(1,M+1):
  for j in range(2,i+1):
    if i % j == 0:
      if 10*j + i//j == D:
        ans += 1
print(ans)

Fixed code:
M, D = map(int, input().split())
ans = 0
for i in range(1,M+1):
  for j in range(2,10):
    if i % j == 0 and 2 <= i//j < 10:
      if 10*j + i//j <= D:
        # print(i,j,i//j)
        ans += 1
print(ans)
Buggy code:
m,d=map(int,input().split())
x=0
if m>=4 and d>=22:
  for i in range(4,m+1):
    for j in range(22,d+1):
      if int(str(d)[1])*int(str(d)[0])==i:
        x+=1
print(x)

Fixed code:
m,d=map(int,input().split())
x=0
if m>=4 and d>=22:
  for i in range(4,m+1):
    for j in range(22,d+1):
      if j%10>1 and int(str(j)[1])*int(str(j)[0])==i:
        x+=1
print(x)
Buggy code:
m,d=map(int,input().split())

ans=0
if d<10:
    print(0)
else:
    for i in range(10,d+1):
        for j in range(1,m+1):
            if (i%10)*(i//10)==j:
                ans+=1
    print(ans)

Fixed code:
m,d=map(int,input().split())

ans=0
if d<10:
    print(0)
else:
    for i in range(10,d+1):
        for j in range(1,m+1):
            if (i%10)*(i//10)==j and i%10>=2 and (i//10)>1:
                ans+=1
    print(ans)
Buggy code:
M,D = map(int,input().split())
c = 0
for m in range(M+1):
    for d in range(D):
        d1 = d%10
        d10 = int((d-d1)/10)

        if d1 >= 2 and d10 >= 2 and d1*d10 == m:
            print(d1,d10)
            c+=1
print(c)


Fixed code:
M,D = map(int,input().split())
c = 0
for m in range(1,M+1):
    for d in range(1,D+1):
        d1 = d%10
        d10 = int((d-d1)/10)

        if d1 >= 2 and d10 >= 2 and d1*d10 == m:
            c+=1
print(c)
Buggy code:
M,D = map(int, input().split())

D = int(D)
ans = 0

for i in range(1,M+1):
    for j in range(1,D+1):
        if len(j) == 2:
            j1 = j // 10
            j2 = j % 10
            if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
                ans += 1


print(ans)


Fixed code:
M,D = map(int, input().split())

ans = 0

for i in range(1,M+1):
    for j in range(1,D+1):
        j1 = j // 10
        j2 = j % 10
        if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
            ans += 1


print(ans)
Buggy code:
M, d = input().split()
d10 = int(d[0])
d1 = int(d[1])
M = int(M)
ans = 0
import sys
for j in range(2,d10+1):
  for i in range(2,10):
    if 10*j+i>d10*10+d1:
      print(ans)
      sys.exit()
    if M >=j*i:
      ans+=1

Fixed code:
import sys
M, d = input().split()
if int(d)>=10:
  d10 = int(d[0])
  d1 = int(d[1])
else:
  print(0)
  sys.exit()
M = int(M)
ans = 0
for j in range(2,d10+1):
  for i in range(2,10):
    if 10*j+i>d10*10+d1:
      print(ans)
      sys.exit()
    if M >=j*i:
      ans+=1
print(ans)
Buggy code:
def calendar():
    m, d = map(int, input().split())
    
    res = []
    for month in range(1, m + 1):
        for day in range(2, d + 1):
            for x in range(2, d + 1):
                if x * day == month:
                    temp = str(day) + str(x)
                    temp = int(temp)
                    if temp <= d:
                        res.append(temp)
    return res
 
 
calendar()

Fixed code:
def calendar():
    m, d = map(int, input().split())
    res = []
 
    for month in range(1, m + 1):
        for day in range(2, 10):
            for x in range(2, 10):
                if x * day == month:
                    temp = str(day) + str(x)
                    temp = int(temp)
                    if temp <= d:
                        res.append(temp)
    return len(res)
 
 
print(calendar())
Buggy code:
M,D = map(int,input().split())

if D < 22:
  print("0")
  exit()

count = 0
  
for m in range(1,M+1):
  for d in range(22,N+1):
    if int(str(d)[1]) < 2:
      continue
   	if int(str(d)[0]) * int(str(d)[1]) == m:
      count += 1
print(count)

Fixed code:
M,D = map(int,input().split())

if D < 22:
  print("0")
  exit()

count = 0

for m in range(1,M+1):
  for d in range(22,D+1):
    if int(str(d)[1]) < 2:
      continue
    if int(str(d)[0]) * int(str(d)[1]) == m:
      count += 1
print(count)
Buggy code:
a,b=map(int,input().split())
x=0
for i in range(1,a+1):
  for j in range(11,b):
    lst = []
    while j > 0:
      lst.append(j%10)
      j //= 10
    lst.reverse()
    if lst[0] >= 2 and lst[1] >= 2:
      if i == lst[0]*lst[1]:
        print(lst[0],lst[1])
        x+=1
print(x)
      

Fixed code:
a,b=map(int,input().split())
x=0
for i in range(1,a+1):
  for j in range(11,b+1):
    lst = []
    while j > 0:
      lst.append(j%10)
      j //= 10
    lst.reverse()
    if lst[0] >= 2 and lst[1] >= 2:
      if i == lst[0]*lst[1]:
        x+=1
print(x)
Buggy code:
import numpy as np
M,D = map(int,input().split())
a = 0
for i in np.arange(1,D+1):
	d10 = int(i/10)
	d01 = i-d10*10
    if 0 < d10*d01 and d10*d01 <= M:
    	a += 1
print(a)

Fixed code:
import numpy as np
M,D = map(int,input().split())
a = 0
for i in np.arange(22,D+1):
  d10 = int(i/10)
  d01 = i-d10*10
  if d01 <= 1:
    continue
  if 0 < d10*d01 and d10*d01 <= M:
    a += 1
print(a)
Buggy code:
m,d = map(int,input().split())
ans = 0
for i in range(1,m+1):
    for j in range(1,d+1):
        if (j//10) * (j%10) == i and j//10 >= 2 and j%10 >= 2:
            print(i,j)
            ans += 1
print(ans)

Fixed code:
m,d = map(int,input().split())
ans = 0
for i in range(1,m+1):
    for j in range(1,d+1):
        if (j//10) * (j%10) == i and j//10 >= 2 and j%10 >= 2:
            ans += 1
print(ans)
Buggy code:
m, d = map(int,input().split())
cnt = 0
for i in range(1, m + 1):
    for j in range(1, d + 1):
        if (j % 10) * (j // 10) == i and j % 10 >= 2 and j // 10 >= 2:
            print(i, j, j % 10, j // 10)
            cnt += 1
print(cnt)

Fixed code:
m,d=map(int,input().split())
ans=0
for i in range(1,d+1):
    for j in range(1,m+1):
    # print(i//10,i%10,m)
        if (i//10)*(i%10)==j and i//10>=2 and i%10>=2:
            # print(i,j)
            ans+=1
print(ans)
Buggy code:
MD = [int(i) for i in input().split()]

c = 0
for m in range(1, MD[0] + 1):
    for d in range(1, MD[1] + 1):
        if d < 22:
            continue
        d1  = d % 10
        d10 = (d - d1) /10


        if m == d1 * d10:
            #print("d-> %d,m -> %d, d1 - > %d, d10 -> %d"%(d, m,d1,d10))
            c+=1

print(c -1 )

Fixed code:
MD = [int(i) for i in input().split()]

c = 0
for m in range(1, MD[0] + 1):
    for d in range(1, MD[1] + 1):
        
        d1  = d % 10
        d10 = (d - d1) /10
        if d1 < 2 or d10 <2:
            continue

        if m == d1 * d10:
            #print("d-> %d,m -> %d, d1 - > %d, d10 -> %d"%(d, m,d1,d10))
            c+=1

print(c  )
Buggy code:
m,d = map(int,input().split())
count=0

if d<20:
  print(0)
else:
  for i in range(1,m+1):
    for j in range(20, d+1):
      a = j//10
      b = j%10
      if i == a*b:
        count+=1

print(count)

Fixed code:
m,d = map(int,input().split())
count=0
 
if d<20:
  print(count)
else:
  for i in range(1,m+1):
    for j in range(20, d+1):
      a = j//10
      b = j%10
      if b>=2:
        if i == a*b:
          count+=1
  print(count)
Buggy code:
def seki_day(m, d):
    d10 = d // 10
    d1 = d - d10 * 10

    if d1 >= 2 and m == d10 * d1:
        print(m, d)
        return 1
    else:
        return 0

M, D = [int(x) for x in input().split()]

count = 0
for m in range(1, M + 1):
    for d in range(22, D + 1):
        count += seki_day(m, d)

print(count)


Fixed code:
def seki_day(m, d):
    d10 = d // 10
    d1 = d - d10 * 10

    if d1 >= 2 and m == d10 * d1:
        return 1
    else:
        return 0

M, D = [int(x) for x in input().split()]

count = 0
for m in range(1, M + 1):
    for d in range(22, D + 1):
        count += seki_day(m, d)

print(count)
Buggy code:
m,d = map(int,input().split())
d1,d2 = str(d)[0],str(d)[1]
cnt = 0
m_list = [i+1 for i in range(m)]
for i in range(d):
  if i >= 20:
    d1,d2 = str(i)[0],str(i)[1]
    if d1=='1' or d2=='1':
      continue
    if int(d1)*int(d2) in m_list:
      
      cnt += 1
print(cnt)
    

Fixed code:
m,d = map(int,input().split())
if len(str(d)) == 2:
	d1,d2 = str(d)[0],str(d)[1]

cnt = 0
m_list = [i+1 for i in range(m)]

if len(str(d)) == 2:
  for i in range(d+1):
    
    if i >= 20:
      d1,d2 = str(i)[0],str(i)[1]
      if d1=='1' or d2=='1':
        continue
      if int(d1)*int(d2) in m_list:
        cnt += 1
print(cnt)
Buggy code:
a,b = map(int, input().split())
ans = 0

for i in range(a+1):
  for j in range(b+1):
    if len(str(j)) == 2 and i >= 2 and int(str(j)[1]) >= 2 and int(str(j)[0]) >= 2:
      if i == int(str(j)[0]) * int(str(j)[1]): 
        print(str(i) +' '+ str(j))
        ans += 1

print(ans)

Fixed code:
a,b = map(int, input().split())

ans = 0

for i in range(a+1):
  for j in range(b+1):
    if len(str(j)) == 2 and i >= 2 and int(str(j)[1]) >= 2 and int(str(j)[0]) >= 2:
      if i == int(str(j)[0]) * int(str(j)[1]): 
        ans += 1

print(ans)
Buggy code:
m,d = map(int,input().split())
ans = 0
for i in range(m):
  for j in range(d):
    if "1" in str(j):
      continue
    j1 = j//10
    j2 = j%10
    if i == j1*j2:
      ans += 1
print(ans)

Fixed code:
m,d = map(int,input().split())
ans = 0
for i in range(1,m+1):
  for j in range(10,d+1):
    if "1" in list(str(j)):
      continue
    j1 = j//10
    j2 = j%10
    if i == j1*j2:
      ans += 1
print(ans)