Harryxun/stf_run huggingface dataset:
N,X=map(int,input().split())
inputcities=list(map(int, input().split()))
cities=[abs(inputcities[i]-X) for i in range(N)]
count=0
minimum=min(cities)
for j in range(minimum+1)[::-1]:
  for i in range(N):
    if cities[i]%j==0:
      count+=1
    else:
      count=0
      break
    if count==N:
      print(j)
      flag=1
      break
  if flag==1:
    break

### FIXED CODE ###

def gcd(a,b):
    if a < b:
        a,b = b,a
    if a % b == 0:
        return b
    else:
        return gcd(b,(a % b))
 
N,X=map(int,input().split())
inputcities=list(map(int, input().split()))
cities=[abs(inputcities[i]-X) for i in range(N)]
cities.sort()
D=cities[0]
for i in range(N):
  D=gcd(D,cities[i])
print(D)
# -*- coding: utf-8 -*-
#ABC112C
import sys

n = int(input())

x = []
y = []
h = []
for i in range(0,n):
	tmp = input().split()
	hoge = list(map(lambda a: int(a), tmp))
	x.append(hoge[0])
	y.append(hoge[1])
	h.append(hoge[2])

distance=0
height=0
#peak ga (i,j) to katei
for i in range(0,101):
	for j in range(0,101):
		distance=abs(i-x[0])
		distance+=abs(j-y[0])
		height=distance+h[0]

		for k in range(1,n):
			distance=abs(i-x[k])
			distance+=abs(j-y[k])
			if(height==distance+h[k]!):
				break
			if(k==n-1):
				print(i,j,height)
				sys.exit()

### FIXED CODE ###

# -*- coding: utf-8 -*-
#ABC112C
import sys

n = int(input())

x = []
y = []
h = []
for i in range(0,n):
	tmp = input().split()
	hoge = list(map(lambda a: int(a), tmp))
	x.append(hoge[0])
	y.append(hoge[1])
	h.append(hoge[2])

distance=0
height=0

m=0
while(h[m]==0):
	m+=1
for i in range(0,101):
	for j in range(0,101):
		distance=abs(i-x[m])
		distance+=abs(j-y[m])
		height=distance+h[m]
		for k in range(0,n):
			distance=abs(i-x[k])
			distance+=abs(j-y[k])
			if(max(height-distance,0)!=h[k]):
				break
			if(k==n-1):
				print(i,j,height)
				sys.exit()
import sys
import numpy as np

l3 = l / 3

print(l3**3)

### FIXED CODE ###

l = int(input())

print((l/3)**3)
S=input()
list=[Sunny,Cloudy,Rainy]
print(list[(list.index(S)+1)]%3)

### FIXED CODE ###

S=input()
list=["Sunny","Cloudy","Rainy"]
print(list[(list.index(S)+1)%3])
import math
X,Y = [int(x) for x in input().split()]
lcm = X*Y//math.gcd(X,Y)
if(lcm==X):
    print(-1)
else:
    print(X)


### FIXED CODE ###

import fractions as math
X,Y = [int(x) for x in input().split()]
lcm = X*Y//math.gcd(X,Y)
if(lcm==X):
    print(-1)
else:
    print(X)
a=int(input())
s=input()
if a < 3200:
    print(red)
else:
    print(s)

### FIXED CODE ###

a=int(input())
s=input()
if a < 3200:
    print("red")
else:
    print(s)
a,op,b=map(int,input().split())
if op=="+":
  suma=int(a)+int(b)
  print(suma)
elif op=="-":
  resta=int(a)-int(b)
  print(resta)

### FIXED CODE ###

l=input().split()
a=int(l[0])
x=l[1]
b=int(l[2])
if(x=='+'):
    print(a+b)
else:
    print(a-b)
x = input():

print x^3:

### FIXED CODE ###

x = input()

print x*x*x
n,d = map(int,input().split())
ans = 0
for i in range(n):
    if x*x+y*y <= d*d: ans+=1
print(ans)

### FIXED CODE ###

n,d = map(int,input().split())
ans = 0
for i in range(n):
    x,y = map(int,input().split())
    if x*x+y*y <= d*d: ans+=1
print(ans)
import bisect

n = int(input())
a = [int(input()) for _ in range(n)]
t = [a[-1]]

for i in reversed(a[:-1]):
    idx = bisect.bisect_left(t, i + 1)
    print(i, idx)
    if idx == len(t):
        t.append(i)

    else:
        t[idx] = i
    print(t)

print(len(t))

### FIXED CODE ###

import bisect
 
n = int(input())
a = [int(input()) for _ in range(n)]
# それぞれの色の最大値を入れる筒のリスト
t = [a[-1]]
 
for i in reversed(a[:-1]):
    # それぞれの色のどの値よりも小さかったとき
    idx = bisect.bisect_left(t, i+1)
    # print(i, idx)
    if idx == len(t):
        t.append(i)
    # 効率的な色の探索
    else:
        t[idx] = i
    # print(t)
 
print(len(t))
import sys
def main():
  input = sys.stdin.readline
  n, k = map(int , input().split())
  p_list = list(map(int, input().split()))
  c_list = list(map(int, input().split()))
  
  dp = [[float('-inf')]*n for _ in range(k+1)]
  dp[0] = [0]*n
  for i in range(k):
    for j in range(n):
      if i==0:
        dp[i+1][p_list[j]-1] = dp[i][j]+c_list[j]
      else:
        dp[i+1][p_list[j]-1] = max(dp[i][p_list[j]-1], dp[i][j]+c_list[j])
  print(max(dp[-1]))

if (__name__=='__main__'):
  main()

### FIXED CODE ###

import sys
def main():
  input = sys.stdin.readline
  n, k = map(int , input().split())
  p_list = list(map(int, input().split()))
  c_list = list(map(int, input().split()))
  res = -float('inf')
  
  for s in range(n):
    S = []
    i = p_list[s] - 1
    S.append(c_list[i])
    while i != s:
      i = p_list[i]-1
      S.append(S[-1] + c_list[i])
    if k <= len(S):
      score = max(S[:k])
    elif S[-1] <= 0:
      score = max(S)
    else:
      score1 = S[-1] * (k//len(S) - 1)
      score1 += max(S)
      
      score2 = S[-1] * (k//len(S))
      r = k%len(S)
      if r!=0:
        score2 += max(0, max(S[:r]))
      score = max(score1, score2)
    res = max(res, score)
  print(res)
      

if (__name__=='__main__'):
  main()
a=input()
if (a=="AAA" || a=="BBB"):
    print("No")
else:
    print("Yes")

### FIXED CODE ###

a=input()
flag=False
if a[0]!=a[1]:
    flag=True
if a[1]!=a[2]:
    flag=True

if flag:
    print("Yes")
else:
    print("No")
N = list(map(int, input().split()))
S = N%4

if S == 0:
    print("Yes")
elif S == 3::
    print("Yes")
else:
    print("No")

### FIXED CODE ###

N = int(input())

if N%4 == 0:
    print("Yes")

if N%4 == 1:
    if N < 21:
        print("No")
    else:
        print("Yes")

if N%4 == 2:
    if N < 14:
        print("No")
    else:
        print("Yes")


if N%4 == 3:
    if N < 7:
        print("No")
    else:
        print("Yes")
import numpy as np

S = input()
MOD = 10 ** 9 + 7

dp = [0] * 13
dp[0] = 1

for s in S:
    prev = dp
    dp = [0] * 13
    if s == '?':
        add = range(10)
    else:
        add = [int(s)]
    for i in range(13):
        for a in add:
            dp[(10*i+a)%13] += prev[i]
        dp[i] %= MOD
print(dp[5])

### FIXED CODE ###

MOD = 10 ** 9 + 7
S = input()

dp = [0] * 13
dp[0] = 1

for s in S:
  prev = [x for x in dp]
  dp = [0] * 13
  if s == '?':
    add = range(10)
  else:
    add = [int(s)]
  for i in range(13):
    for x in add:
      dp[(10*i+x)%13] += prev[i]
  dp = [x % MOD for x in dp]
  
print(dp[5])
n = int(input())
h = list(map(int, input().split()))
#高さ。0~n-1でアクセス

#足場Nにたどり着くまでの最小コストを格納。アクセスは[N-1]
dp = [float("inf")] * n

dp[0] = 0
dp[1] = abs(h[0] - h[1])

#足場x（0～n-1）にたどり着くまでの最小コストを返す関数。
def getdp(x):
    global dp #これでいいのか？
    if dp[x] != float("inf"): return dp[x] #0,1の場合と、既に求めた場合は値を返す
    dp[x] = min(getdp(x-2) + abs(h[x]-h[x-2]), getdp(x-1) + abs(h[x]-h[x-1]))
    #2つ左から飛ぶか1つ左から飛ぶかの最小値がxのdp。
    return(dp[x])

print(getdp(n-1))

### FIXED CODE ###

n = int(input())
h = list(map(int, input().split()))
#高さ。0~n-1でアクセス

#足場Nにたどり着くまでの最小コストを格納。アクセスは[N-1]
dp = [float("inf")] * n

dp[0] = 0
dp[1] = abs(h[0] - h[1])

import sys
sys.setrecursionlimit(10000000)
#足場x（0～n-1）にたどり着くまでの最小コストを返す関数。
def getdp(x):
    global dp #これでいいのか？
    if dp[x] != float("inf"): return dp[x] #0,1の場合と、既に求めた場合は値を返す
    dp[x] = min(getdp(x-2) + abs(h[x]-h[x-2]), getdp(x-1) + abs(h[x]-h[x-1]))
    #2つ左から飛ぶか1つ左から飛ぶかの最小値がxのdp。
    return(dp[x])

print(getdp(n-1))
while True:
  H,W = map(int, input().split())
  if H == 0 and W == 0:
    break
    
  if i in range(round(H/2)):
    print(("#"+".")*round(W/2))
    
  if i in range(int(H/2)):
    print(("."+"#")*round(W/2))    


### FIXED CODE ###

while True:
    (H,W) = [int(i) for i in input().split()]
    if H==W==0:
        break
    for i in range(H):
        for j in range(W):
            if (i+j)%2==0: print('#',end="")
            else: print('.',end="")
        print('')
    print('')
N=int(input())
P=list(map(int,input().split()))
Q=list(map(int,input().split()))

def mul(n):
  s=1
  for t in range(1,n+1):
    s=s*t
  return s

def f(x):
  result=0
  M=len(x)
  for i in range (x):
    k=0
    for j in range(i,M):
      if x[i]>x[j]:
        k=k+1
    result=result+k*mul(M-i-1)
  return result

print(abs(f(P)-f(Q)))


### FIXED CODE ###

K,X=map(int,input().split())
if K*500>=X:
  print("Yes")
else:
  print("No")
n = int(input())
a = list(map(int, input().split()))

x = 0
y = sum(a)
ans = []

if i in range(n-1):
    x += a[i]
    y -= a[i]
    ans.append(abs(x-y))

print(min(ans))

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))

x = 0
y = sum(a)
ans = []

for i in range(n-1):
    x += a[i]
    y -= a[i]
    ans.append(abs(x-y))

print(min(ans))
import math
n=int(input())
a=list(map(int,input().split()))
gcd=float('inf')
for i in range(n-1):
  gcd=min(gcd,math.gcd(a[i],a[i+1]))
print(gcd)
  
      


### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
def gcd(x,y):
  while x%y>0:
    x,y=y,x%y
  return y
a.sort(reverse=True)
ans=a[0]
for j in range(n-1):
  ans=gcd(ans,a[j+1])
print(ans)
# encoding:utf-8
import copy
import numpy as np
import random

n,q = map(int,input().split())
s = list(str(input()))
L = []
for i in range(q):
    l,r = map(int,input().split())
    L.append([l,r])

# count_ac = np.zeros([n])
count_ac = []
count = 0
i = 0
while True:
    if i==n:
        count_ac.append(count)
        break
    if s[i] == "A" and s[i+1] == "C":
        count_ac.append(count)
        count += 1
        count_ac.append(count)
        i += 2
    else:
        count_ac.append(count)
        i += 1


# print(count_ac)
for i in range(q):
    ans = count_ac[L[i][1]-1]-count_ac[L[i][0]-1]
    print(int(ans))


### FIXED CODE ###

# encoding:utf-8
import copy
import numpy as np
import random

n,q = map(int,input().split())
s = list(str(input()))
L = []
for i in range(q):
    l,r = map(int,input().split())
    L.append([l,r])

# count_ac = np.zeros([n])
count_ac = []
count = 0
i = 0
while i < n-1:
    if s[i] == "A" and s[i+1] == "C":
        count_ac.append(count)
        count += 1
        count_ac.append(count)
        i += 2
    else:
        count_ac.append(count)
        i += 1

count_ac.append(count)


# print(count_ac)
for i in range(q):
    ans = count_ac[L[i][1]-1]-count_ac[L[i][0]-1]
    print(int(ans))
X, Y = map(int, input().split())
d = {1:300000, 2:200000, 3:100000}
ans = d[X]+d[Y]
if X==1 and Y==1:
  ans += 400000
print(ans)

### FIXED CODE ###

from collections import defaultdict
X, Y = map(int, input().split())
d = defaultdict(int)
d[1] = 300000
d[2] = 200000
d[3] = 100000
ans = d[X]+d[Y]
if X==1 and Y==1:
  ans += 400000
print(ans)
from Lib import heapq
Heappop=heapq.heappop
Heappush=heapq.heappush
N,M=map(int,input().split())
L=[]
for _ in range(N):
    a,b=map(int,input().split())
    L.append([a,-b])
L.sort()
q=[0]*10**5
ans=0
d=1
memo=0
while d<=M:
    while memo<=N-1:
        a,b=L[memo]
        if d<a:
            break
        else:
            Heappush(q,b)
            memo+=1
    ans-=Heappop(q)
    d+=1
print(ans)

### FIXED CODE ###

import heapq
Heappop=heapq.heappop
Heappush=heapq.heappush
N,M=map(int,input().split())
L=[]
for _ in range(N):
    a,b=map(int,input().split())
    L.append([a,-b])
L.sort()
q=[0]*10**5
ans=0
d=1
memo=0
while d<=M:
    while memo<=N-1:
        a,b=L[memo]
        if d<a:
            break
        else:
            Heappush(q,b)
            memo+=1
    ans-=Heappop(q)
    d+=1
print(ans)
X ,Y ,A ,B ,C = map(int,input().split())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))
p.sort(reverse = True)
q.sort(reverse = True)
r.sort(reverse = True)
p = p[:X]
q = q[:Y]
p.extend(q)
p.extend(r)
p. sort(reverse = True)
p = p[:A+B]
print(sum(p))

### FIXED CODE ###

S = input()
if S[2] ==S[3] and S[4] == S[5]:
    print("Yes")
else :
    print("No")
N = int(input())
L = [tuple(map(int, input().split())) for _ in range(N)]
L.sort(key=lambda x: x[1])
work = 0
for n in range(N):
  work += L[0][n]
  if work > L[1][n]:
    print('No')
    exit()
print('Yes')

### FIXED CODE ###

N = int(input())
L = [tuple(map(int, input().split())) for _ in range(N)]
L.sort(key=lambda x: x[1])
work = 0
for n in range(N):
  work += L[n][0]
  if work > L[n][1]:
    print('No')
    exit()
print('Yes')
mod = (a*b)/2

if mod == 1:
    print(Odd)
else mode == 0:
    print(Even)

### FIXED CODE ###

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

mod = (a*b)%2
if mod == 1:
    print('Odd')
else:
    print('Even')
n = input()

zero = "0"
nine = "9"
zeronine = ""

for index in range(len(n)-1):
  if index%2==1:
    zeronine += zero
  else:
    zeronine += nine

if len(n)%2==0:
  print(int(zeronine))
else:
  if n=="0":
    print(1)
  else:
    print(int(n)-int(zeronine))

### FIXED CODE ###

n = input()

zero = "0"
nine = "9"
zeronine = ""

for index in range(len(n)-1):
  if index%2==1:
    zeronine += zero
  else:
    zeronine += nine

if len(n)%2==0:
  print(int(zeronine))
else:
  if len(n)==1:
    print(int(n))
  else:
    print(int(n)-int(zeronine))
p = 0
a,b,c = map(int,input().split())
for (int x = a; x <= b; x++):
    if c%x=0:
        p += 1
print(p)


### FIXED CODE ###

a,b,c = map(int,input().split())
count = 0
for i in range(a,b+1):
    if c%i == 0:
        count += 1


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

if (a+b)==c or (b+c)==a or (c+a)==b:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

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

if a+b==c or b+c==a or c+a==b:
    print("Yes")
else:
    print("No")
import sys
import heapq
input = sys.stdin.readline

class UnionFind():
    def __init__(self, n):
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

n = int(input())
uf = UnionFind(n)
d = {}

for i in range(n):
    x, y = map(int, input().split())
    d[x] = (i, y)
    
q = []
heapq.heapify(q)

for x in range(n):
    i, y = d[x+1]
    while q[0][0] < y:
        y2, i2 = heapq.heappop(q)
        uf.union(i,i2)
    heapq.heappush(q, (y,i))

for i in range(n):
    p = uf.find(i)
    print(-uf.parents[p])


### FIXED CODE ###

import sys
import heapq
input = sys.stdin.readline

class UnionFind():
    def __init__(self, n):
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

n = int(input())
uf = UnionFind(n)
d = {}

for i in range(n):
    x, y = map(int, input().split())
    d[x] = (i, y)
    
q = []
heapq.heapify(q)

for x in range(n):
    i, y = d[x+1]
    ym, im = 0, 0
    while q and q[0][0] < y:
        y2, i2 = heapq.heappop(q)
        if ym == 0:
            ym = y2
            im = i2
        uf.union(i,i2)
    heapq.heappush(q, (y,i))
    if ym:
        heapq.heappush(q, (ym,im))

for i in range(n):
    p = uf.find(i)
    print(-uf.parents[p])
nums = [int(input()) for _ in range(5)]
l = map(int,filter(lambda x:x !="0",[str(n)[-1] for n in nums]))
r = [(n+9) // 10 for n in nums]
print(sum(r)*10-(10-min(l))) if len(l) != 0 else print(sum(r)*10)

### FIXED CODE ###

nums = [int(input()) for _ in range(5)]
l = list(map(int,filter(lambda x:x !="0",[str(n)[-1] for n in nums])))
r = [(n+9) // 10 for n in nums]
print(sum(r)*10-(10-min(l))) if len(l) != 0 else print(sum(r)*10)
#n回,m回　　X =n + 2*m  Y = 2*n + m
X,Y = map(int,input().split())
import numpy as np
a = [[1, 2], [2, 1]]
#次に逆行列を求めます。
mod = pow(10,9)+7

b = np.linalg.inv(a)


Z = np.array([[X],[Y]])

n,m=np.dot(b,Z)
p,q = *n,*m



if p<0 or q<0:
    print(0)
elif not p == int(p) or not q==int(q):
    print(0)
else:
    n = int(p)+int(q)
    
    fac = [1]*(n+1)
    for i in range(1,n+1):
        fac[i] = (fac[i-1]*i) % mod 
    print(fac[n])


### FIXED CODE ###

#n回,m回　　X =n + 2*m  Y = 2*n + m
X,Y = map(int,input().split())
import numpy as np
from functools import reduce
import math 
a = [[1, 2], [2, 1]]
#次に逆行列を求めます。
mod = pow(10,9)+7

b = np.linalg.inv(a)


Z = np.array([[X],[Y]])

n,m=np.dot(b,Z)
p,q = *n,*m


def comb(n,k,p):
    if k==0:
        return 1
    A = reduce(lambda x,y:x*y%p ,[n-k+1+i for i in range(k)])
    B = reduce(lambda x,y:x*y%p ,[i+1 for i in range(k)])
    return A*pow(B,p-2,p)%p


if p<0 or q<0:
    print(0)
elif not abs(p-round(p))<pow(10,-3) or not abs(q-round(q))<pow(10,-3):
    print(0)
elif p==0 and q==0:
    print(0)
elif p==0:
    print(1)
elif q==0:
    print(1)
else:
    n = int(round(p))
    m = int(round(q))
    ans = comb(n+m,m,mod)

    print(ans%mod)
n = input()
??????
def scalar(n):
??????m = [[0 for i in range(len(n))] for j in range(len(n))]
??????
??????for l in range(2, len(n)+1):
????????????for i in range(0, len(n)-l+1):
??????????????????j = i + l - 1
??????????????????m[i][j] = min(m[i][k] + m[k+1][j] + M[i][0]*M[k][1]*M[j][1] for k in range(i, j))
??????
??????print m[0][len(n)-1]
??????
for i in range(n):
??????M.append(map(int, raw_input().split()))
scalar(M)

### FIXED CODE ###

n = input()
M = []
 
def scalar(n):
   m = [[0 for i in range(len(n))] for j in range(len(n))]
 
   for l in range(2, len(n)+1):
      for i in range(0, len(n)-l+1):
         j = i + l - 1
         m[i][j] = min(m[i][k] + m[k+1][j] + M[i][0]*M[k][1]*M[j][1] for k in range(i, j))
 
   print m[0][len(n)-1]
 
for i in range(n):
   M.append(map(int, raw_input().split()))
scalar(M)
import numpy as np
hoge = input()
N = int(hoge)
paper = set([])
for i in range(N):
    hoge = input()
    hoge = hoge.strip()
    if paper.issuperset(hoge):
        paper = paper - set([hoge])
    else:
        paper = paper + set([hoge])
    
print(len(paper))

    


### FIXED CODE ###

import numpy as np
hoge = input()
N = int(hoge)
paper ={}
for i in range(N):
    hoge = input()
    hoge = hoge.strip()
    if hoge in paper:
        paper.pop(hoge)
    else:
        paper[hoge] = 1
    
print(len(paper))
N,M=map(int,input().split())
INF=10**18
A=[INF]*N
ans=0
for _ in range(M):
    s,c=map(int,input().split())
    s-=1
    if A[s]==INF:
        A[s]=c
    else:
        if A[s]!=c:
            print(-1)
            exit()

if A[0]==0:
    print(-1)
    exit()
elif A[0]==INF:
    A[0]=1

for i in range(1,3):
    if A[i]==INF:
        A[i]=0
A=[str(a) for a in A]
print(''.join(A))

### FIXED CODE ###

N,M=map(int,input().split())
A=[]
if M==0:
    if N==1:
        print(0)
        exit()
    elif N==2:
        print(10)
        exit()
    else:
        print(100)
        exit()
        
else:
    for _ in range (M):
        s,c=map(int,input().split())
        A.append([s,c])

    for i in range(1000):
        i=str(i)
        if len(i)!=N:
            continue
        ans=0
        for X in A:
            x=X[0]
            y=X[1]
            x-=1
            if i[x]!=str(y):
                ans=1
                break
            else:
                continue
        if ans==0:
            print(i)
            exit()
print(-1)
m=2019
l,r=map(int,input().split())

if l==0 or l//m>r//m or r%m==0:
  print(0)
  exit()

import numpy as np
lr=m
for ii in np.arange(l,r):
  for jj in np.arange(ii+1,r+1):
    t=((ii%m)*(jj%m))%m
    if t==0:
        print(0)
        exit()
    if t<lr:
      lr=t
print(lr)

### FIXED CODE ###

m=2019
l,r=map(int,input().split())

if l==0 or l//m<r//m or l%m==0:
  print(0)
  exit()

import numpy as np
lr=m
for ii in np.arange(l,r):
  for jj in np.arange(ii+1,r+1):
    t=((ii%m)*(jj%m))%m
    if t==0:
        print(0)
        exit()
    if t<lr:
      lr=t
print(lr)
n = int(input())
a = [list(map(int, input().split())) for i in range(0, n)] 
at = list(map(list, zip(*a)))

if a != at: 
    print(-1)
    exit(0)

dr = list()
for u in range(n):
    for v in range(u + 1, n): 
        dist = a[u][v]
        cd = min([a[u][i] + a[i][v] for i in [x for x in range(0, n) if x != u and x != v]])
        if dist > cd:
            print(-1)
            exit(0)
        if dist < cd:
            dr.append(a[u][v])

print(sum(dr))

### FIXED CODE ###

import numpy as np

n = int(input())
a = np.array([np.array(input().split(), dtype=np.uint64) for _ in range(n)], dtype=np.uint64)

for i in range(n):
  a[i,i] = 1e9 + 1

ans = 0
for u in range(n):
    for v in range(u + 1, n): 
        dist = a[u,v]
        cd = np.min(a[u] + a[v])
        if dist > cd:
            print(-1)
            exit(0)
        if dist < cd:
            ans += dist
 
print(int(ans))
class union_find():
  def __init__(self,n):
    self.n=n
    self.parents=[-1]*n
  def find(self,x):
    if self.parents[x]<0:
      return x
    else:
      self.parents[x]=self.find(self.parents[x])
      return self.parents[x]
  def union(self,x,y):
    x=self.find(x)
    y=self.find(y)
    if x==y:
      return 
    if self.parents[x]>self.parents[y]:
      x,y=y,x
    self.parents[x]+=self.parents[y]
    self.parents[y]=x
    
def main():
  N,M=map(int,input().split())
  box=union_find(N)
  for i in range(M):
    x,y,z=map(int,input().split())
    box.union(x,y)
  box.find(1)
  ans=0
  for i, x in enumerate(box.parents):
    if x<0:
      ans+=1
  print(ans)
main()
    
    

### FIXED CODE ###

class union_find():
  def __init__(self,n):
    self.n=n
    self.parents=[-1]*n
  def find(self,x):
    if self.parents[x]<0:
      return x
    else:
      self.parents[x]=self.find(self.parents[x])
      return self.parents[x]
  def union(self,x,y):
    x=self.find(x)
    y=self.find(y)
    if x==y:
      return 
    if self.parents[x]>self.parents[y]:
      x,y=y,x
    self.parents[x]+=self.parents[y]
    self.parents[y]=x
    
def main():
  N,M=map(int,input().split())
  box=union_find(N)
  for i in range(M):
    x,y,z=map(int,input().split())
    box.union(x-1,y-1)
  box.find(1)
  ans=0
  for i, x in enumerate(box.parents):
    if x<0:
      ans+=1
  print(ans)
main()
i = str(input())
day = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']

if len(day) - day.index(i) == 0:
    print(7)
  else:
    print(len(day) - day.index(i))


### FIXED CODE ###

i = str(input())
day = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']

if i == 'SUN':
    print(7)
else:
    print(len(day) - day.index(i) - 1)
N, K = input().split()
int(N)
int(K)

array = []
for i in range(N):
    n = i+1
    nankai = 0
    while n < K:
        n = n * 2
        nankai += 1
    array.append(nankai)

kakus = 0
for k in array:
    kaku = 1 / N
    for q in range(k):
        kaku = kaku / 2
    kakus += kaku

print(kakus)


### FIXED CODE ###

N, K = input().split()
N=int(N)
K=int(K)

array = []
for i in range(N):
    n = i+1
    nankai = 0
    while n < K:
        n = n * 2
        nankai += 1
    array.append(nankai)

kakus = 0
for k in array:
    kaku = 1 / N
    for q in range(k):
        kaku = kaku / 2
    kakus += kaku

print(kakus)
import sys
from itertools import accumulate
input = sys.stdin.readline
def inputs():return [int(x) for x in input().split()]
N,C = inputs()
stc = [inputs() for i in range(N)]
ans = [0]*(10**5+1)
for i in range(N):
    s,t,c, = stc[i]
    ans[s]+=1
    ans[t+1]-=1
ans = list(accumulate(ans))
print(max(ans))

### FIXED CODE ###

import sys
from itertools import accumulate
input = sys.stdin.readline
def inputs():return [int(x) for x in input().split()]
N,C = inputs()
stc = [inputs() for i in range(N)]
stc = sorted(stc,key=lambda x:x[1])
stc = sorted(stc,key=lambda x:x[2])
ans = [0]*(10**5+2)
for i in range(N):
    s,t,c, = stc[i]
    if i>0 and c==stc[i-1][2] and s==stc[i-1][1]:
      ans[s+1]+=1
      ans[t+1]-=1
      continue
    ans[s]+=1
    ans[t+1]-=1
ans = list(accumulate(ans))
print(max(ans))