Harryxun/stf_run huggingface dataset:
from itertools import *
from more_itertools import *

n,m,q=map(int,input().split())

aaa=[]
for i in range(m):
    aaa.append(i+1)

l=[]
for i in range(q):
    a=list(map(int,input().split()))
    l.append(a)

a=list(combinations_with_replacement(aaa,n))
ans=0
for i in a:
    aa=0
    for j in l:
        if i[j[1]-1]-i[j[0]-1]==j[2]:
            aa+=j[3]
    if aa>ans:
        ans=aa
print(ans)

### FIXED CODE ###

from itertools import *

n,m,q=map(int,input().split())

aaa=[]
for i in range(m):
    aaa.append(i+1)

l=[]
for i in range(q):
    a=list(map(int,input().split()))
    l.append(a)

a=list(combinations_with_replacement(aaa,n))
ans=0
for i in a:
    aa=0
    for j in l:
        if i[j[1]-1]-i[j[0]-1]==j[2]:
            aa+=j[3]
    if aa>ans:
        ans=aa
print(ans)
import itertools

N=int(input())
P=list(map(int, input().split()))
Q=list(map(int, input().split()))
A=list(range(1,N+1))

Pattern=[]
for i in itertools.permutations(A):
    Pattern.append(i)

c1=Pattern.index(P) + 1
c2=Pattern.index(Q) + 1

print(abs(c1-c2))

### FIXED CODE ###

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

if 500*K >= X:
    print("Yes")
else:
    print("No")
S = int(input())
yymm = S//100
mmyy = S%100
yymm = (1<=y<=12)
mmyy = (1<=x<=12)

ans = "NA"
if yymm and mmyy:
    answer = 'AMBIGUOUS'
elif yymm and not(mmyy):
    answer = 'YYMM'
elif mmyy and not(yymm):
    answer = 'MMYY'

print(ans)  

### FIXED CODE ###

import sys
input = sys.stdin.readline

S = input().rstrip()
l = [0]*2
y = S[:2]
m = S[2:]
l[0] = 0 if "01" <= y <= "12" else 1
l[1] = 1 if "01" <= m <= "12" else 0

if l[0] == 0 and l[1] == 1:
  print("AMBIGUOUS")
elif l[0] == 1 and l[1] == 1:
  print("YYMM")
elif l[0] == 0 and l[1] == 0:
  print("MMYY")  
else:
  print("NA")
#ナップザック問題
import numpy as np

N,W=map(int,input())
wv = np.array([list(map(int, input().split())) for i in range(0, N)])  


dp=np.zeros((N+1,W+1),dtype=int)
for n in range(0, N):  
    for w in range(0, W + 1):  
        if w < wv[n, 0]:  
            dp[n+1, w] = dp[n, w]  
        else:  
            dp[n+1, w] = max(dp[n, w], dp[n, w - wv[n, 0]] + wv[n, 1])  
print(dp[N,W])  

### FIXED CODE ###

N,W=map(int,input().split())
DP=[[0 for j in range(W+1)]for i in range(N+1)]
for i in range(N):
    w,v=map(int,input().split())
    for j in range(1,W+1):
        if j>=w:
            DP[i+1][j]=max(DP[i][j-w]+v,DP[i][j])
        else:
            DP[i+1][j]=DP[i][j]
print(DP[N][W])
a= int(input())
b,c=map(int, input().split())

s=input()

print (str(a+b+c)+" "+s)

### FIXED CODE ###

x,y=map(int, input().split())


a = [0, 1, 3, 1, 2, 1, 2, 1, 1, 2, 1, 2, 1]

if a[x] == a[y]:
    print("Yes")
else:
    print("No")
def qqq(n):
     
        a = int(n/100)
        if a == 7: 
            return "Yes" 
        
        n %= 100
        b = int(n/10)
        if b == 7:
            return "Yes"
        
        n %= 10
        if n == 7:
            return "Yes"
     
        return "No"
     
    if __name__ == '__main__':
        N = int(input())
        print (qqq(N))

### FIXED CODE ###

def qqq(n):

    a = int(n/100)
    if a == 7: 
        return "Yes" 
    
    n %= 100
    b = int(n/10)
    if b == 7:
        return "Yes"
    
    n %= 10
    if n == 7:
        return "Yes"

    return "No"

if __name__ == '__main__':
    N = int(raw_input())
    print qqq(N)
def quick_sort(arr):
    left = []
    right = []
    if len(arr) <= 1:
        return arr

    # データの状態に左右されないためにrandom.choice()を用いることもある。
    # ref = random.choice(arr)
    ref = arr[0]
    ref_count = 0

    for ele in arr:
        if ele < ref:
            left.append(ele)
        elif ele > ref:
            right.append(ele)
        else:
            ref_count += 1
    left = quick_sort(left)
    right = quick_sort(right)
    return left + [ref] * ref_count + right

def LCM(m,n):
  for i in range(1,m+1)[::-1]:
    if n%i==0:
      return i
    
N,X=(int(i) for i in input().split(' '))
x=[int(i) for i in input().split(' ')]
x=[X]+x
x=quick_sort(x)
D=abs(x[1]-x[0])
for i in range(N):
  D=LCM(D,abs(x[i+1]-x[i]))
print(D)

### FIXED CODE ###

s = [int(i) for i in input().split()]
if(s[0] * s[1] % 2 == 1):
    print("Yes")
else:
    print("No")
w,h,x,y = map(int, input().split())
men = float(w * h / 2)
r1 = float(w/x)
r2 = float(h/y)
if w/x == h/y:
    han = 1
else:
    han = 0
print("{} {}".format(men,han))

### FIXED CODE ###

w,h,x,y = map(int, input().split())
men = float(w * h / 2)
if (2*x == w) and (2*y == h):
    han = 1
else:
    han = 0
print("{} {}".format(men,han))
x=int(input())
if x==3||x==5||x==7:
  print("YES")
else:
  print("NO")


### FIXED CODE ###

x=int(input())
if x==3 or x==5 or x==7:
  print("YES")
else:
  print("NO")
l = [a,b,c,d,e,f,g,h,i,j]
a,b,c,d,e,f,g,h,i,j = int(input())
l.sort()
print(l[-1])
print(l[-2])
print(l[-3])

### FIXED CODE ###

l = []
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
f = int(input())
g = int(input())
h = int(input())
i = int(input())
j = int(input())

l.append(a)
l.append(b)
l.append(c)
l.append(d)
l.append(e)
l.append(f)
l.append(g)
l.append(h)
l.append(i)
l.append(j)

l.sort()
print(l[-1])
print(l[-2])
print(l[-3])
k = int(input())
anss = [1,2,3,4,5,6,7,8,9]
for i in range(12):
    if len(anss) > k:
        print(new_anss[k-1])
        break
    new_anss = []
    for ans in anss:
        if ans % 10 != 0:
            new_anss += [ans*10+ans%10-1]
        new_anss += [ans*10+ans%10]
        if ans % 10 != 9:
            new_anss += [ans*10+ans%10+1]
    k -= len(anss)
    anss = new_anss

### FIXED CODE ###

k = int(input())
anss = [1,2,3,4,5,6,7,8,9]
for i in range(12):
    if len(anss) > k:
        print(anss[k-1])
        break
    new_anss = []
    for ans in anss:
        if ans % 10 != 0:
            new_anss += [ans*10+ans%10-1]
        new_anss += [ans*10+ans%10]
        if ans % 10 != 9:
            new_anss += [ans*10+ans%10+1]
    k -= len(anss)
    anss = new_anss
s=str(input())
st=list(s)
l=len(st)
if st[0]="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" st[4]=="n" and st[5]=="c" and st[6]=="e":
  print("YES")
elif st[l-7]="k" and st[l-6]=="e" and st[l-5]=="y" and st[l-4]=="e" st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]="k" and st[l-6]=="e" and st[l-5]=="y" and st[l-4]=="e" st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]="k" and st[1]=="e" and st[l-5]=="y" and st[l-4]=="e" st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]="k" and st[1]=="e" and st[2]=="y" and st[l-4]=="e" st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" st[4]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" st[4]=="n" and st[5]=="c" and st[l-1]=="e":
  print("YES")
else:
  ptint("NO")

### FIXED CODE ###

s=str(input())
st=list(s)
l=len(st)
if st[0]=="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" and st[4]=="n" and st[5]=="c" and st[6]=="e":
  print("YES")
elif st[l-7]=="k" and st[l-6]=="e" and st[l-5]=="y" and st[l-4]=="e" and st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]=="k" and st[l-6]=="e" and st[l-5]=="y" and st[l-4]=="e" and st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]=="k" and st[1]=="e" and st[l-5]=="y" and st[l-4]=="e" and st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]=="k" and st[1]=="e" and st[2]=="y" and st[l-4]=="e" and st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]=="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" and st[l-3]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]=="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" and st[4]=="n" and st[l-2]=="c" and st[l-1]=="e":
  print("YES")
elif st[0]=="k" and st[1]=="e" and st[2]=="y" and st[3]=="e" and st[4]=="n" and st[5]=="c" and st[l-1]=="e":
  print("YES")
else:
  print("NO")
N = int(input())
d = list(map(int, input().split()))

d.sort()

left = d[N//2]
right = d[N//2 +1]

dif = right - left

print(dif)

### FIXED CODE ###

N = int(input())
d = list(map(int, input().split()))

d.sort()
left = d[int(N/2-1)]
right = d[int(N/2)]

dif = right - left

print(dif)
# coding: utf-8

def bubblesort(ls):
    count = 0
    
    for i in range(1, len(ls)):
        for j in reversed(range(i, len(ls))):
            if ls[j] < ls[j-1]:
                ls[j], ls[j-1] = ls[j-1], ls[j]
                count += 1
    return count

def main():
    trash = input()
    ls = list(map(int, input))

    i = bubblesort(ls)

    print(ls)
    print(i)
    
if __name__ == '__main__':
    main()

### FIXED CODE ###

# coding: utf-8

def bubblesort(ls):
    count = 0
    
    for i in range(1, len(ls)):
        for j in reversed(range(i, len(ls))):
            if ls[j] < ls[j-1]:
                ls[j], ls[j-1] = ls[j-1], ls[j]
                count += 1
    return count

def main():
    trash = input()
    ls = list(map(int, input().split(' ')))

    i = bubblesort(ls)

    print(' '.join((map(str,ls))))
    print(i)
    
if __name__ == '__main__':
    main()
s = input()[0]
print("A"+s+"C"

### FIXED CODE ###

s = input()[8]
print("A"+s+"C")
n=int(input())
if n>=400 and n<=599:
	print("8")
elif n>=600 and n<=799:
	print("7")
elif n>=800 and n<=999:
	print("6")
elif n>=1000 and n<=1199:
	print("5')
elif n>=1200 and n<=1399:
	print("4")
elif n>=1400 and n<=1599:
    print("3")
elif n>=1600 and n<=1799:
    print("2")
elif n>=1800 and n<=1999:
	print("1")

### FIXED CODE ###

n=int(input())
if n>=400 and n<=599:
  print("8")
elif n>=600 and n<=799:
  print("7")
elif n>=800 and n<=999:
  print("6")
elif n>=1000 and n<=1199:
  print("5")
elif n>=1200 and n<=1399:
  print("4")
elif n>=1400 and n<=1599:
  print("3")
elif n>=1600 and n<=1799:
  print("2")
elif n>=1800 and n<=1999:
  print("1")
import math
a, b, c, d = map(int, input().split())

print(b - b//c - b//d + b//((c*d)//math.gcd(c, d)) - (a-1 - (a-1)//c - (a-1)//d + (a-1)//((c*d)//math.gcd(c, d))))

### FIXED CODE ###

from fractions import gcd
a, b, c, d = map(int, input().split())

c_count = b//c
d_count = b//d
# 最小公倍数で割る
c_d = b//(c*d//gcd(c, d))

print(b - c_count - d_count + c_d - (a-1 - (a-1)//c - (a-1)//d + (a-1)//(c*d//gcd(c, d))))
import sys
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))

sys.setrecursionlimit(10 ** 9)


def main():
    N, M = MAP()
    X = LIST()

    if M == 1:
        print(0)
        sys.exit()

    X = sorted(X)

    H = []
    heapify(H)
    for i in range(len(X)-1):
        heappush(H, (X[i+1] - X[i])*(-1))

    for i in range(N-1): heappop(H)

    print(sum(H)*(-1))


if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))

sys.setrecursionlimit(10 ** 9)


def main():
    N, M = MAP()
    X = LIST()

    if M == 1 or N >= M:
        print(0)
        sys.exit()

    X = sorted(X)

    H = []
    heapify(H)
    for i in range(len(X)-1):
        heappush(H, (X[i+1] - X[i])*(-1))

    for i in range(N-1): heappop(H)

    print(sum(H)*(-1))


if __name__ == '__main__':
    main()
while True:
    n, x = map(int, raw_input().split())
    if not n and not x :
        break
    count = 0
    for i in range(1:n-1):
        for j in range(i+1,n):
            for k in range(j+1, n+1):
                if i+j+k == x :
                    count += 1
    print count

### FIXED CODE ###

while True:
    n, x = map(int, raw_input().split())
    if not n and not x :
        break
    count = 0
    for i in range(1,n-1):
        for j in range(i+1,n):
            for k in range(j+1, n+1):
                if i+j+k == x :
                    count += 1
    print count
n,a,b=[int(_) for_ in input().split()]
if n==1:
  if a==b:
    print(1)
  else:
    print(0)
print(max(0,(n-2)*(b-a)+1)

### FIXED CODE ###

n,a,b=[int(_) for _ in input().split()]
if n==1:
  if a==b:
    print(1)
  else:
    print(0)
  exit()
print(max(0,(n-2)*(b-a)+1))
n = int(input())
x = input()

original_pop_count = x.count('1')
one_pop_count = original_pop_count - 1
zero_pop_count = original_pop_count + 1

one_mod = 0
zero_mod = 0
for b in x:
    if one_pop_count != 0
        one_mod = (one_mod *2 + int(b))%one_pop_count
        zero_mod = (zero_mod *2 + int(b))%zero_pop_count

f = [0]*220001
pop_count = [0]*220000
for i in range(1, 220000):
    pop_count[i] = pop_count[i//2] + i%2
    f[i] = f[i%pop_count[i]] + 1

one_pow2 = [1]*220000
zero_pow2 = [1]*220000
for i in range(1, 220001):
    if one_pop_count != 0
        one_pow2[i] = one_pow2[i-1] *2 % one_pop_count
        zero_pow2[i] = zero_pow2[i-1] *2 % zero_pop_count

for i in range(n-1, -1, -1):
    if x[n-1-i] == '1':
        if one_pop_count != 0
            nxt = one_mod
            nxt -= one_pow2[i]
            nxt %= one_pop_count
            print(f[nxt]+1)
        else:
            print(0)

    if x[n-1-i] == '0':
        nxt = zero_mod
        nxt += zero_pow2[i]
        nxt %= zero_pop_count
        print(f[nxt]+1)

### FIXED CODE ###

n = int(input())
x = input()

original_pop_count = x.count('1')
one_pop_count = original_pop_count - 1
zero_pop_count = original_pop_count + 1

one_mod = 0
zero_mod = 0
for b in x:
    if one_pop_count != 0:
        one_mod = (one_mod *2 + int(b))%one_pop_count
    zero_mod = (zero_mod *2 + int(b))%zero_pop_count

f = [0]*220001
pop_count = [0]*220001
for i in range(1, 220001):
    pop_count[i] = pop_count[i//2] + i%2
    f[i] = f[i%pop_count[i]] + 1

one_pow2 = [1]*220001
zero_pow2 = [1]*220001
for i in range(1, 220001):
    if one_pop_count != 0:
        one_pow2[i] = one_pow2[i-1] *2 % one_pop_count
    zero_pow2[i] = zero_pow2[i-1] *2 % zero_pop_count

for i in range(n-1, -1, -1):
    if x[n-1-i] == '1':
        if one_pop_count != 0:
            nxt = one_mod
            nxt -= one_pow2[i]
            nxt %= one_pop_count
            print(f[nxt]+1)
        else:
            print(0)

    if x[n-1-i] == '0':
        nxt = zero_mod
        nxt += zero_pow2[i]
        nxt %= zero_pop_count
        print(f[nxt]+1)
n,k=(int(i) for i in input().split())
l=[i for i in range(1,n+1)]
for i in range(k):
  d=input()
  for i in input().split():
    l[i]=0
c=0
for i in l:
  if(i>0):
    c+=1
print(c)

### FIXED CODE ###

n,k=(int(i) for i in input().split())
l=[1 for i in range(1,n+1)]
for i in range(k):
  d=input()
  l1=[int(j) for j in input().split()]
  for j in l1:
      l[j-1]=0
c=0
for i in l:
  if(i>0):
    c+=1
print(c)
N = input()

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

cnt = []
cnt2 = 0
while(int(N)-cnt2 != 0):
  s = a.count(a[0])-1
  cnt.append(s)
  a.remove(a[0])
  cnt2 += s+1
  print(cnt)
su = sum(cnt)
print(int(N)-su)

### FIXED CODE ###

N = input()

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

cnt = {s:(a.count(s)-1) for s in a}

print(int(N)-sum([int(j) for j in cnt.values()]))
#C
import sys

a,b=map(int,input().split())
for i in range(1,1000):
    if int(i*0.08)==a and int(i*0.1)==b:
        print(i,i*0.08,i*0.1)
        break
    if i==999:
        print(-1)
        sys.exit()

print(ans)


### FIXED CODE ###

import sys
a,b=map(int,input().split())
f=True
for i in range(1,1010):#max_a=1
    if int(i*0.08)==a and int(i*0.1)==b:
        ans=i
        f=False
        break
if f:
  print(-1)
else:
  print(ans)
r = int(nput())
print(int(r**2))

### FIXED CODE ###

r = int(input())
print(r*r)
from collections import defaultdict, deque

n, m = [int(i) for i in raw_input().split()]

# children = defaultdict(list)
parents = defaultdict(list)

for _ in range(m):
    u, v = [int(i) for i in raw_input().split()]
    # children[u-1].append(v-1)
    parents[v-1].append(u-1)

def get_f(parents, f, i):
    if i in f:
        return f[i]

    f[i] = 0
    for v in parents[i]:
        f[i] = max(f[i], get_f(parents, f, v) + 1)

    return f[i]

def longest_path(parents, n):
    f = defaultdict(lambda: -1)
    # targets = [x for y in children.values() for x in y]
    # starts = [v for v in range(n) if v not in targets]

    # print f
    for i in xrange(n):
        get_f(parents, f, i)

    # print f
    return max(f)

# def longest_path(children, parents, n):
#     targets = [x for y in children.values() for x in y]
#     starts = [v for v in range(n) if v not in targets]
#     f = [None] * n
    
#     Q = deque([])
#     for v in starts:
#         f[v] = 0
#         Q.append((v, 0))

#     output = 0
#     while len(Q) > 0:
#         node, length = Q.pop()
#         output = max(output, length)
#         for v in children[node]:
#             Q.append((v, length+1))

#     return output

print(longest_path(parents, n))

### FIXED CODE ###

from collections import defaultdict
import sys
sys.setrecursionlimit(1000000)

n, m = [int(i) for i in raw_input().split()]
parents = defaultdict(list)

i = 0
while i < m:
    u, v = [int(x) for x in raw_input().split()]
    parents[v-1].append(u-1)
    i += 1

def calc_f(parents, f, i):
    if i < 0 or i >= len(f):
        return 0

    if f[i] != -1:
        return f[i]

    f[i] = 0
    for v in parents[i]:
        f[i] = max(f[i], calc_f(parents, f, v)+1)

    return f[i]

f = [-1] * n
j = 0
while j < n:
    calc_f(parents, f, j)
    j += 1

if len(f) == 0:
    print 0
else:
    print max(f)
sys.setrecursionlimit(10**7)
n = int(input())
g = [[] for _ in range(n)]

for _ in range(n-1):
    u,v,w = map(int,input().split())
    g[u-1].append((v-1,w))
    g[v-1].append((u-1,w))
    
ans = [0] * n

def dfs(v,p,c):
    ans[v] = c
    for i in g[v]:
        if i[0] != p:
            if i[1] % 2 ==0:
                dfs(i[0],v,c)
            else:
                dfs(i[0],v,1-c)

dfs(0,-1,0)

for i in ans:
    print(i)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**7)
n = int(input())
g = [[] for _ in range(n)]

for _ in range(n-1):
    u,v,w = map(int,input().split())
    g[u-1].append((v-1,w))
    g[v-1].append((u-1,w))
    
ans = [0] * n

def dfs(v,p,c):
    ans[v] = c
    for i in g[v]:
        if i[0] != p:
            if i[1] % 2 ==0:
                dfs(i[0],v,c)
            else:
                dfs(i[0],v,1-c)

dfs(0,-1,0)

for i in ans:
    print(i)
def combi(y,x,p=998244353):
  s=fac[y]
  t=fac[x]
  u=fac[y-x]
  ans= (s* pow(t,p-2,p)*pow(u,p-2,p))%p
  return ans

###############################

N,M,K=map(int,input().split())
p=998244353
fac=[1,1]
for i in range(2,N+1):
  fac.append( (fac[-1]*i)%p )
R = M*(M-1)**(N-K-2)

ans=0
for i in range(K,-1,-1):
  R = (R*(M-1))%p
  L = combi(N-1,i)
  #print(i,R,L)
  ans = (ans + (R*L)%p)%p
print(ans)

### FIXED CODE ###

def combi(y,x,p=998244353):
  s=fac[y]
  t=fac[x]
  u=fac[y-x]
  ans= (s* pow(t,p-2,p)*pow(u,p-2,p))%p
  return ans

###############################

N,M,K=map(int,input().split())
p=998244353
fac=[1,1]
for i in range(2,N+1):
  fac.append( (fac[-1]*i)%p )


ans=0
for i in range(0,K+1):
  R = ( (M%p) *pow(M-1,N-1-i,p) )%p
  L = combi(N-1,i)
  ans = (ans + (R*L)%p)%p
  
print(ans)
N = int(input())
p = list(map(int, input().split()))
for i in range(N):
    for j in range(i + 1, N):
        if p[j - 1] < p[i] < p[j + 1] and p[i - 1] < p[j] < p[i + 1]:
            print("YES")
            exit()
        else:
            continue
print("NO")


### FIXED CODE ###

N = int(input())
p = list(map(int, input().split()))
count = 0
for i in range(N):
    if p[i] != i + 1:
        count += 1
if count == 0 or count == 2:
    print("YES")
else:
    print("NO")
a,b = map (int , input().split())
if b % a == 0 ;
    c = a+b
else;
    c = b-a
print (c)

### FIXED CODE ###

a,b = map (int , input().split())
if b % a == 0 :
    c = a+b
else:
    c = b-a
print (c)
N =input(int())
i =input(int())
print(int(N+1-i))

### FIXED CODE ###

N, i = map(int, input().split())
print(int(N-i+1))
import fractions
a, b, c, d = [int(i) for i in input().split()]

c_left = [a // c - 1, a // c][a % c != 0]
c_right = b // c

c_number = c_right - c_left

d_left = [a // d - 1, a // d][a % d != 0]
d_right = b // d

d_number = d_right - d_left
cdgcd = int(c * d / fractions.gcd(c, d))

cd_left = [a // (cdgcd - 1), a // (cdgcd)][a % (cdgcd) != 0]
cd_right = b // (cdgcd)

cd_number = cd_right - cd_left


print(b - a + 1 -  (c_number + d_number - cd_number))

### FIXED CODE ###

import fractions

a, b, c, d = [int(i) for i in input().split()]

if c == 1 or d == 1:
    print(0)
    exit()

c_left = max(0, [a // c - 1, a // c][a % c != 0])
c_right = b // c

d_left = max(0, [a // d - 1, a // d][a % d != 0])
d_right = b // d

cdgcd = (c * d) // fractions.gcd(c, d)

cd_left = max(0, [a // cdgcd - 1, a // (cdgcd)][a % (cdgcd) != 0])
cd_right = b // (cdgcd)

c_number = c_right - c_left
d_number = d_right - d_left
cd_number = cd_right - cd_left

print(b - a + 1 - (c_number + d_number - cd_number))
S =int(input())
h = int(S / 3600)
m = int((S - h*3600)/60)
s = int(S -(h*3600+m*60))

print(h,':',m,":",s sep ="")

### FIXED CODE ###

S = int(input())
h = int(S // 3600)
m = int((S - h*3600)// 60 )
s = int(S - (h*3600+m*60))

print(h,m,s, sep=':' )
N = int(input())
A = list(map(int,input().split()))

MAX = []
e = 1
for a in A:
    if e > 0:
        MAX.append(e)
        e -= a
        e *= 2
    else:
        print(-1)
        exit()

A.reverse()
MAX.reverse()
ans = []
s = 0
for i,a in enumerate(A):
    if MAX[i] < s//2 + a:
        ans[-1] = (MAX[i] - a) * 2 + 1
        s = MAX[i]
    else:
        s += a
        s = min(MAX[i],s)
    ans.append(s)
print(sum(ans))

### FIXED CODE ###

N = int(input())
A = list(map(int,input().split()))

SUM = sum(A)

ans = 0
node = 1
for i,leaf in enumerate(A):
    if i == 0:
        non_leaf = 1 - leaf
        ans += 1
        if non_leaf <0:
            print(-1)
            exit()
    else:
        left,right = non_leaf,non_leaf*2
        if SUM < left or non_leaf <= 0:
            print(-1)
            exit()
        node = min(right,SUM)
        ans += node
        non_leaf = node - leaf
        SUM -= leaf
        if non_leaf < 0:
            print(-1)
            exit()

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


A = [-1]*(M+100)
A[0] = X
i = 0
tmpans = 0
flag = False
check = [-1]*(M+1)
slice = -1
while i< N-1:
    newa = A[i]**2%M
    i+= 1
    if check[newa] != -1:
        flag = True
        slice = check[newa]
        break
    A[i] = newa
    check[newa] = i

if not flag:
    print(sum(A[:i+1]))

else:
    print(sum(A[:slice])+ sum(A[slice:i])*((N-slice)//(i-slice))+sum(A[slice:slice + (N-slice)%(i-slice)]))


### FIXED CODE ###

s = input()
if s[-1] == "s":
    print(s + "es")
else:
    print(s + "s")
H,N=map(int, input().split())
A = list(map(int, input().split()))

if(sum(A) > H):
  print("Yes")
else:
  print("No")


### FIXED CODE ###

H,A=map(int, input().split())

count = 0;

while(H > 0):
  H -= A
  count += 1
  
print(count)
N = int(input())
A = list(map(int, input().split()))
lis = [0] * (10**5)
Q = int(input())
for x in A:
  lis[x] += 1 * x
for i in range(Q):
  B, C = map(int, input().split())
  try:
    temp = lis[B] // B
    lis[B] = 0
    lis[C] += temp * C
  except:
    pass
  print(sum(lis))

### FIXED CODE ###

from collections import Counter
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
su = sum(A)
counter = Counter(A)
lis = {}
for i in range(Q):
  B, C = map(int, input().split())
  su -= B * counter[B]
  su += C * counter[B]
  counter[C] += counter[B]
  counter[B] = 0
  print(su)