Harryxun/stf_run huggingface dataset:
N = int(input())
a = list(map(int, input().split()))

INF = 10**18

dp0 = [[INF] * N for _ in range(N)]
dp1 = [[INF] * N for _ in range(N)]

def calc(i, j, t):
    if t == 0:
        if dp0[i][j] == INF:
            if i == j:
                dp0[i][j] = a[i]
            else:
                dp0[i][j] = max(calc(i+1, j, 1) + a[i], calc(i, j-1, 1) + a[j])
        return dp0[i][j]
    else:
        if dp1[i][j] == INF:
            if i == j:
                dp1[i][j] = -a[i]
            else:
                dp1[i][j] = min(calc(i+1, j, 0) - a[i], calc(i, j-1, 0) - a[j])
        return dp1[i][j]

print(calc(0, N-1, 0))

### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**8)

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

INF = 10**18
dp = [[INF] * N for _ in range(N)]

# def calc(i, j, t):
#     if dp[i][j] != INF:
#         return dp[i][j]
#     if t == 0:
#         if i == j:
#             dp[i][j] = a[i]
#         else:
#             dp[i][j] = max(calc(i+1, j, 1) + a[i], calc(i, j-1, 1) + a[j])
#     else:
#         if i == j:
#             dp[i][j] = -a[i]
#         else:
#             dp[i][j] = min(calc(i+1, j, 0) - a[i], calc(i, j-1, 0) - a[j])
#     return dp[i][j]

# print(calc(0, N-1, 0))

for l in range(N):
    t = (N-l) % 2
    for i in range(N-l):
        j = i + l
        if t == 1:
            if l == 0:
                dp[i][j] = a[i]
            else:
                dp[i][j] = max(dp[i+1][j] + a[i], dp[i][j-1] + a[j])
        else:
            if l == 0:
                dp[i][j] = -a[i]
            else:
                dp[i][j] = min(dp[i+1][j] - a[i], dp[i][j-1] - a[j])
print(dp[0][N-1])
n, m = map(int, input().split())
py = [list(map(int, input().split()))for i in range(m)]
pre = [[] for i in range(n)]
for i in range(3): pre[py[i][0]-1].append(py[i][1])
for i in range(n): pre[i].sort()
for i in range(3):
    j = pre[py[i][0]-1].index(py[i][1])
    print("%06d%06d" % (py[i][0], j+1))

### FIXED CODE ###

from sys import stdin
input = stdin.readline
n, m = map(int, input().split())

ans = sorted([list(map(int, input().split()))+[i] for i in range(m)], key=lambda x:x[1])

built = [1]*n
for i in range(m):
    ans[i][1] = built[ans[i][0]-1]
    built[ans[i][0]-1] += 1

for i in sorted(ans,key=lambda x:x[2]): print("%06d%06d" % (i[0],i[1]))
N = int(input())
A = [int(n) for n in input().split()]

cnt = 0
for in range(N):
    if A[i] % 2 == 1:
        cnt += 1

if cnt % 2 == 0:
    print ('YES')
else:
    print('NO')


### FIXED CODE ###

N = int(input())
A = [int(n) for n in input().split()]

cnt = 0
for i in range(N):
    if A[i] % 2 == 1:
        cnt += 1

if cnt % 2 == 0:
    print ('YES')
else:
    print('NO')
a, b=map(int, input().split())
li = [a+b,a-b,a＊b]

print(max(li))

### FIXED CODE ###

a, b=map(int, input().split())
li = [a+b, a-b, a*b]

print(max(li))
import numpy as np
from numba import njit


@njit
def main(I):
    N,K=I[0],I[1]
    A = np.array(I[2:],dtype=int)
    A.sort()
    lb = -10**18-1
    rb = 10 ** 18 + 1
    while rb - lb > 1:
        target = (rb + lb) // 2
        if 1:
            cnt=0
            for i, a in enumerate(A):
                if a==0:
                    d = i if target >= 0 else 0
                elif a < 0:
                    il = np.searchsorted(A,0- (-target)//a,side='left')
                    d = max(i - il, 0)
                else:
                    ir = np.searchsorted(A,target//a,side='right')
                    d = min(ir, i)
                cnt+=d
        if cnt>=K:
            rb = target
        else:
            lb = target
    return rb

I=np.array([int(_) for _ in open(0).read().split()],dtype=int)
print(main(I))

### FIXED CODE ###

import numpy as np
from numba import njit
N,K=[int(_) for _ in input().split()]
A = np.array([int(_) for _ in input().split()],dtype=int)
A.sort()


@njit
def main(N,K,A):
    lb = -10**18-1
    rb = 10 ** 18 + 1
    while rb - lb > 1:
        target = (rb + lb) // 2
        if 1:
            cnt=0
            for i, a in enumerate(A):
                if a==0:
                    d = i if target >= 0 else 0
                elif a < 0:
                    il = np.searchsorted(A,0- (-target)//a,side='left')
                    d = max(i - il, 0)
                else:
                    ir = np.searchsorted(A,target//a,side='right')
                    d = min(ir, i)
                cnt+=d
        if cnt>=K:
            rb = target
        else:
            lb = target
    return rb

print(main(N,K,A))
n= int(input())

mat = [[0]*(10)]*(10)

for i in range(1,n+1):
  a,b = str(i)[0],str(i)[-1]:
  mat[a][b] += 1

ans = 0
for i in range(1,10):
  for j in range(1,10):
    ans += mat[i][j]*mat[j][i]
print(ans)


### FIXED CODE ###

n= int(input())

mat = [ [0]*10 for i in range(10)]

for i in range(1,n+1):
  a,b = int(str(i)[0]), i%10
  mat[a][b] += 1

ans = 0
for i in range(1,10):
  for j in range(1,10):
    ans += mat[i][j]*mat[j][i]

print(ans)
import sys


def solve(n, m, links, parents):
    if m % 2 == 1:
        print(-1)
        return

    fixed = [len(l) % 2 == 0 for l in links]

    def reverse_links(s, t):
        v = s
        while v != t:
            p = parents[v]
            links[p][v] ^= 1
            v = p

    tmp_trace = set()
    tmp_pair = -1
    for v in range(n):
        if fixed[v]:
            continue
        if tmp_pair == -1:
            u = v
            while u != -1:
                tmp_trace.add(u)
                u = parents[u]
            tmp_pair = v
        else:
            u = v
            while u != -1:
                if u in tmp_trace:
                    reverse_links(v, u)
                    reverse_links(tmp_pair, u)
                    break
                u = parents[u]
            else:
                raise AssertionError
            tmp_trace.clear()
            tmp_pair = -1

        # print(v, tmp_vertices, tmp_pair)

    assert tmp_pair == -1

    ans = []
    for v in range(n):
        for u, d in links[v].items():
            if d == 0:
                ans.append('{} {}'.format(v + 1, u + 1))
            else:
                ans.append('{} {}'.format(u + 1, v + 1))
    print('\n'.join(ans))


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

first_links = []
for line in sys.stdin:
    a, b = map(int, line.split())
    a -= 1
    b -= 1
    if a > b:
        a, b = b, a
    first_links.append((a, b))
first_links.sort()

links = [{} for _ in range(n)]
parents = [-1] * n
for a, b in first_links:
    links[a][b] = 0
    if parents[b] == -1:
        parents[b] = a

solve(n, m, links, parents)


### FIXED CODE ###

import sys
from collections import deque

sys.setrecursionlimit(10 ** 5)


def solve(n, m, links):
    if m % 2 == 1:
        print(-1)
        return

    tree = [set() for _ in range(n)]
    parents = [-1] * n
    q = deque([0])
    while q:
        v = q.popleft()
        for u in links[v]:
            if parents[u] == -1:
                tree[v].add(u)
                parents[u] = v
                q.append(u)
            links[u].remove(v)

    parities = [len(l) % 2 for l in links]

    # print(links)
    # print(tree)
    # print(parents)
    # print(parities)

    def dfs(v):
        b = parities[v]
        for u in tree[v]:
            c = dfs(u)
            b ^= c
        if b:
            p = parents[v]
            links[p].remove(v)
            links[v].add(p)
        return b

    dfs(0)

    ans = ['{} {}'.format(v + 1, u + 1) for v in range(n) for u in links[v]]
    print('\n'.join(ans))


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

links = [set() for _ in range(n)]
for line in sys.stdin:
    a, b = map(int, line.split())
    a -= 1
    b -= 1
    links[a].add(b)
    links[b].add(a)

solve(n, m, links)
n=int(input())
tree=[[]for _ in range(n+1)]
for _ in range(n-1):
    u,v,w=map(int,input().split())
    tree[u].append([v,w])
    tree[v].append([u,w])
d=[-1]*(n+1)
d[1]=0
q=[1]
while q:
    now=q.pop()
    for n_i,n_l in tree[now]:
        if d[n_i]==-1:
            d[n_i]=d[now]+[n_l]
            q.append(n_i)
for l in d[1:]:
    print(l%2)

### FIXED CODE ###

from collections import deque

N = int(input())
S = [[]for i in range(N)]
for i in range(N-1):
    u,v,w = map(int,input().split())
    S[u-1].append([v-1,w])
    S[v-1].append([u-1,w])
Node = [None]*N
Node[0] = True
queue = deque([0])
while queue != deque([]):
    p = queue.popleft()
    for u,w in S[p]:
        if Node[u] == None:
            queue.append(u)
            Node[u] = (Node[p])^(w%2==1)
for i in range(N):
    print([0,1][Node[i]])
a,b,c,d=input().split()
if abs(a-c)<=d:
  print('Yes')
elif abs(a-b)<=d and abs(b-c)<=d:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

a,b,c,d=map(int, input().split())
if abs(a-c)<=d:
  print('Yes')
elif abs(a-b)<=d and abs(b-c)<=d:
  print('Yes')
else:
  print('No')
s = list(input())

return (s in "a") & (s in "b") & (s in "c")

### FIXED CODE ###

s = list(input())

if (("a" in s) & ("b" in s) & ("c" in s)):
    print("Yes")
else:
    print("No")
N, M = map(int, input().split())
L = [0] * N
D = {}
c = 1
for i in range(M):
  A, B = map(int, input().split())
  if L[A - 1] == L[B - 1] == 0:
    D[c] = set()
    D[c].add(A)
    D[c].add(B)
    L[A - 1] = c
    L[B - 1] = c
    c += 1
  elif L[A - 1] == 0:
    D[L[B - 1]].add(A)
    L[A - 1] = L[B - 1]
  elif L[B - 1] == 0:
    D[L[A - 1]].add(B)
    L[B - 1] = L[A - 1]
  elif L[A - 1] != L[B - 1]:
    D[L[A - 1]] |= D[L[B - 1]]
    for j in D.pop(L[B - 1]):
      L[j - 1] == L[A - 1]
  #print(L, D, sep = "\n")
print(len(D) + L.count(0) - 1)
        

### FIXED CODE ###

N, M = map(int, input().split())
L = [0] * N
D = {}
c = 1
for i in range(M):
  A, B = map(int, input().split())
  if L[A - 1] == L[B - 1] == 0:
    D[c] = set()
    D[c].add(A)
    D[c].add(B)
    L[A - 1] = c
    L[B - 1] = c
    c += 1
  elif L[A - 1] == 0:
    D[L[B - 1]].add(A)
    L[A - 1] = L[B - 1]
  elif L[B - 1] == 0:
    D[L[A - 1]].add(B)
    L[B - 1] = L[A - 1]
  elif L[A - 1] != L[B - 1]:
    if len(D[L[A - 1]]) < len(D[L[B - 1]]):
      A, B = B, A
    D[L[A - 1]] |= D[L[B - 1]]
    for j in D.pop(L[B - 1]):
      L[j - 1] = L[A - 1]
  #print(L, D, sep = "\n")
print(len(D) + L.count(0) - 1)
N, M, K = map(int, input().split())
A = list(input().split())
B = list(input().split())

a=0;b=0
cnt=0
while a < len(A) and b < len(B) and K > 0:
	a_ = A[a]
	b_ = B[b]
    
    if a_ > K and b_ > K:
      break
      
    if a_ < b_ and a_ <= K:
		cnt += 1
		K -= a_
		A.pop(0)
	elif a_ >= b_ and b_ <= K:
      cnt += 1
      K -= b_
      B.pop(0)
      
print(cnt)   
      

### FIXED CODE ###

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

A = [0]
B = [0]
ans = 0

for i in range(n):
    A.append(A[i] + a[i])

for i in range(m):
    B.append(B[i] + b[i])

j = m

for i in range(n + 1):
    if A[i] > k:
        break
    while A[i] + B[j] > k:
        j -= 1
    ans = max(ans, i + j)

print(ans)
n=int(input())
m=[]
for i in range(1,n+1):
 a=i
 if a%3==0:
  m.append(i)
  continue
 while a>0:
  if a%10==3:
   m.append(i)
   break
  a/=10
print(' '+*m)

### FIXED CODE ###

print('',*[i for i in range(3,int(input())+1)if i%3==0 or'3'in str(i)])
n,m = map(int,input().split())
a = list(range(m+2))
a[0] = -1
a[m+1] = n+1
ans = 1
for i in range(m):
  a[i+1] = int(input())
for i in range(m+1):
  if a[i]+1 == a[i+1] and i != 0 and i != m:
    ans = 0
    break
  else:
    x = a[i+1]-a[i]-1
    ans = ans * int(1/(5**0.5) * (((1+(5**0.5))/2)**x - ((1-(5**0.5))/2)**x)) %1000000007

if m == 0:
    x = a[m+1]-a[i]-1
    ans = int(1/(5**0.5) * (((1+(5**0.5))/2)**x - ((1-(5**0.5))/2)**x)) %1000000007

print(ans)


### FIXED CODE ###

n,m = map(int,input().split())
b = [] 
for i in range(n+1):
  if i == 0 or i == 1:
    b.append(1)
  else:
    b.append(b[i-2]+b[i-1])

ans = 1
if m != 0:
  a = list(range(m))
  for i in range(m):
    a[i] = int(input())
    if i == 0:
      ans = ans*b[a[i]-1]%1000000007
    else:
      if a[i] == a[i-1]+1:
        ans = 0
      else:
        ans = ans*b[a[i]-a[i-1]-2]%1000000007
  ans = ans*b[n-a[m-1]-1]%1000000007
  print(ans)
else:
  print(b[n]%1000000007)
n = int(input())
     
    last = None
    seen = set()
    for _ in range(n):
      w = input()
      if w in seen or (last and last[-1] != w[0]):
        print("No")
        break
      seen.add(w)
    else:
      print("Yes")

### FIXED CODE ###

n = int(input())

last = None
seen = set()
for _ in range(n):
  w = input()
  if w in seen or (last and last[-1] != w[0]):
    print("No")
    break
  seen.add(w)
  last = w
else:
  print("Yes")
n=int(input())
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
c=[int(i) for i in input().split()]

res = 0
prev = -1
for i in range(n):
  res += b[a[i]]
  if prev+1 == a[i]:
    res += c[prev]
  prev = a[i]

print(res)

### FIXED CODE ###

n=int(input())
a=[0]+[int(i) for i in input().split()]
b=[0]+[int(i) for i in input().split()]
c=[0]+[int(i) for i in input().split()]
 
res = 0
prev = -1
for i in range(1, n+1):
    res += b[a[i]]
    if prev+1 == a[i]:
        res += c[prev]
    prev = a[i]

print(res)
L,R= map(int,input().split())
#境界条件
bool = True
l = L % 2019
r = R % 2019
if l == 0 or r == 0:
    ans = 0
else:
    for i in range(l,r):
        for j in range(i+1,r+1):
            temp = (i * j) % 2019
            if bool:
                min = temp
                bool = False
            elif min > temp:
                min = temp
                ans = min
print(ans)

### FIXED CODE ###

L,R= map(int,input().split())
#境界条件
bool = True
flag = False
for i in range(L,R):
    for j in range(i+1,R+1):
        temp = (i * j) % 2019
        if bool:
            min = temp
            ans = min
            bool = False
        elif min > temp:
            min = temp
            ans = min
        if min == 0:
            flag = True
            break
    if flag:
        break
print(ans)
x,y = map(int,input().split())
if x%2!==y%2:
  print('IMPOSSIbLE')
else: print((x+y)/2)  

### FIXED CODE ###

x,y = map(int,input().split())
if x%2!=y%2:
  print('IMPOSSIBLE')
else:
  print(int((x+y)/2))
import re

given = input("")

result = re.search(r"([0-9]+)\s([0-9]+)", given)

a = int(result.group(1))
b = int(result.group(2))

if a == b:
    print(a, ==, b)

elif a < b:
    print(a, <, b)

else:
    print(a, >, b)

### FIXED CODE ###

a, b = map(int, input().split())
if a<b:
    print("a < b")

elif a>b:
    print("a > b")

else:
    print("a == b")
A, B=map(int, input().split())
if (B-1)/(A-1)==(B-1)//(A-1):
	print((B-1)/(A-1))
else:
	ptint((B-1)//(A-1)+1)

### FIXED CODE ###

A, B=map(int, input().split())
a=(B-1)/(A-1)
b=(B-1)//(A-1)
if a==b:
    print(b)
else:
	print(b+1)
a,b,c=int(input())
print(a+b+c)

### FIXED CODE ###

a,b,c=map(int,input())
print(a+b+c)
while True:
    try:
        a,b=(int(i) for i in input().split())
        print(len(str(a+b)))
    except EOFError:

### FIXED CODE ###

while True:
    try:
        a,b=(int(i) for i in input().split())
        print(len(str(a+b)))
    except EOFError:
        break
from sys import stdin
input = stdin.readline
N, M = map(int, input().split())
# d = [0] * (N + 1)
adj = [[] for _ in range(N + 1)]
for _ in range(M):
    x, y = map(int, input().split())
    adj[x].append(y)
    # d[y] += 1

dp = [-1] * (N + 1)


def lp(x: 'int') -> 'int':
    if dp[x] >= 0:
        return dp[x]
    else:
        dp[x] = 0
        for y in adj[x]:
            dp[x] = max(dp[x], lp(y) + 1)
        return dp[x]


print(max(lp(i) for i in range(1, N + 1)))


### FIXED CODE ###

from sys import stdin, setrecursionlimit
# input = stdin.readline
setrecursionlimit(200000)
N, M = map(int, input().split())
# d = [0] * (N + 1)
adj = [[] for _ in range(N + 1)]
for _ in range(M):
    x, y = map(int, input().split())
    adj[x].append(y)
    # d[y] += 1

dp = [-1] * (N + 1)


def lp(x: 'int') -> 'int':
    if dp[x] >= 0:
        return dp[x]
    else:
        dp[x] = 0
        for y in adj[x]:
            dp[x] = max(dp[x], lp(y) + 1)
        return dp[x]


print(max(lp(i) for i in range(1, N + 1)))
from bisect import bisect_right
n,X = map(int,input().split())
a = list(map(int,input().split()))
ind = bisect_right(a,X)
if ind == 0:
    print(a[1]-X)
else:
    print(min(a[ind]-X,X-a[ind-1]))


### FIXED CODE ###

def gcd(a,b):
    if b == 0:
        return a
    return gcd(b,a%b)
n,X = map(int,input().split())
x = [abs(X-int(i)) for i in input().split()]
g = x[0]
for i in range(1,n):
    g = gcd(g,x[i])
print(g)
H,W,M = map(int, input().split())
bombmat = [[0]*(W+1) for _ in range(H+1)]
bomb_row = [0]*M; bomb_col = [0]*M
for i in range(M):
    h,w = map(lambda x: int(x)-1, input().split())
    bombmat[h][w] = 1
    bombmat[H][w] += 1
    bombmat[h][W] += 1
    
    bomb_row[i] = h
    bomb_col[i] = w

row_H = bombmat[H]
maxcol = 0
for col in range(W):
    maxcol = max(maxcol, row_H[col])

maxcollist = [False]*W
for col in range(W):
    if row_H[col] == maxcol:
        maxcollist[col] = True

maxrow = 0
for row in range(H):
    maxrow = max(maxrow, bombmat[row][W])

maxrowlist = [False]*H
for row in range(H):
    if bombmat[row][W] == maxrow:
        maxrowlist[row] = True

#最高行または最高列上にあり、
#かつ最高行と最高列の交点にない爆弾があるかをチェック
cross_cnt = sum(maxrowlist) * sum(maxcollist)
for i in range(M):
    h,w = bomb_row[i], bomb_col[w]
    if maxrowlist[h] and maxcollist[w]:
        cross_cnt -= 1

if cross_cnt > 0:
    print(maxcol + maxrow)
else:
    print(maxcol + maxrow - 1)

### FIXED CODE ###

from sys import stdin
input = stdin.readline

H,W,M = map(int, input().split())

sum_row = [0]*H; sum_col = [0]*W
bomb_row = [0]*M; bomb_col = [0]*M
for i in range(M):
    h,w = map(int, input().split())
    sum_row[h-1] += 1
    sum_col[w-1] += 1
    
    bomb_row[i] = h-1
    bomb_col[i] = w-1

maxcol = max(sum_col)
maxcollist = [False]*W
for col in range(W):
    if sum_col[col] == maxcol:
        maxcollist[col] = True

maxrow = max(sum_row)
maxrowlist = [False]*H
for row in range(H):
    if sum_row[row] == maxrow:
        maxrowlist[row] = True

#最高行または最高列上にあり、
#かつ最高行と最高列の交点にない爆弾があるかをチェック
cross_cnt = sum(maxrowlist) * sum(maxcollist)
for i in range(M):
    h,w = bomb_row[i], bomb_col[i]
    if maxrowlist[h] and maxcollist[w]:
        cross_cnt -= 1

if cross_cnt > 0:
    print(maxcol + maxrow)
else:
    print(maxcol + maxrow - 1)
#import numpy as np
import sys
input = sys.stdin.readline


def main():
    h, n = map(int, input().split())
    A = []
    B = []
    for _ in range(n):
        a, b = map(int, input().split())
        A.append(a)
        B.append(b)
        
    m = 2 * 10**4 + 10
    dp = [0] * (h+1)
    for a, b in zip(A, B):
        dp[a] = b
        for i in range(h):
            for a, b in zip(A, B):
                if i + a < m and dp[i] > 0:
                    j = min(i+a, h)
                    if dp[j] > 0:
                        dp[j] = min(dp[j], dp[i] + b)
                    else:
                        dp[j] = dp[i] + b
    k = h
    # print(dp[:20])
    # while (flag):
    #     if dp[k] > 0:
    #         ans = dp[k]
    #         flag = 0
    #     k += 1
    # d = np.array(dp[k:])
    # print(np.min(d[d.nonzero()]))
    print(dp[h])
    
    
main()


### FIXED CODE ###

#import numpy as np
import sys
input = sys.stdin.readline


def main():
    h, n = map(int, input().split())
    # A = []
    # B = []
    # for _ in range(n):
    #     A.append(a)
    #     B.append(b)
        
    m = 2 * 10**4 + 10
    dp = [float("inf")] * (h+1)
    dp[0] = 0
    # for a, b in zip(A, B):
    #     dp[a] = b
    for _ in range(n):
        a, b = map(int, input().split())
        for i in range(h):
            # for a, b in zip(A, B):
            if i + a < m :
                j = min(i+a, h)
                if dp[j] > 0:
                    dp[j] = min(dp[j], dp[i] + b)
                else:
                    dp[j] = dp[i] + b
    k = h
    # print(dp[:20])
    # while (flag):
    #     if dp[k] > 0:
    #         ans = dp[k]
    #         flag = 0
    #     k += 1
    # d = np.array(dp[k:])
    # print(np.min(d[d.nonzero()]))
    print(dp[h])
    
    
main()
from math import atan, atan2, degrees

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

th = atan2(a, b)

tmp1 = atan(a**3 / (2 * (a**2 * b - x)))
tmp2 = atan(2 * x / (a * b**2))

if tmp1 <= th:
    print(90 - degrees(tmp2))
else:
    print(90 - degrees(tmp1))

### FIXED CODE ###

from math import atan, atan2, degrees

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

th = atan2(a, b)

if a**2*b == x:
    print(0)
else:
    tmp1 = atan(a**3 / (2 * (a**2 * b - x)))
    tmp2 = atan(2 * x / (a * b**2))

    if tmp1 <= th:
        print(90 - degrees(tmp2))
    else:
        print(90 - degrees(tmp1))
"""
author : halo2halo
date : 29, Jan, 2020
"""

import sys
import itertools

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

A, B = read().decode('utf8').split()
print(2*B-A)


### FIXED CODE ###

"""
author : halo2halo
date : 29, Jan, 2020
"""

import sys
import itertools

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

A, B = map(int,read().decode('utf8').split())
print(2*B-A)
l,r=map(int,input().split())
if(r-l>=2018):
  print(0)
else:
  mi=2018
  res1=l%2019
  for i in range(r-l):
    res2=(i+l+1)%2019
    for j in range(r-l-i):
      if (res1*res2)%2019<mi:
        mi=(res1*res2)%2019
      res2+=1
    res1+=1
  print(mi)

### FIXED CODE ###

N,a,b=map(int,input().split())
print(min(N*a,b))
n = int(input())
print(pow(n / 3, 3))

### FIXED CODE ###

n, m = input().split()
n = int(n)
m = int(m)
ans = (n * (n - 1) / 2) + (m * (m - 1) / 2)
print(round(ans))
N, X = map(int, input().split())
x_list = list(map(int, input().split()))

x_abs = []
for i in x_list:
    x_abs.append(abs(X - i))

def gcd(i, j):
    if i % j == 0:
        return j
    else:
        k = i % j
        gcd(j, k)

x_abs.sort(reverse=True)
ans = 0
if len(x_abs) == 1:
    ans = x_abs[0]
else:
    for i in range(N-2):
        temp = gcd(x_abs[i], x_abs[i + 1])
        ans = gcd(temp, x_abs[i + 2])
    
print(ans)

### FIXED CODE ###

from fractions import gcd
from functools import reduce
n,x = map(int,input().split())
 
l=list(map(int,input().split()))
l=list(map(lambda i: abs(i-x),l))
 
x = reduce(gcd,l)
print(x)
from collections import deque

    H, W = map(int, input().split())
    ch, cw = map(lambda x: int(x)-1, input().split())
    dh, dw = map(lambda x: int(x)-1, input().split())
    S = [list(input()) for _ in range(H)]
    dist = [[-1] * W for _ in range(H)]

    q = deque()
    q.append((0, ch, cw))
    while q:
        c, h, w = q.popleft()
        if dist[h][w] >= 0:
            continue
        dist[h][w] = c
        for hh in range(-2, 3):
            for ww in range(-2, 3):
                if 0 <= h+hh < H and 0 <= w+ww < W and S[h+hh][w+ww] == "." and dist[h+hh][w+ww] < 0:
                    if (hh, ww) in ((0,1), (1,0), (-1,0), (0,-1)):
                        q.appendleft((c, h+hh, w+ww)) # 徒歩は前に追加
                    else:
                        q.append((c+1, h+hh, w+ww)) # ワープは後ろに追加

    print(dist[dh][dw])

### FIXED CODE ###

from collections import deque

H, W = map(int, input().split())
ch, cw = map(lambda x: int(x)-1, input().split())
dh, dw = map(lambda x: int(x)-1, input().split())
S = [list(input()) for _ in range(H)]
dist = [[-1] * W for _ in range(H)]

q = deque()
q.append((0, ch, cw))
while q:
    c, h, w = q.popleft()
    if dist[h][w] >= 0:
        continue
    dist[h][w] = c
    for hh in range(-2, 3):
        for ww in range(-2, 3):
            if 0 <= h+hh < H and 0 <= w+ww < W and S[h+hh][w+ww] == "." and dist[h+hh][w+ww] < 0:
                if (hh, ww) in ((0,1), (1,0), (-1,0), (0,-1)):
                    q.appendleft((c, h+hh, w+ww)) # 徒歩は前に追加
                else:
                    q.append((c+1, h+hh, w+ww)) # ワープは後ろに追加

print(dist[dh][dw])