Harryxun/stf_run huggingface dataset:
a, b = map(int, input())
if a > 9 or b > 9:
  print("-1")
else:
  print(a * b)

### FIXED CODE ###

a, b = map(int, input().split())
if a > 9 or b > 9:
  print("-1")
else:
  print(a * b)
x = int(input())
y = int(input())
if x == y:
    print(y)
else:
    print(y - x + 1)


### FIXED CODE ###

t,i = map(int,input().split(" "))
j=t-i+1 
print(j)
# -*- coding: utf-8 -*-
import numpy as np
import math

def calculate_distance(in1, in2):
    list1 = np.array(in1) 
    list2 = np.array(in2) 
    sub_list = list1 - list2
    pow_list = np.power(sub_list, 2)
    sum_number = sum(pow_list)
    distance = math.sqrt(sum_number)

    return distance

[N, D] = [int(i) for i in input().split()]

X = []
for n in range(N):
    X.append([int(i) for i in input().split()])

number = 0
for n in range(N):
    for nn in range(n+1, N):
        distance = calculate_distance(X[n], X[nn])
        if distance.is_integer() is True:
            number += 1

print(number)


### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy as np
import math

def calculate_distance(in1, in2):
    list1 = np.array(in1) 
    list2 = np.array(in2) 
    sub_list = list1 - list2
    pow_list = np.power(sub_list, 2)
    sum_number = sum(pow_list)
    distance = math.sqrt(sum_number)

    return distance

[N, D] = [int(i) for i in input().split()]

X = []
for n in range(N):
    X.append([int(i) for i in input().split()])

number = 0
for n in range(N):
    for nn in range(n+1, N):
        distance = calculate_distance(X[n], X[nn])
        if distance.is_integer() is True:
            number += 1

print(number)
N=int(input())
if N==1:
    print("1")
elif 2<=N<4:
    print("2")
elif 4<=N<8:
    print("4")
elif 8<=N<16:
    print("8")
elif 16<=N<32:
    prnit("16")
elif 32<=N<64:
    print("32")
elif 64<=N<=100:
    print("64")


### FIXED CODE ###

N=int(input())
list=[]
for i in range(7):
    s=2**i
    if s<=N:
        list.append(s)
    else:
        break
print(max(list))
x = input().split(" ")
a = int(x[0])
b = int(x[1])
c = int(x[2])
d = int(x[3])

c_count = (b//c)-((a-1)//c)
d_count = (b//d)-((a-1)//c)

import math

cd = c*d // math.gcd(c,d)
cd_count =  (b//cd) - ((a-1)//cd)

print((b+1-a)-c_count-d_count+cd_count)

### FIXED CODE ###

import fractions

x = input().split(" ")
a = int(x[0])
b = int(x[1])
c = int(x[2])
d = int(x[3])

c_count = (b//c)-((a-1)//c)
d_count = (b//d)-((a-1)//d)

cd = c*d // fractions.gcd(c,d)
cd_count = (b//cd) - ((a-1)//cd)
ans = (b+1-a)-c_count-d_count+cd_count

print(ans)
N = int(input())
l = []
c = 0

for i in range(N):
  a = int(input())
  l.append(a)

for j in range(N):
  for k in range(j+1,N):
    for m in range(k+1,N):
      if l[j]==l[k] or l[k]==l[m] or l[j]==l[m]:
        continue
      if (l[j] + l[k] > l[m]) and (l[k] + l[m] > l[j]) and (l[j] + l[m] > l[k]):
        c += 1

print(c)

### FIXED CODE ###

N = int(input())
L = list(map(int, input().split()))
c = 0
 
for i in range(N):
  for j in range(i+1,N):
    for k in range(j+1,N):
      if L[i]!=L[j] and L[j]!=L[k] and L[k]!=L[i]:
        if L[i] + L[j] + L[k] > 2 * max(L[i],L[j],L[k]):
          c +=1
 
print(c)
N = int(input())
M = int(input())

print(N*M)

### FIXED CODE ###

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

print(N*M)
a=list(map(int,input().split()))
a.sort()
ans=0
while True:
    if a[0]==a[1]==a[2]:
        print(ans)
        sys.exit()
    if a[0]<a[1]:
        a[0]+=2
        ans+=1
        a.sort()
        if a[0]==a[1]==a[2]:
            print(ans)
            sys.exit()
    if a[0]==a[1]:
        a[0]+=1
        a[1]+=1
        ans+=1
        a.sort()
        if a[0]==a[1]==a[2]:
            print(ans)
            sys.exit()

### FIXED CODE ###

import sys
a=list(map(int,input().split()))
a.sort()
ans=0
while True:
    if a[0]==a[1]==a[2]:
        print(ans)
        sys.exit()
    if a[0]<a[1]:
        a[0]+=2
        ans+=1
        a.sort()
        if a[0]==a[1]==a[2]:
            print(ans)
            sys.exit()
    if a[0]==a[1]:
        a[0]+=1
        a[1]+=1
        ans+=1
        a.sort()
        if a[0]==a[1]==a[2]:
            print(ans)
            sys.exit()
A,B=map(int,input())
    ans=0 if A-B*2<0 else A-B*2
    print(A-B*2)

### FIXED CODE ###

# coding: utf-8
# Your code here!
# coding: utf-8
import sys
sys.setrecursionlimit(10000000)

#const
# my functions here!
def pin(type=int):
    return map(type,input().rstrip().split())

def resolve():
    A,B=pin()
    ans=0 if (A<B*2) else A-B*2
    print(ans)
"""
#printデバッグ消した？
#前の問題の結果見てないのに次の問題に行くの？
"""
"""
お前カッコ閉じるの忘れてるだろ
"""
import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """12 4"""
        output = """4"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """20 15"""
        output = """0"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """20 30"""
        output = """0"""
        self.assertIO(input, output)

if __name__=="__main__":resolve()
count = -1
realcount = 0
for i in k:
    count +=1
    if i!=S[count]:
        S.replace(S[count],i)
        realcount+=1
        if realcount == 0:
            real = 0
        else:
            real = realcount//2
print(real)

### FIXED CODE ###

S = input()
k = S[::-1]
count = -1
realcount = 0
for i in k:
    count +=1
    if i!=S[count]:
        S.replace(S[count],i)
        realcount+=1
    if realcount == 0:
        real = 0
    else:
        real = realcount//2
print(real)
import sys; sys.setrecursionlimit(50000)
input = sys.stdin.readline

X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)

cnt = 0
result = [0]*(X*Y*Z)
for x in range(X):
    for y in range(Y):
        if x * y > K: break
        for z in range(Z):
            if x * y * z > K: break
            result[cnt] = A[x]+B[y]+C[z]
            cnt += 1
result.sort(reverse=True)
for i in range(K):
    print(result[i])


### FIXED CODE ###

X,Y,Z,K = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))

import itertools
AB = [a + b for a, b in itertools.product(A,B)]
AB.sort(reverse=True)
ABC = [ab + c for ab, c in itertools.product(AB[:3000],C)]
ABC.sort(reverse=True)
for i in range(K):
    print(ABC[i])
import math
A,B = map(int,input().split())
gd = math.gcd(A,B)
hf = A*B//gd
print(hf)

### FIXED CODE ###

def gcd(x,y):
  while y:
    x,y = y,x%y
  return x

A,B = map(int,input().split())
gd = gcd(A,B)
hf = A*B//gd
print(hf)
# coding: utf-8
N, M = map(int, input().split())
d = {}
ans = ["0" for _ in range(N)]
for i in range(M):
    s, c = map(int, input().split())
    if s not in d.keys():
        d[s] = c
        ans[s-1] = str(c)
    else:
        if d[s] != c:
            ans = -1
            print(ans)
            exit()
ans = "".join(ans)
if ans[0] == "0" and 0 not in d.keys():
    ans[0] = "1"
print(ans)

### FIXED CODE ###

# coding: utf-8
N, M = map(int, input().split())
d = {}
ans = ["0" for _ in range(N)]
for i in range(M):
    s, c = map(int, input().split())
    if str(s) not in d.keys():
        d[str(s)] = c
        ans[s-1] = str(c)
    else:
        if d[str(s)] != c:
            print(-1)
            exit()
if N == 1:
    print("".join(ans))
    exit()
if "1" not in d.keys():
    ans[0] = "1"
ans = "".join(ans)
if ans[0] == "0" and N != 1:
    print(-1)
else:
    print(int(ans))
import numpy as np
import itertools

n = map(int, input().split())
x = [list(map(int,input().split())) for i in range(n)]

res = 0
cnt = 0
for v in itertools.permutations(x):
  a = numpy.array(v[0])
  b = numpy.array(v[1])
  res += np.linalg.norm(b-a)
  cnt += 1

print((res+0.0)/cnt)

### FIXED CODE ###

import math
import itertools

n = int(input())
x = [list(map(int, input().split())) for i in range(n)]

res = 0
cnt = 0
for v in itertools.permutations(x):
  for i in range(n-1):
    res += math.sqrt((v[i+1][0] - v[i][0]) ** 2 + (v[i+1][1] - v[i][1]) ** 2)
  cnt += 1

print((res+0.0)/cnt)
import fractions
N,M = map(int,input().split())
A = list(map(int,input().split()))
while A:
 t=1
 b=0
 for i in range(N):
  A[i]=int(A[i]/2)
  if A[i]%2==1:
   b+=1
 if b==N:
  break
 elif 0<b<N:
  t=0
  break
 else:
  t+=1
if t==0:
 print(0)
else:
 ans = A[0]
 for i in range(1, N):
  ans = ans * A[i] // fractions.gcd(ans, A[i])
 print(int(M/(2**(t-1))/ans)-int(M/(2**(t))/ans))


### FIXED CODE ###

import fractions
N,M = map(int,input().split())
A = list(map(int,input().split()))
t=1
while A:
 b=0
 for i in range(N):
  A[i]=int(A[i]/2)
  if A[i]%2==1:
   b+=1
 if b==N:
  break
 elif 0<b<N:
  t=0
  break
 else:
  t+=1
if t==0:
 print(0)
else:
 ans = A[0]
 for i in range(1, N):
  ans = ans * A[i] // fractions.gcd(ans, A[i])
 ans=min(ans,(M+1))
 c=int(M/(2**(t-1))/ans)
 d=int(M/(2**(t))/ans)
 print(c-d)
s = np.array(list(map(int, input())))
     
idx = np.array([[i, i+1, i+2] for i in range(len(s)-2)])

total = np.sum(np.abs(s[idx] - [7,5,3])*[100,10,1], axis=1)
        
print(np.min(total))

### FIXED CODE ###

s = input()

min_num = 753

for i in range(len(s)-2):
    num = abs(int(s[i:i+3]) - 753)
    if num < min_num:
        min_num = num
print(min_num)
K=input()
A=input()
B=input()

for i in range(A,B,1):
    if (i %= K) == 0:
        print("OK")
    else:
        print("NG")


### FIXED CODE ###

K=int(input())
A,B=map(int,input().split())

yn=0
for i in range(A,B+1,1):
    if (i % K) == 0:
        print("OK")
        yn=1
        break
if yn==0:
    print("NG")
# -*- coding: utf-8 -*-
a, b = int(input().split())
x = (a + b) / 2
if x > 0:
	return x + 1
else:
	return x


### FIXED CODE ###

# -*- coding: utf-8 -*-
import math

a, b = map(int, input().split())
x = (a + b) / 2
print(math.ceil(x))
import sys
x=(input())
t = int(x[:-2])
x = int(x)
c = 0
while True:
    if x <= 100:
        break
    x -=105
    c += 1

if c == t:
    print(0)
else:
    print(1)



### FIXED CODE ###

import sys
x=(input())
ls = [101,102,103,104,105]
if int(x) < 100:
    print(0)
else:
    t = int(x[:-2])
    x = int(x)
    c = 0
    while True:
        if x <= 100:
            break
        x -=105
        c += 1

    if x+105 in ls:
        print(1)
    elif c == t:
        print(0)
    else:
        print(1)
import math

a, b = map(int, input().split())
print(int(a * b / math.gcd(a, b)))

### FIXED CODE ###

a,b=map(int, input().split())

def gcd(l,s):
    r = l%s
    if r == 0:
        return s
    else:
        return gcd(s,r)

def lcm(x,y):
    return (x * y) // gcd(x, y)

print(lcm(a,b))
print(input()**3)

### FIXED CODE ###

n = int(input())
print(n ** 3)
import numpy as np

N, K = map(int, input().split(" "))
S = np.array([int(i) for i in input()])
pos1 = np.linspace(0,N-1,N)[S == 1]
lst = []
st =[pos1[0]]
for i in pos1[1:]:
    if st[-1] + 1 == i:
        st.append(i)
    else:
        lst.append(st)
        st = [i]
    if i == pos1[-1]:
        lst.append(st)
lst = [[0]] + lst + [[N-1]]
time = len(lst) - K
if time <= 0:
    print(N)
else:
    print(int(max([max(lst[i+K]) - min(lst[i])+1 for i in range(time)])))

### FIXED CODE ###

import numpy as np

N, K = map(int, input().split(" "))
S = np.array([int(i) for i in input()])
pos1 = np.linspace(0,N-1,N)[S == 1]
lst = []
if len(pos1) == 0:
    print(N)
else:    
    st =[pos1[0]]
    if len(pos1) != 1:
        for i in pos1[1:]:
            if st[-1] + 1 == i:
                st.append(i)
            else:
                lst.append(st)
                st = [i]
            if i == pos1[-1]:
                lst.append(st)
    else:
        lst.append(st)
    lst = [[0]] + lst + [[N-1]]
    time = len(lst) - K
    if time <= 0:
        print(N)
    else:
        print(int(max([max(lst[i+K]) - min(lst[i])+1 for i in range(time)])))
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')

from math import log2


class Doubling:

    def __init__(self, N, K, next0):
        """
        ダブリングのメモ構築 O(NlogK)
        :param N: 解の存在空間の大きさ
        :param K: K個先までのステップを考慮する
        :param next0: i番目の要素の1個先の番号を要素として持つリスト
                      次の要素が存在しない場合には-1を要素として保持する
        """
        next = [[0] * N for _ in range(int(log2(K)) + 1)]
        next[0] = next0
        for k in range(int(log2(K))):
            for i in range(N):
                if next[k][i] == -1:
                    # 2^k個次に要素が無い時、当然2^(k+1)個次にも要素はない
                    next[k + 1][i] = -1
                else:
                    # i番目の要素の2^(k+1)個次の要素 := next[k][i](i番目の要素の2^k個次の要素)の2^k個先
                    next[k + 1][i] = next[k][next[k][i]]
        self.next = next

    def query(self, p, K):
        """
        p番目の要素のK個次の要素を求める O(logK)
        """
        for i in reversed(range(int(log2(K)) + 1)):
            if p == -1:
                return p
            if (K >> i) & 1:
                p = self.next[i][p]
        return p


S = input()

times = 10 ** 100
n0 = [i + 1 if c == 'R' else i - 1 for i, c in enumerate(S)]
d = Doubling(len(S), times, n0)

ans = [0] * len(S)
for i in range(len(S)):
    ans[d.query(i, times)] += 1
print(' '.join(str(x) for x in ans))


### FIXED CODE ###

S = input()

lst = list()
rev = False
r = 0
l = 0
start = 0
for i in range(len(S)):
    c = S[i]
    if rev and c == 'R':
        lst.append((start, r, l))
        r = 1
        l = 0
        start = i + 1
        rev = False
        continue
    if c == 'R':
        r += 1
    elif c == 'L':
        rev = True
        l += 1
lst.append((start, r, l))

ans = list()
for start, r, l in lst:
    for _ in range(r - 1):
        ans.append(0)

    a = 0
    b = 0
    if r % 2 != 0:
        a += 1
    a += r // 2
    b += r // 2
    if l % 2 != 0:
        b += 1
    a += l // 2
    b += l // 2
    ans.append(a)
    ans.append(b)

    for _ in range(l - 1):
        ans.append(0)

print(' '.join([str(x) for x in ans]))
t=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
p,q=[0],[0]
x,y=[(a[0]-b[0])*t[0],(a[1]-b[1])*t[1]]
#print(x,y,abs(x)<abs(y))
#exit()
if x+y==0:
    print("infinity")
elif (x<0 and y<0) or (x>0 and y>0):
    print(0)
elif (x<0 and x+(x+y)>0) or (x>0 and x+(x+y)<0):
    print(1)
elif x<0 and x+y>0:
    print((abs(x)//(x+y))*2+[0,1][abs(x)%(x+y)>1])
#elif x>0 and x+y<0:
#    print((abs(y)//abs(x+y))*2+[0,1][abs(y)%abs(x+y)>1])
else:
    print(hhh)


### FIXED CODE ###

T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
 
P = (A1 - B1) * T1
Q = (A2 - B2) * T2
if P > 0:
	P *= -1
	Q *= -1
 
if P + Q < 0:
	print(0)
elif P + Q == 0:
	print("infinity")
else:
	S = (-P) // (P + Q)
	T = (-P) % (P + Q)
	if T != 0:
		print(S * 2 + 1)
	else:
		print(S * 2)
a=[int(input())for i in[0]*int(input())]
b=max(a)
if a.count(b)>1:print('\n'.join([str(b)]*len(a)))
else:
  c=[b for i in a]
  c[a.index(b)]=max(a[:a.index(b)]+a[a.index(b)+1:])

### FIXED CODE ###

print(3*int(input())**2)
import sys

##Fill alpha array
alpha = [0] * (ord('z') - ord('a') + 1)

for line in sys.stdin:
    line_char = filter(
        map(lambda c: c.lower(),
            (lambda c: c.isalpha(), list(line))))
    for c in line_char:
        alpha[ord(c) - ord('a')] += 1

for idx in range(len(alpha)):
    print chr(idx + ord('a')), '=', alpha[idx]

### FIXED CODE ###

import sys

##Fill alpha array
alpha = [0] * (ord('z') - ord('a') + 1)

for line in sys.stdin:
    line_char = map(lambda c: c.lower(),
                    filter(lambda c: c.isalpha(), list(line)))
    for c in line_char:
        alpha[ord(c) - ord('a')] += 1

for idx in range(len(alpha)):
    print chr(idx + ord('a')), ':', alpha[idx]

exit()
import math
a,b=map(int,input().split())
A=[]
B=[]
for i in range(9):
  A.append(a+i/10)
  B.append(b+i/10)
for i in range(len(A)):
  A[i]=A[i]/0.08
  B[i]=B[i]/0.1
ans=[]
for i in range(len(A)):
  for j in range(len(A)):
    if math.isclose(A[i],B[j]):
      ans.append(A[i])
      break
if ans==[]:
  print(-1)
else:
  print(int(ans[0]))

### FIXED CODE ###

import sys
input = sys.stdin.readline

a,b=map(int,input().split())
ans=-1
for i in range(1,1001):
  if i*0.08//1 == a and i*0.1//1 == b:
    ans=i
    break
print(ans)
#ABC080B
n = input()
print("Yes" if sum(map(int,n))%n == 0 else "No")

### FIXED CODE ###

#ABC080B
n = input()
print("Yes" if int(n) %sum(map(int,n)) == 0 else "No")
a, b, c = map(int, input().split())  # 入力
k = map(int, input().split())  # 入力
num_ary = [a, b, c]
max_n = max(a,b,c)
max_index = num_ary.index(max_n)#最大値のindex
max_num = pow(max(a, b, c), k)

num_ary[max_index] = max_num

print(num_ary[0] + num_ary[1] + num_ary[2])





### FIXED CODE ###

a, b, c = map(int, input().split())  # 入力
k = int(input())  # 入力
num_ary = [a, b, c]
max_n = max(num_ary)

max_index = num_ary.index(max_n)#最大値のindex

max_num = max_n * pow(2, k)

num_ary[max_index] = max_num

print(num_ary[0] + num_ary[1] + num_ary[2])
sec    7404 KB     68 bytes     
?
1
2
3
4
while 1:
    s=input()
    if '?' in s:break
    print(int(eval(s)))


### FIXED CODE ###

while 1:
    s=input()
    if '?' in s:break
    print(int(eval(s)))
a=input().split()
N,A,B=int(a[0]),int(a[1]),int(a[2])
a_str='b'*A
b_str='r'*B
st=a_str+b_str
num=A+B
sum_str=''
sum_num=0

while sum_num<=N:
    sum_str+=st
    sum_num+=num
b=sum_str[0:N]
print(b.count('b'))

### FIXED CODE ###

a=input().split()
N,A,B=int(a[0]),int(a[1]),int(a[2])
b=int(N/(A+B))
ans=int(A*b)
if(N-b*(A+B)<=A):
    ans=ans+N-b*(A+B)
else:
    ans+=A
print(int(ans))
N, M = map(int, input().split())
P = []
S = []
flag = [False for i in range(0, N)]
for i in range(0, M):
    x, y = map(str, input().split())
    P.append(int(x-1))
    S.append(y)
ans = [0, 0]
for i in range(0, M):
    if flag[P[i]]:
        continue
    else:
        if S[i] == 'AC':
            flag[P[i]] = True
            ans[0] += 1
        else:
            ans[1] += 1
print(*ans)


### FIXED CODE ###

N, M = map(int, input().split())
P = []
S = []
flag = [False for i in range(0, N)]
for i in range(0, M):
    x, y = map(str, input().split())
    P.append(int(x)-1)
    S.append(y)
ans = [0, 0]
wa = [0 for i in range(0, N)]
for i in range(0, M):
    if not flag[P[i]]:
        if S[i] == 'AC':
            flag[P[i]] = True
            ans[0] += 1
            ans[1] += wa[P[i]]
        else:
            wa[P[i]] += 1
print(*ans)
#!/usr/bin/env python3

N  = int(input())

ans = 0
T, A = [0] * 1001, [0] * 1001

for i in range(N):
    T[i], A[i] = map(int, input().split())

    if i != 0 and T[i-1] >= T[i] or A[i-1] >= A[i]:
        t = T[i-1] // T[i] if T[i-1] % T[i] == 0 else T[i-1] // T[i] + 1
        s = A[i-1] // A[i] if A[i-1] % A[i] == 0 else A[i-1] // A[i] + 1

        m = max(t, s)

        T[i] *= m
        A[i] *= m

    ans = sum([T[i], A[i]])

print (ans)


### FIXED CODE ###

a, b, c = map(int, raw_input().split())

ans = 0

if a == b == c:
    ans = 1

elif a == b or b == c or c == a:
    ans = 2

else:
    ans = 3

print ans
X = list(map(int, input().split()))

print(max{X[0]*X[1], X[1]*X[2], X[2]*X[3], X[3]*X[0], X[0]*X[2],
         X[1]*X[3]})

### FIXED CODE ###

X = list(map(int, input().split()))

print(max(X[1]*X[2], X[3]*X[0], X[0]*X[2],X[1]*X[3]))
a,b,c = map(int,input().split())

lis = [a,b,c]
lis  = lis.remove(max(lis))

print(int(lis[0]*lis[1]/2))

### FIXED CODE ###

a,b,c = map(int,input().split())

lis = [a,b,c]

lis.remove(max(lis))

print(int(lis[0]*lis[1]/2))
ab = input()
a = int(input.split()[0])
b = float(input.split()[1])
print(int(a*b))

### FIXED CODE ###

from decimal import Decimal

a,b = map(Decimal,input().split())

print(int(a*b))
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

def main():
    A = list(map(int, input().split()))

    if sum(A) => 22:
        print('bust')
    else:
        print('win')


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

def main():
    A = list(map(int, input().split()))

    if sum(A) >= 22:
        print('bust')
    else:
        print('win')


if __name__ == '__main__':
    main()
N = int(input())
if N % 2 == 0:
  print(0.5000000000)
else:
  print((N+1)/2N)


### FIXED CODE ###

N = int(input())
if N % 2 == 0:
  print(0.5000000000)
else:
  print((N+1)/(2*N))
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, S, X):
    Xs = []
    for x in X:
        t = abs(x - S)
        Xs.append(t)

    if N == 1:
        return Xs[0]
    ans = math.gcd(Xs[0], Xs[1])
    for i in range(2, N):
        ans = math.gcd(ans, Xs[i])

    return ans


def main():
    N, S = read_int_n()
    X = read_int_n()
    print(slv(N, S, X))


if __name__ == '__main__':
    main()


### FIXED CODE ###

# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, S, X):
    Xs = []
    for x in X:
        t = abs(x - S)
        Xs.append(t)

    if N == 1:
        return Xs[0]
    ans = gcd(Xs[0], Xs[1])
    for i in range(2, N):
        ans = gcd(ans, Xs[i])

    return ans


def gcd(a, b):
    if a < b:
        return gcd(b, a)
    if b == 0:
        return a
    return gcd(b, a % b)


def main():
    N, S = read_int_n()
    X = read_int_n()
    print(slv(N, S, X))

    # N = 10000
    # S = random.randint(1, 10**9)
    # # X = [random.randint(1, 10**9) for _ in range(N)]
    # S = 1
    # X = list(range(N))
    # print(slv(N, S, X))


if __name__ == '__main__':
    main()