Harryxun/stf_run huggingface dataset:
print(input()[::int(input())]

### FIXED CODE ###

print(input()[::int(input())])
n = int(input())
a = list(map(int,input.split()))

print(max(a)-min(a))

### FIXED CODE ###

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

print(max(a)-min(a))
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


lim = 2*10**5   #必要そうな階乗の限界を入力

#階乗#
fact = [1] * (lim+1)
for n in range(1, lim+1):
	fact[n] = n * fact[n-1] % mod

#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
	fact_inv[n-1] = n*fact_inv[n]%mod

def C(n, r):
	return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod


H, W, A, B = MAP()

ans = 0
for n in range(B, W):
	way = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod
	ans = (ans+way)%mod

print(ans)

### FIXED CODE ###

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

lim = 2*10**6
fact = [1]*(lim+1)
for n in range(1, lim+1):
	fact[n] = n*fact[n-1]%mod

fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
	fact_inv[n-1] = n*fact_inv[n]%mod

def C(n, r):
	return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod

H, W, A, B = MAP()

ans = 0
for n in range(B, W):
	way = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod
	ans = (ans+way)%mod

print(ans)
H, W = input().split()
for i in range(H):
    for k in range(W):
        print("#", end = "")
    print("")


### FIXED CODE ###

while(True):
    H, W = map(int, input().split())
    if(H == 0 and W == 0):
        break
    for i in range(H):
        for k in range(W):
            print("#", end = "")
        print("")
    print("")
import math

a,b = map(int,input().split())
c = math.ceil(a*b/2)
if a = b = 1:
    print(1)
else:
    print(c)


### FIXED CODE ###

import math

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

if a == 1 or b == 1:
    print(1)
else:
    print(math.ceil(a*b/2))
from math import gcd
N = int(input())
A = [int(input()) for _ in range(N)]
B = [0]*(N-1)
B[0] = (A[0]*A[1])//gcd(A[0], A[1])
for i in range(N-2):
  B[i+1] = (A[i+2]*B[i])//gcd(A[i+2], B[i])
print(B[N-1])

### FIXED CODE ###

import fractions
N = int(input())
T = list(int(input()) for _ in range(N))
ans = T[0]
for i in range(1, N):
    ans = ans * T[i] // fractions.gcd(ans, T[i])
print(ans)
import sys
import numpy as np

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

H, W, K = map(int, readline().split())
C = np.frombuffer(read(), 'S1').reshape(H, -1)[:, :W]

C = 1 * (C == b'#')

def f(C, x, y):
    rows = [bool(x & (1<<i)) for i in range(H)]
    cols = [bool(y & (1<<i)) for i in range(W)]
    D = C[rows, cols]
    return D.sum() == K

ans = 0
for x in range(1 << H):
    for y in range(1 << W):
        ans += f(C, x, y)
print(ans)


### FIXED CODE ###

import sys
import numpy as np

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

H, W, K = map(int, readline().split())
C = np.frombuffer(read(), 'S1').reshape(H, -1)[:, :W]

C = 1 * (C == b'#')

def f(C, x, y):
    D = C.copy()
    for i in range(H):
        if x & (1 << i):
            D[i] = 0
    for i in range(W):
        if y & (1 << i):
            D[:, i] = 0
    return D.sum() == K

ans = 0
for x in range(1 << H):
    for y in range(1 << W):
        ans += f(C, x, y)
print(ans)
N,M=map(int,input().split())
A=list(map(int,input().split()))
BC=[list(map(int,input().split())) for _ in range(M)]
count=0
D=[]
BC.sort(key=lambda x:x[1],reverse=True)
A.sort()
for B,C in BC:
  D+=[C]*B
  count+=B
  if count>=N:
    break

if D:
  D=D[:N]
  for i in range(N):
    d=D[i]
    if A[i]<d:
      A[i]=d
    else:
      break
  
print(sum(A))

### FIXED CODE ###

N,M=map(int,input().split())
A=list(map(int,input().split()))
BC=[list(map(int,input().split())) for _ in range(M)]
count=0
D=[]
BC.sort(key=lambda x:x[1],reverse=True)
A.sort()
for B,C in BC:
  D+=[C]*B
  count+=B
  if count>=N:
    break

D=D[:N]
for i in range(len(D)):
  d=D[i]
  if A[i]<d:
    A[i]=d
  else:
    break
  
print(sum(A))
import math
n,d=input().split()
n=int(n)
d=int(d)
def combinations(n, r):
    return math.factorial(n)/(math.factorial(n-r)*math.factorial(r))
x=[]
for i in range(n):
    xa=[int(s) for s in input().split()]
    x.append(xa)
    a=[]
for i in range(n-1):
    for j in range(i+1,n):
        t=[]
        for k in range(d):
            c=(x[i][k]-x[j][k])*(x[i][k]-x[j][k])
            t.append(c)
        if k==d-1:
            a.append(sum(t))
answer=list(map(lambda x:pow(x,1/2),a))
count=0
for l in range(n):
    if answer[l].is_integer()==True:
        count=count+1
print(count)

### FIXED CODE ###

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

N, D = map(int, input().split())
s_lines = sys.stdin.readlines()

ans = 0
X_list_list = []
for s in s_lines:
    new_list = list(map(int, s.split()))
    for i in range(len(X_list_list)):
        sum_num = float(0)
        for idx, ite in enumerate(X_list_list[i]):
            sum_num += (new_list[idx] - ite) ** 2
        if pow(sum_num, 0.5).is_integer():
            ans += 1
    X_list_list.append(new_list)

print(ans)
n = int(input())
n = n%10
if n == 3:
    print("bon")
if n == 0 or n == 1 or n == 6 or n == 8):
    print("pon")
else:
    print("hon")

### FIXED CODE ###

n = int(input())
n = n%10
if n == 3:
    print("bon")
elif n == 0 or n == 1 or n == 6 or n == 8:
    print("pon")
else:
    print("hon")
print(x ** 3)

### FIXED CODE ###

x = input()

print(x ** 3)
def main():
  s = input()
  ans = 'A' s.isupper() else 'a'
  print(ans)
  
  
  
if __name__ == '__main__':
  main()

### FIXED CODE ###

def main():
  s = input()
  ans = 'A' if s.upper() == s else 'a'
  print(ans)
    
    
    
 
if __name__ == '__main__':
  main()
S=input()
K=int(input())
i=0
while int(S[i])<2:
  i+=1
print(int(S[i]))

### FIXED CODE ###

S=input()
K=int(input())
i=0
for i in range(len(S)):
  if int(S[i])>1:
    c=i
    break
if K>i:
  print(int(S[i]))
else:
  print(1)
import numpy as np
import math

# input

r, D, x = [float() for _ in input().split()]

xans = np.ones(10)

def Linear_Recursive(x, r, D, N):
    
    if N==0:
        xans = x
        return xans
    
        
    
    xans = r*Linear_Recursive(x, r, D, N-1) - D # linear eq.
    
    return xans
  
for i in range(10):
    xans[i] = Linear_Recursive(x, r, D, 10)
    
    pritnt(x[i])
    


### FIXED CODE ###

import numpy as np
import math

# input

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

xans = x


for i in range(10):
    xans = r*xans - D
    
    print(xans)
# -*- coding : utf-8 -*-

A = list(input())
B = list(input())
C = list(input())

X = [A,B,C]

x = 0
while True :
  if X[x][0] == "a":
    if X[0] == []:
      print("A")
      break
    else:
      X[0].remove(X[0][0])
      x = 0
  elif X[x][0] == "b":
    if X[1] == []:
      print("B")
      break
    else:
      X[1].remove(X[1][0])
      x = 1
  elif X[x][0] == "c":
    if X[2] == []:
      print("C")
      break
    else:
      X[2].remove(X[2][0])
      x = 2

### FIXED CODE ###

# -*- coding : utf-8 -*-

A = list(input())
B = list(input())
C = list(input())
X = [A,B,C]
t = 0

while True:
  if X[t] == []:
    if t == 0:
      print("A")
      break
    elif t == 1 :
      print("B")
      break
    elif t == 2:
      print("C")
      break
  else:
    if X[t][0] == "a":
      X[t].remove(X[t][0])
      t = 0
    elif X[t][0] == "b":
      X[t].remove(X[t][0])
      t = 1
    elif X[t][0] == "c":
      X[t].remove(X[t][0])
      t = 2
# -*- coding: utf-8 -*-
#ABC136C
import copy
import sys
import math

n = int(input())
tmp = input().split()
hoge = list(map(lambda a: int(a), tmp))
minhoge=hoge[n-1]
for i in range(1,n):
	t=n-1-i
	if(hoge[t]>minhoge+1):
		print("No")
		sys.exit()
	elif(hoge[t]<minhoge):
		minhoge=hoge[t]
	if(t==0):
		print("Yes")
		sys.exit()
print("Yes")





### FIXED CODE ###

# -*- coding: utf-8 -*-
#ABC136D
import copy
import sys
import math

s = input()
n = len(s)

ans=[]
for i in range(0,n):
	ans.append(0)

count=0
for i in range(0,n):
	if(s[i]=="R"):
		count+=1
	else:
		ans[i]+=count//2
		ans[i-1]+=(count-1)//2+1
		count=0

count=0
for i in range(0,n):
	t=n-i-1
	if(s[t]=="L"):
		count+=1
	else:
		ans[t]+=count//2
		ans[t+1]+=(count-1)//2+1
		count=0

res=str(ans[0])
for i in range(1,n):
	res+=" "
	res+=(str(ans[i]))
print(res)
import math
a,b,x=map(int,input().split())
ans=0
flag=False
if x==a*a*b/2:
  ans=a/b
elif x<a*a*b/2:
  t=a-2*x/(a*b)
  ans=(a-t)/b
else:
  t=2*x/(a**2)-b
  if (b-t)!=0:
    ans=a/(b-t)
  else:
    flag=True:
if flag==False:
  print(90-math.degrees(math.atan(ans)))
else:
  print(0)

### FIXED CODE ###

import math
a,b,x=map(int,input().split())
ans=0
flag=False
if x==a*a*b/2:
  ans=a/b
elif x<a*a*b/2:
  t=a-2*x/(a*b)
  ans=(a-t)/b
else:
  t=2*x/(a**2)-b
  if (b-t)!=0:
    ans=a/(b-t)
  else:
    flag=True
if flag==False:
  print(90-math.degrees(math.atan(ans)))
else:
  print(0)
N,M= map(int, input().split())
A=list(map(int, input().split()))
A.sort()
A.reverse()
K=sum(A)
for i in range(0,N):
    if  A[i]>=K/(4*M):
        continue
    else:
        answer=i+1
        break
if answer>=M:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

N,M=map(int, input().split())
A=list(map(int, input().split()))
A.sort()
A.reverse()
K=sum(A)
answer=0
breakflag=0
for i in range(0,N):
  if  A[i]*M*4>=K:
    if i==N-1:
      breakflag=1
    continue
  else:
    answer=i
    break
if breakflag==1:
  answer=N
if answer>=M:
    print("Yes")
else:
    print("No")
n = int(input())
vs = input().split(" ")
cs = input().split(" ")

xy = 0
for i in range(n):
  v = vs[i]
  c = cs[i]
  if v>c:
    xy += v-c

print(xy)

### FIXED CODE ###

n = int(input())
vs = input().split(" ")
cs = input().split(" ")
 
xy = 0
for i in range(n):
  v = int(vs[i])
  c = int(cs[i])
  if v>c:
    xy += v-c
 
print(xy)
S=input()
s=S[6:8]
if '0' in s:
  if s == '10':
     s = s
  else:
    s = s.replace('0','')
n = int(s)
if n<=4:
  print('Heisei')
else:
  print('TBD')
  
  

### FIXED CODE ###

y,m,d = map(int,input().split("/"))
if m<=4:
  print('Heisei')
else:
  print('TBD')
a,b,c = map(int,input().split())
print(c a b)

### FIXED CODE ###

a,b,c = map(str,input().split())
print(c+' '+a+' '+b)
N, M = map(int,input().split())
S = []
C = []
flag = True
for i in range(M):
    s,c = map(int,input().split())
    if s in S:
        if C[S.index(s)] != c:
            flag = False
            break
    if s == M:
        if c == 0:
            flag = False
            break
    S.append(s)
    C.append(c)

if flag:
    n = [1] + [0 for i in range(M - 1)]
    for i in range(len(S)):
        n[S[i]-1] = C[i]
    print(*n, sep="")
else:
    print("-1")

### FIXED CODE ###

N, M = map(int,input().split())
S = []
C = []
flag = True
if N == 1 and M == 0:
    print("0")
    quit()

for i in range(M):
    s,c = map(int,input().split())
    if s in S:
        if C[S.index(s)] != c:
            flag = False
            break
    if s == 1 and N > 1:
        if c == 0:
            flag = False
            break
    S.append(s)
    C.append(c)

if flag:
    n = [1] + [0 for i in range(N - 1)]
    for i in range(len(S)):
        n[S[i]-1] = C[i]
    print(*n, sep="")
else:
    print("-1")
while 1:
 a=list(input().lower())
 [print(chr(97+i),':',a.count(chr(97+i)))for i in range(26)]
 if'.'in a:break

### FIXED CODE ###

import sys;s=sys.stdin.read().lower()
for c in map(chr,range(97,123)):print(c,':',s.count(c))
import math
N = int(input())
A = list(map(int, input().split()))

L = [0]*(N+1)
R = [0]*(N+1)

for i in range(N):
    L[i+1] = math.gcd(L[i], A[i])
    R[N-i-1] = math.gcd(R[N-i], A[N-i-1])

M = []
for i in range(N-1):
    M.append(math.gcd(L[i],R[i+1]))
    
print(max(M))

### FIXED CODE ###

def gcd(a, b):
	while b:
		a, b = b, a % b
	return a

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

L = [0]*(N+1)
R = [0]*(N+1)

for i in range(N):
    L[i+1] = gcd(L[i], A[i])
    R[N-i-1] = gcd(R[N-i], A[N-i-1])
    
M = []
for i in range(N):
    M.append(gcd(L[i],R[i+1]))

print(max(M))
N = int(input())
t0, x0, y0 = map(int, input().split())
flag = True
if (x0+y0)%2 != t0%2 or x0+y0 > t0:
    flag = False
else:
    for _ in range(N-1):
        t1, x1, y1 = map(int, input().split())
        if (x1+y1-x0-y0)%2 != (t1-t0)%2 or (x1+y1-x0-y0) > t1-t0:
            flag = False
            brake
        else:
            t0, x0, y0 = t1, x1, y1
if flag:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

N = int(input())
t0, x0, y0 = map(int, input().split())
flag = True
if (x0+y0)%2 != t0%2 or x0+y0 > t0:
    flag = False
for _ in range(N-1):
    t1, x1, y1 = map(int, input().split())
    if (x1+y1-x0-y0)%2 != (t1-t0)%2 or (x1+y1-x0-y0) > t1-t0:
        flag = False
    t0, x0, y0 = t1, x1, y1
if flag:
    print('Yes')
else:
    print('No')
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))


S=list(ns())
T=list(ns())

INF=10**9
ans=INF
for i in range(len(S)-len(T)):
    tmp=0
    for j in range(len(T)):
        if(S[i+j]!=T[j]):
            tmp+=1
    ans=min(ans,tmp)

print(tmp)
            




### FIXED CODE ###

import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))


S=list(ns())
T=list(ns())

INF=10**9
ans=INF
for i in range(len(S)-len(T)+1):
    tmp=0
    for j in range(len(T)):
        if(S[i+j]!=T[j]):
            tmp+=1
    ans=min(ans,tmp)

print(ans)
n = input()
A = []
for i in range(n):
   A.append(int(raw_input()))

q = input()
M = []
for i in range(n):
   M.append(int(raw_input()))

def solve(i, m)
   if m == 0
     return true
   if i >= n
     return false
   res = solve(i + 1, m) or solve(i + 1, m - A[i])
   return res
for i in M:
   if solve(0,m):
      print "yes"
   else:
      print "no"

 

### FIXED CODE ###

n = input()
A = map(int, raw_input().split())
q = input()
M = map(int, raw_input().split())

def solve(i, m):
   if m == 0:
     return True
   if i >= n or m > sum(A):
     return False
   res = solve(i + 1, m) or solve(i + 1, m - A[i])
   return res

for m in M:
  if solve(0,m):
     print "yes"
  else:
     print "no"
N = int(input())
if N >= 30:
  print(Yes)
else:
  print(No)

### FIXED CODE ###

N = int(input())
if N >= 30:
  print("Yes")
else:
  print("No")
N, M =map(int,input().split())
class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
uf = UnionFind(N)
cnt = 0
for i in range(M):
  x, y, z = map(int, input().split())
  if not uf.is_same(x, y):
    cnt += 1
    uf.union(x,y)
    
print(N-cnt)

### FIXED CODE ###

N, M =map(int,input().split())
class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
uf = UnionFind(N)
cnt = 0
for i in range(M):
  x, y, z = map(int, input().split())
  if not uf.is_same(x-1, y-1):
    cnt += 1
    uf.union(x-1,y-1)
    
print(N-cnt)
D = int(input())
if D == 22:
    print("Christmas Eve Eve Eve")
if D == 23:
    print("Christmas Eve Eve")
if D == 24:
    prtin("Christmas Eve")
if D == 25:
    print("Christmas")

### FIXED CODE ###

D = int(input())
if D == 22:
    print("Christmas Eve Eve Eve")
if D == 23:
    print("Christmas Eve Eve")
if D == 24:
    print("Christmas Eve")
if D == 25:
    print("Christmas")
import fractions


def GCD(a, b):
    if b == 0:
        return a
    else:
        return GCD(b, a % b)


N = int(input())
clock = [0] * N
for j in range(N):
    clock[j] = int(input())
gcd = clock[0]

ans = clock[0]
for i in range(1, N):
    gcd = GCD(ans, clock[i])
    ans = ans/gcd
    ans = ans * clock[i]

print(int(ans))


### FIXED CODE ###

import fractions


def GCD(a, b):
    if b == 0:
        return a
    else:
        return GCD(b, a % b)


N = int(input())
clock = [0] * N
for j in range(N):
    clock[j] = int(input())
gcd = clock[0]

ans = clock[0]
for i in range(1, N):
    gcd = GCD(ans, clock[i])
    ans = ans//gcd
    ans = ans * clock[i]

print(int(ans))
c=0
s=''
p=input().upper()
while True:
    s1=input()
    if s1 =='END_OF_TEXT':
        break
     s+=s1
a=s.upper().split()
for i in a:
    if p in i:
       c+=1
print(c)

### FIXED CODE ###

import re

c=0
p=re.compile(r'^'+input().upper()+r'$')

while True:
    s=input()
    if s =='END_OF_TEXT':
        break
    a=s.upper().split()
    for i in a:
        if re.match(p, i):
            c+=1
print(c)
n = raw_input()
S = raw_input()

N = int(n)
x=0 
y = str(x)
for i in range(0,N):
    if S[i] == "I":
        x = x+1 
        y = y + str(x)
    elif S[i]=="D":
        x = x - 1 
        y = y + str(x)
        
print max([int(c) for c in y])


### FIXED CODE ###

n=int(input())
s=input()
x=0
maxx=0
for char in s:
  if char =='I':
    x+=1
  else:
    x-=1
  if maxx<x:
    maxx=x
print (maxx)
s = str(input())
if s[0]==7 or s[1]==7 or s[2]==7:
  print('Yes')
else:
  print('No'9

### FIXED CODE ###

s = str(input())
if s[0]=='7' or s[1]=='7' or s[2]=='7':
  print('Yes')
else:
  print('No')
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))

ans=0
pre=-1

for i in a:
  ans += b[i-1]
  if(i==pre+1):
    ans += c[i-2]
  pre=i
  
print(ans)

### FIXED CODE ###

n=int(input())
print(n**3)
n=int(input())
if n==100000:
  print(90909)
elif 10000<=n<=99999:
  print((n-10000)+910)
elif 1000<=n<=9999:
  print(909)
elif 100<=n<=999:
  print(n-100)+10
elif 10<=n<=99:
  print(9)
elif 1<=n<=9:
  print(n)


### FIXED CODE ###

n=int(input())
if n==100000:
  print(90909)
elif 10000<=n<=99999:
  print((n-10000)+910)
elif 1000<=n<=9999:
  print(909)
elif 100<=n<=999:
  print((n-100)+10)
elif 10<=n<=99:
  print(9)
elif 1<=n<=9:
  print(n)
H,W = map(int, input().split())
List = []
queue = [(0,0)]
shape = 0
for i in range(H):
    x = input()
    shape += x.count('#')
    List.append(x)

def check(x,y):
    if(x >= W-1 or y >= H-1):
        return
    if(List[y][x] == '#')
        return
    queue.append((x,y))

while(len(queue) != 0):
    x,y = queue[0]
    queue.pop(0)
    check(x+1,y)
    check(x, y+1)
if(flag == 1):
    print(H*W - (H-1 + W-1 + 1) - shape)
else:
    print(-1)


### FIXED CODE ###

H,W = map(int, input().split())
List = []
queue = [(0,0,1)]
shape = 0
used ={(0,0)}
for i in range(H):
    x = input()
    shape += x.count('#')
    List.append(x)

def check(x,y,c):
    if(x>W-1 or y>H-1 or x<0 or y<0):
        return
    if(List[y][x] == '#'):
        return
    if(x,y) in used:
        return
    queue.append((x,y,c+1))
    used.add((x,y))

flag = -1
while(len(queue) != 0):
    x,y,c = queue[0]
    if x==W-1 and y==H-1:
        flag = 1
        break
    queue.pop(0)
    check(x+1,y,c)
    check(x, y+1,c)
    check(x-1,y,c)
    check(x, y-1,c)
if(flag == 1):
    print(H*W - c - shape)
else:
    print(-1)
N,C=map(int,input().split())
imos=[0]*(10**5)
for i in range(N):
  s,t,c=map(int,input().split())
  imos[s-1]+=1
  imos[t]-=1
channels=[imos[0]]*(10**5)
for i in range(10**5-1):
  channels[i+1]=channels[i]+imos[i+1]
print(max(channels))

### FIXED CODE ###

N,C=map(int,input().split())
cha=[[0 for i in range(10**5+1)] for j in range(C)]
for i in range(N):
  s,t,c=map(int,input().split())
  cha[c-1][s-1:t]=[1]*(t-s+1)
channels=0
for i in range(10**5+1):
  chans=0
  for c in range(C):
    chans+=cha[c-1][i]
  channels=max(channels,chans)
print(channels)
N=int(input())
M=int(input())
if N>M:
  	print(N-M)
else:
  	print(-1)

### FIXED CODE ###

N,M=map(int,input().split())
A=list(map(int,input().split()))
B=0
for i in A:
    B=B+i       
N=N-B
if 0<=N:
    print(N)
else:
    print(-1)
n = int(input())
li = [list(map(lambda x:int(x),input().split())) for i in range(n)]
ok = False
for i in range(n-1):
    mo = (li[i+1][2] - li[i][2]) + (li[i+1][1] - li[i][1])
    ti = li[i+1][0] - li[i][0]
    if (mo%2)==(ti%2) and mo<=ti and ((mo==0 and ti == 0) or (mo!=0 and ti != 0)):
        ok = True
if ok :
    print("Yes")
else :
    print("No")

### FIXED CODE ###

N = int(input())
li = list(map(int,input().split()))
li2 = list(map(int,input().split()))
sum = 0
max = 0
for k in range(N):
    for m in range(N-k):
        sum += li[m]
    for l in range(N-1-k,N):
        sum+=li2[l]
    if (max<=sum):
        max = sum
    sum = 0
print(max)
N, K = map(int, input().split())
List = list(map(int, input().split()))
count = 0
for i in List:
  if i>=K:
    count +=
print(count)

### FIXED CODE ###

N, K = map(int, input().split())
List = list(map(int, input().split()))
count = 0
for i in List:
  if i>=K:
    count += 1
print(count)
a,b,c = int(input().split())
 
for i in range(c):
  if(a == 0):
  	b -= 1
  elif(a > 0):
    a -= 1
print(str(a),str(b))

### FIXED CODE ###

a,b,c = map(int, input().split())
 
print(max(0,a-c),max(0, b - max(0,c-a)))