Harryxun/stf_run huggingface dataset:
inp = input().split()
l = int(inp[0])
r = int(inp[1])

int_list_pre = list(range(l,r+1))
int_list = [s%2019 for s in int_list_pre]
l = len(int_list)
min_mod = 2018

for i in range(l):
    for j in range(l):
        if j > i:
            compare = (int_list[i] * int_list[j])%2019
            if compare < min_mod:
                min_mod = compare


print(min_mod)




### FIXED CODE ###

inp = input().split()
l = int(inp[0])
r = int(inp[1])

if r - l > 2019:
    print(0)
else:
    int_list_pre = list(range(l,r+1))
    int_list = [s%2019 for s in int_list_pre]
    l_l = len(int_list)
    min_mod = 2018

    for i in range(l_l):
        for j in range(l_l):
            if j > i:
                compare = (int_list[i] * int_list[j])%2019
                if compare < min_mod:
                    min_mod = compare


    print(min_mod)
n,k = map(int,input().split())
li = list(map(int,input().split()))
li = list(map(lambda x:(x+1)/2,li))
wk = 0
nn = n-k+1
kai = [None]*(nn)

for y in range(nn):
    wk = 0
    for x in range(y,k+y):
        wk = wk + li[x]
    kai[x] = wk
 
print(max(kai))

### FIXED CODE ###

n,k = map(int,input().split())
li = list(map(int,input().split()))
li = list(map(lambda x:(x+1)/2,li))

wk = 0
nn = n-k

for i in range(0,k):
    wk += li[i]
kwk = wk
for j in range(nn):
    wk = wk - li[j]
    wk = wk + li[j+k]
    kwk = max(wk,kwk)
 
print(kwk)
N , T = map(int, input().split())
mini = T
x = 0
y = 0
for i in range(N):
    c , t = input().split()
for j in range(N-1):
    if int(t[j])<mini:
        mini = int(t[j])
        x = j
if mini<T:
    print(c[j-1])
else:
    print("TLE")

### FIXED CODE ###

N,T=map(int,input().split())
c=[]
mn=1001
for i in range(N):
    cost,time=map(int,input().split())
    if time<=T:
        c.append(cost)
for i in c:
    if i<=mn:
        mn=i
if len(c)==0:
    print('TLE')
else:
    print(mn)
n,k = input().split()
d = list(input().split())

ans = ''

for i in range(10):
    if not str(i) in d:
        sm = str(i)
        break

for i in range(len(str(n))):
    if n[i] in d:
        co = str(int(n[i])+1)
        while(1):
            if not co in d:
                break
            co = co + 1
        ans = ans + co + sm*(len(n)-i-1)
        break
    else:
        ans = ans + n[i]
print(ans)




### FIXED CODE ###

n, k = map(int, input().split())
d = list(input().split())

while 1:
    if all(dd not in str(n) for dd in d):
        print(n)
        break
    n = n+1
lis=list(map(int,input().split()))
alist=[-1]
for i in range(lis[1]):
    alist.append(int(input()))
alist.append(lis[0]+1)
flag=0
ans=0
for i in range(lis[1]):
    if alist[i+1]-alist[i]==1:
        flag=1
        break
if flag==0:
    steps=[0]*(lis[0]+1)
    if 1 in alist:
        steps[1]=0
        steps[2]=1
    elif 2 in alist:
        steps[1]=1
        steps[2]=1
    else:
        steps[1]=1
        steps[2]=2
    for i in range(3,lis[0]+1):
        if i in alist:
            steps[i]=steps[i-1]
            flag=2
        elif flag==2:
            steps[i]=steps[i-1]
            flag=3
        elif flag==3:
            steps[i]=steps[i-1]
            flag=0
        else:
            steps[i]=(steps[i-1]+steps[i-2])%((10**9)+7)
    ans=steps[-1]

print(ans)


### FIXED CODE ###

lis=list(map(int,input().split()))
alist=[0]*(lis[0]+1)
for i in range(lis[1]):
    a=int(input())
    alist[a]=1
steps=[0]*(lis[0]+2)
steps[1]=1
mod=(10**9)+7
for i in range(2,lis[0]+2):
    if alist[i-1]==0:
        steps[i]=(steps[i-1]+steps[i-2])%mod
ans=steps[-1]
print(ans)
N, M = map(int, input().split())

m = map(int,read().split())
ST = zip(m,m)
 
edge_out = [[] for i in range(N)] #edge_out[i]はiから出ている道
edge_in = [[] for i in range(N + 1)] # edge_in[i]はiに行く道
 
for s,t in ST:
    edge_out[s].append(t)
    edge_in[t].append(s)
    

edge_sum = [len(edge_out[i]) for i in range(N)] # edge_sum[i] = iから出ている道の本数

dp = [0.0]*(N + 1) # dp[i]はiからNへの距離の期待値
dp[N - 1] = 1.0
# 道を塞がない場合
for i in range(N - 2, 0, - 1):
    dp[i] = 1 + sum(dp[j] for j in edge_out[i])/edge_sum[i]
    
p_to_i = [0]*(N + 1) # p_to_i[i]は1から各iへ到達する確率
p_to_i[1] = 1
for i in range(2, N + 1):
    p_to_i[i] = sum(p_to_i[j]/edge_sum[j] for j in edge_in[i])


t = 0

for i in range(1, N - 1):
    if edge_sum[i] == 1:
        continue
        # iから出ている道の先にある部屋のうち、その部屋からNまでの距離の期待値が最も大きいものへ通ずる道を塞ぐ
    t = max(t, p_to_i[i]*(dp[i] - 1- ((dp[i] - 1)*edge_sum[i] - max(dp[j] for j in edge_out[i]))/(edge_sum[i] - 1)))
    
print(dp[1] - t)

### FIXED CODE ###

N, M = map(int, input().split())
edge_out = [[] for i in range(N)] #edge_out[i]はiから出ている道
edge_in = [[] for i in range(N + 1)] # edge_in[i]はiに行く道
for i in range(M):
    s, t = map(int, input().split())
    edge_out[s].append(t)
    edge_in[t].append(s)

edge_sum = [len(edge_out[i]) for i in range(N)] # edge_sum[i] = iから出ている道の本数

dp = [0.0]*(N + 1) # dp[i]はiからNへの距離の期待値
dp[N - 1] = 1.0
# 道を塞がない場合
for i in range(N - 2, 0, - 1):
    dp[i] = 1 + sum(dp[j] for j in edge_out[i])/edge_sum[i]
    
p_to_i = [0]*(N + 1) # p_to_i[i]は1から各iへ到達する確率
p_to_i[1] = 1
for i in range(2, N + 1):
    p_to_i[i] = sum(p_to_i[j]/edge_sum[j] for j in edge_in[i])


t = 0

for i in range(1, N - 1):
    if edge_sum[i] == 1:
        continue
        # iから出ている道の先にある部屋のうち、その部屋からNまでの距離の期待値が最も大きいものへ通ずる道を塞ぐ
    t = max(t, p_to_i[i]*(dp[i] - 1- ((dp[i] - 1)*edge_sum[i] - max(dp[j] for j in edge_out[i]))/(edge_sum[i] - 1)))
    
print(dp[1] - t)
S=int(input())
h = s//3600
m = (s-h*3600)//60
s = (S-(h*3600)-(m*60))
print (str(h)+":"+str(m)+":"+str(s))


### FIXED CODE ###

x=int(input())
h = x//3600
m = (x-h*3600)//60
s = (x-(h*3600)-(m*60))
print (h,m,s,sep=":")
# -*- coding: utf-8 -*-

import numpy as np

N = input()
# N = int(input())
# t = np.array(list(map(int, input().split())))
t = map(int, raw_input().split())

odd = t[0::2]
even = t[1::2]

rest = 0

for _k in [odd, even]:
    uni = list(set(_k))
    cnt = np.zeros((len(uni), ))
    for _i in _k:
        cnt[uni.index(_i_)] += 1
    # unique = np.unique(odd, return_counts=True)
    # rest += len(_k) - count[np.argmax(count)]
    rest += len(_k) - np.max(cnt)
print rest


### FIXED CODE ###

# -*- coding: utf-8 -*-
import numpy as np
from collections import Counter
N = input()
t = np.array(map(int, raw_input().split()))

odd = t[0::2]
even = t[1::2]
rest = 0

co = Counter(odd)
ce = Counter(even)

omc = co.most_common()
emc = ce.most_common()

if omc[0][0] == emc[0][0]:
    if len(omc) < 2 and len(emc) < 2:       # same
        rest = len(even)
    elif len(omc) < 2:
        rest = len(even)
    elif len(emc) < 2:
        rest = len(odd)
    else:
        or1 = len(odd) - co.most_common()[0][1]
        or2 = len(odd) - co.most_common()[1][1]
        er1 = len(even) - ce.most_common()[0][1]
        er2 = len(even) - ce.most_common()[1][1]

        if or1 + er2 > or2 + er1:
            rest = or2 + er1
        else:
            rest = or1 + er2
else:
    rest = len(odd) - co.most_common()[0][1] + len(even) - ce.most_common()[0][1]


print rest
n, x = map(int,input().split())
L = list(map(int,input().split()))
d, cnt = 0, 1
for i in range(1,n+2):
  d = d + L[i-1]
  if d <= x:
    cnt+=1
  else:
    break
print(cnt)

### FIXED CODE ###

n, x = map(int,input().split())
L = list(map(int,input().split()))
D = [0]*(n+1)
cnt = 1

for i in range(n):
  D[i+1] = D[i] + L[i]
  if D[i+1]<=x:
    cnt+=1

print(cnt)
n = int( input ())
s = sum(list( map ( int ,list ( str ( n ) ) ) )
if n % s == 0:
  ans = 'Yes'
else :
  ans = 'No'
print(ans)

### FIXED CODE ###

n = input ()
s = sum(list( map ( int , list(n))))
num = int(n)
if num % s == 0 :
  ans = 'Yes'
else :
  ans = 'No'
print(ans)
l,r=map(int,input().split())
s=list(range(l,r+1))
ans=2018
for i in range(l,r):
    for j in range(i+1,r+1):
        ans=min(i*j%2019,ans)
        if ans==0:
            exit()
print(ans)

### FIXED CODE ###

l,r=[int(i) for i in input().split()]
ans=2018
for i in range(l,r):
    for j in range(i+1,r+1):
        ans=min(i*j%2019,ans)
        if ans==0:
            print(ans)
            exit()
print(ans)
S=input()
S=int(S)

W=input()
W=int(W)

if W>=S:
  print("unsafe")
  else:
    print("safe")

### FIXED CODE ###

s, w = input().split(" ")

s = int(s)
w = int(w)

if w >= s:
    print("unsafe")
else:
    print("safe")
a = [str(i) for i in input()]

for bit in range(2 ** (len(a)+1)):
	s = a.copy()

	for i in range(0,len(a)+1):
		if (bit >> i) & 1:
			s.insert(i*2, "A")
			
	if "".join(s) == "AKIHABARA":
		print("YES")
		exit()

print("NO")

	

### FIXED CODE ###

a = [str(i) for i in input()]

if len(a) > 10:
	print("NO")
	exit()

for bit in range(2 ** (len(a)+1)):
	s = a.copy()

	for i in range(0,len(a)+1):
		if (bit >> i) & 1:
			s.insert(i*2, "A")
			
	if "".join(s) == "AKIHABARA":
		print("YES")
		exit()

print("NO")
a=input()
A=int(a.split()[0])
B=int(a.split()[1])
K=int(a.split()[2])

a=0
if(A>B): i=A
if(B>A): i=B
count=0
while(a==0):
  if(A%i==0 and B%i==0):
    count+=1
    if(count==K):
      print(i)
      break
  i-=1

### FIXED CODE ###

a=input()
A=int(a.split()[0])
B=int(a.split()[1])
K=int(a.split()[2])

a=0
if(A>B): i=A
else: i=B
count=0
while(a==0):
  if(A%i==0 and B%i==0):
    count+=1
    if(count==K):
      print(i)
      break
  i-=1
def main():
    s = " "+input()
    N = len(s)-1

    t = " "+input()
    M = len(t)-1
    if N < M:
        N, M = M, N
        s, t = t, s
    # dp[i][j] := sのi文字目, tのj文字目までを使ったLCSの長さ
    # last_letter[i][j] := s_i, t_jまでを使ったLCSの最後の文字
    dp = [[-1]*(M+1) for i in range(N+1)]
    last_letter = [[-1]*(M+1) for i in range(N+1)]
    dp[0] = [0]*(N+1)
    last_letter[0] = ['' for n in range(N+1)]
    for i in range(N+1):
        dp[i][0] = 0
        last_letter[i][0] = ''
    for i in range(1, N+1):
        for j in range(1, M+1):
            
            if s[i] == t[j]:
                dp[i][j] = dp[i-1][j-1]+1
                last_letter[i][j] = s[i]
            elif s[i] != t[j]:
                if dp[i-1][j] > dp[i][j-1]:
                    dp[i][j] = dp[i-1][j]
                    last_letter[i][j] = last_letter[i-1][j]
                else:
                    dp[i][j] = dp[i][j-1]
                    last_letter[i][j] = last_letter[i][j-1]
    print(get(s, t, N, M, dp, last_letter))

def get(s, t, i, j, dp, last_letter):
    if i == 0 or j == 0:
        return ""
    ll = last_letter[i][j]
    if s[i]==t[j]==ll:
        return get(s, t, i-1, j-1, dp, last_letter) + s[i]
    elif ll == s[i] and ll != t[j]:
        return get(s, t, i, j-1, dp, last_letter)
    elif ll == t[j] and ll != s[i]:
        return get(s, t, i-1, j, dp, last_letter)
    elif ll != t[j] and ll!= s[i]:
        return get(s, t, i-1, j-1, dp, last_letter)

if __name__ == "__main__":
    main()

### FIXED CODE ###

import sys
sys.setrecursionlimit(3003)
def main():
    s = " "+input()
    N = len(s)-1

    t = " "+input()
    M = len(t)-1
    if N < M:
        N, M = M, N
        s, t = t, s
    # dp[i][j] := sのi文字目, tのj文字目までを使ったLCSの長さ
    dp = [[-1]*(M+1) for i in range(N+1)]
    dp[0] = [0]*(N+1)
    for i in range(N+1):
        dp[i][0] = 0
    for i in range(1, N+1):
        for j in range(1, M+1):
            
            if s[i] == t[j]:
                dp[i][j] = dp[i-1][j-1]+1
            elif s[i] != t[j]:
                if dp[i-1][j] > dp[i][j-1]:
                    dp[i][j] = dp[i-1][j]
                else:
                    dp[i][j] = dp[i][j-1]
    print(get(s, t, N, M, dp))

def get(s, t, i, j, dp):
    if i == 0 or j == 0:
        return ""

    if s[i]==t[j]:
        return get(s, t, i-1, j-1, dp) + s[i]
    elif s[i] != t[j]:
        if dp[i-1][j] > dp[i][j-1]:
            return get(s, t, i-1, j, dp)
        else:
            return get(s, t, i, j-1, dp)


if __name__ == "__main__":
    main()
s=input()
a=""
if(s.equal("Sunny")):a="Cloudy"
if(s.equal("Cloudy")):a="Rainy"
if(s.equal("Rainy")):a="Sunny"
print(a)


### FIXED CODE ###

s=input()
a=""
if(s=="Sunny"):a="Cloudy"
if(s=="Cloudy"):a="Rainy"
if(s=="Rainy"):a="Sunny"
print(a)
A, B, K = map(int,input().split())
listAB = []
for i in range(min(A,B)):
    if i == 0:
        continue
    if A%i == 0 and B % i == 0:
        listAB.append(i)

if A == 1 or B == 1:
    print(1)
else:
    print(listAB[K-1])

### FIXED CODE ###

A, B, K = map(int,input().split())
listAB = []
for i in range(min(A,B)):
    if A%(i+1) == 0 and B % (i+1) == 0:
        listAB.append(i+1)
listAB.sort(reverse = True)
if A == 1 or B == 1:
    print(1)
else:
    print(listAB[K-1])
n, x = map(int, input().split())
a = sorted([*map(int, input().split())])
ans, i = 0, 0
while i < (n - 1):
    if x - a[i] >= 0:
        x -= a[i]
        ans += 1
    else:
        break
    i += 1
if x == a[i]:
	ans += 1
print(ans)


### FIXED CODE ###

n, x = map(int, input().split())
a = sorted(list(map(int, input().split())))
ans, i = 0, 0
while i < (n - 1):
    if x - a[i] >= 0:
        x -= a[i]
        ans += 1
    else:
        break
    i += 1
if x == a[i]:
	ans += 1
print(ans)
import numpy as np
R = int(input())
print(R*R*np.pi)

### FIXED CODE ###

import numpy as np
R = int(input())
print(R*2*np.pi)
from collections import Counter

N = int(input())

arr = list(map(int, input().split(' ')))

print(arr)

odd = arr[0::2]
even = arr[1::2]

odd_counter = Counter(odd)
even_counter = Counter(even)

print(odd_counter.most_common())
print(even_counter.most_common())

odd_mode = odd_counter.most_common()[0][0]
even_mode = even_counter.most_common()[0][0]

odd_diff = (N / 2) - odd_counter.most_common()[0][1]
even_diff = (N / 2) - even_counter.most_common()[0][1]

if odd_mode != even_mode:
	print(int(odd_diff + even_diff))

elif odd_diff == N /2:
	print(N / 2)
else:
	odd_diff2 = (N / 2) - odd_counter.most_common()[1][1]
	even_diff2 = (N / 2) - even_counter.most_common()[1][1]
	if odd_diff2 > even_diff2:
		print(int(odd_diff + even_diff2))
	else:
		print(int(odd_diff2 + even_diff))


### FIXED CODE ###

from collections import Counter

N = int(input())

arr = list(map(int, input().split(' ')))

odd = arr[0::2]
even = arr[1::2]

odd_counter = Counter(odd)
even_counter = Counter(even)

odd_mode = odd_counter.most_common()[0][0]
even_mode = even_counter.most_common()[0][0]

odd_diff = (N / 2) - odd_counter.most_common()[0][1]
even_diff = (N / 2) - even_counter.most_common()[0][1]

if odd_mode != even_mode:
	print(int(odd_diff + even_diff))
elif odd_diff == 0:
	print(int(N / 2))
else:
	odd_diff2 = (N / 2) - odd_counter.most_common()[1][1]
	even_diff2 = (N / 2) - even_counter.most_common()[1][1]
	if odd_diff2 > even_diff2:
		print(int(odd_diff + even_diff2))
	else:
		print(int(odd_diff2 + even_diff))
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 998244353

def solve():
    n,s = LI()
    a = LI()
    ans = 0
    dp = [0]*(s+1)
    for i in range(n):
        ai = a[i]
        for j in range(s+1)[::-1]:
            nj = j+ai
            if nj > s:
                continue
            dp[nj] += dp[j]
            dp[nj] %= mod
        dp[ai] += i+1
        dp[ai] %= mod
        ans += dp[s]
        ans %= mod
    print(ans)
    return

#Solve
if __name__ == "__main__":
    solve()


### FIXED CODE ###

#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 998244353

def solve():
    n,s = LI()
    a = LI()
    ans = 0
    f = [0]*(s+1)
    f[0] = 0
    for i in a:
        f[0] += 1
        for j in range(s+1)[::-1]:
            nj = j+i
            if nj > s:
                continue
            f[nj] += f[j]
            f[nj] %= mod
        ans += f[s]
        ans %= mod
    print(ans)
    return

#Solve
if __name__ == "__main__":
    solve()
N,M = map(int, input().split())
if n == 1:
    if m == 1:
      print(1)
    else:
      print(m - 2)
elif m == 1:
  print(n - 2)
else: 
  print((N-2)*(M-2))


### FIXED CODE ###

N,M = map(int, input().split())
if N == 1: print(1) if M == 1 else print(M - 2)
elif M == 1: print(N - 2)
else: print(N * M - (N + M - 2) * 2)
n=int(input())
from collections import deque
d=deque()
e=deque()
d.append("a")

alpha=list("abcdefghijklmnopqrstuvwxyz")
dic={alpha[i]:i for i in range(26)}
for i in range(n-1):
    while d:
        x=d.popleft()
 
        for j in range(dic[(x[-1])]+2):
            e.append(x+alpha[int(j)])  
    d=e.copy()
    e=deque()
d=list(d)

if n==1:
    print("a")
else:
    d=sorted(d)
    for some in d:
        print(some)

### FIXED CODE ###

n=int(input())
from collections import deque
d=deque()
e=deque()
d.append(("a",0))

alpha=list("abcdefghijklmnopqrstuvwxyz")
dic={alpha[i]:i for i in range(26)}
for i in range(n-1):
    while d:
        x,y=d.popleft() 
        for j in range(y+2):
            e.append((x+alpha[int(j)],max(y,j)))
    d=e
    e=deque()
d=list(d)
if n==1:
    print("a")
else:
    d=sorted(d,key=lambda x:x[0])
    for some in d:
        print(some[0])
a,b,h = map(int,input().split())]

print((a+b)*h//2)

### FIXED CODE ###

a = int(input())
b = int(input())
c = int(input())

print((a+b)*c//2)
X = int(input())

for a in range(-3, 3):
  for b in range(-3, 3):
    #print(a,b)
    if a**5 - b**5 == X:
      print(a, b)
      return()

### FIXED CODE ###

X = int(input())

for a in range(-1000, 1000):
  for b in range(-1000, 1000):
    #print(a,b)
    if a**5 - b**5 == X:
      print(a, b)
      exit()
import sys
n,k = map(int,input().split())
h = map(int,input().split())
h = list(h)

dp = [sys.maxsize]*n
dp[0]=0

for i in range(n):
    for j in range(i+1,i+k+1):
        if j<n:
            dp[j]=min(dp[j],dp[i]+abs(h[i]-h[j]))

print(dp[n-1])

### FIXED CODE ###

import sys
n =int(input())
h = map(int,input().split())
h = list(h)

dp = [sys.maxsize]*n
dp[0]=0

for i in range(n):
    for j in range(i+1,i+2+1):
        if j<n :
            dp[j]=min(dp[j],dp[i]+abs(h[i]-h[j]))

print(dp[n-1])
S = int(input())
h =
m = 
s =
print(h, m, s, sep=':')

### FIXED CODE ###

x = int(input());
h = x // 3600;
m = x % 3600 // 60;
s = x % 60;
 
print(h,m,s,sep=':');
N, A, B = map(int, input().split())
 ans = N // (A + B) * A
 rem = N % (A + B)
 ans += min(rem, A)
 print(ans)


### FIXED CODE ###

n,a,b = map(int,input().split())
ans = n // (a+b) * a
rem = n % (a+b)
ans += min(rem,a)
print(ans)
def calc_height(xs, ys, hs, cx, cy):
    ret = -1
    for i in range(len(xs)):
        x = xs[i]
        y = ys[i]
        h = hs[i]
        a = abs(x - cx)
        b = abs(y - cy)
        ch = h + a + b
        if ret == -1:
            ret = ch
        else:
            if ret != ch:
                return -1
    return ret


def solve(xs, ys, hs):
    for cx in range(101):
        for cy in range(101):
            h = calc_height(xs, ys, hs, cx, cy)
            if h > 0:
                return cx, cy, h


n = int(input())
xs = []
ys = []
hs = []
for i in range(n):
    x, y, h = list(map(int, input().split(' ')))
    xs.append(x)
    ys.append(y)
    hs.append(h)


print(' '.join([str(q) for q in solve(xs, ys, hs)]))

### FIXED CODE ###

def calc_height(xs, ys, hs, cx, cy):
    ret = -1
    zeros = []
    for i in range(len(xs)):
        x = xs[i]
        y = ys[i]
        h = hs[i]
        if h == 0:
            zeros.append((x,y,h))
            continue
        a = abs(x - cx)
        b = abs(y - cy)
        ch = h + a + b
        if ret == -1:
            ret = ch
        else:
            if ret != ch:
                return -1
    for x, y, h in zeros:
        a = abs(x - cx)
        b = abs(y - cy)
        if ret - a - b > 0:
            return -1
    return ret


def solve(xs, ys, hs):
    for cx in range(101):
        for cy in range(101):
            h = calc_height(xs, ys, hs, cx, cy)
            if h > 0:
                return cx, cy, h


n = int(input())
xs = []
ys = []
hs = []
for i in range(n):
    x, y, h = list(map(int, input().split(' ')))
    xs.append(x)
    ys.append(y)
    hs.append(h)


print(' '.join([str(q) for q in solve(xs, ys, hs)]))
NQ = list(map(int, input().split()))
word = input()
word_list = [*word]
for i in range(0, NQ[1]):
    rl = list(map(int, input().split()))
    word = word_list[rl[0]-1:rl[1]]
    word = ''.join(word)
    print(word.count('AC'))

### FIXED CODE ###

n,q = map(int, input().split())
s = input()
count = [0]*n
for i in range(1,n):
    count[i] += count[i-1]
    if s[i-1:i+1]=="AC": count[i]+=1
for i in range(q):
    l,r = map(int, input().split())
    print(count[r-1]-count[l-1])
s=input()
x=0
for i in range(0,len(s),2):
  if s[i]="L":
    x+=1
    
for j in range(1,len(s),2):
  if s[j]="R":
    x+=1

if x==0:
  print("Yes")
else:
  print("No")


### FIXED CODE ###

s=input()
x=0
for i in range(0,len(s),2):
  if s[i]=="L":
    x+=1
    
for j in range(1,len(s),2):
  if s[j]=="R":
    x+=1

if x==0:
  print("Yes")
else:
  print("No")
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    n=int(input())
    A=[None]*n
    B=[None]*n
    for i in range(n):
        A[i],B[i]=map(int,input().split())

    d=sum(b-a for a,b in zip(A,B) if(a<b))
    s=min(b for a,b in zip(A,B) if(a>=b and a-b<d))
    print(sum(A)-s)
resolve()

### FIXED CODE ###

import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    n=int(input())
    A=[None]*n
    B=[None]*n
    for i in range(n):
        A[i],B[i]=map(int,input().split())

    if(A==B):
        print(0)
        return
    print(sum(A)-min(b for a,b in zip(A,B) if(a>b)))
resolve()
def main():
    H, W = map(int, input().split())
    a = [list(map(int, input().split())) for _ in range(H)]
    N = 0
    yx = []
    for i in range(H):
        for j in range(W - 1):
            if a[i][j] % 2 == 0:
                continue
            a[i][j] -= 1
            a[i][j + 1] += 1
            N += 1
            yx.append([i + 1, j + 1, i + 1, j + 2])
        if H > i + 1 and a[i][j + 1] % 2 != 0 and 9 > a[i + 1][j + 1]:
            a[i][j + 1] -= 1
            a[i + 1][j + 1] += 1
            N += 1
            yx.append([i + 1, j + 2, i + 2, j + 2])
    print(N)
    for row in yx:
        print(' '.join(list(map(str, row))))


main()


### FIXED CODE ###

def main():
    H, W = map(int, input().split())
    a = [[0] * W]
    for _ in range(H):
        ai = list(map(int, input().split()))
        ai.insert(0, 0)
        a.append(ai)
    N = 0
    yx = []
    for i in range(1, H + 1):
        for j in range(1, W + 1):
            if a[i][j] % 2 == 0:
                continue
            if W >= j + 1:
                a[i][j] -= 1
                a[i][j + 1] += 1
                N += 1
                yx.append([i, j, i, j + 1])
            elif H >= i + 1:
                a[i][j] -= 1
                a[i + 1][j] += 1
                N += 1
                yx.append([i, j, i + 1, j])
        if H > i + 1 and a[i][j] % 2 != 0:
            a[i][j] -= 1
            a[i + 1][j] += 1
            N += 1
            yx.append([i, j + 1, i + 1, j])
    print(N)
    for row in yx:
        print(' '.join(list(map(str, row))))


main()