Harryxun/stf_run huggingface dataset:
def xx (a,b)
  
a = input()
b = input()

  if a*b %2 == 0:
    print("Even")
  else
    print("Odd")
    


def(1,21)

### FIXED CODE ###

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

print("Even" if a*b%2==0 else "Odd")
N, K = map(int, input().split())
S = [input().split() for _ in range(N+K-1)]
new_list = []; count = 1
while count < 2*K:
    for i in new_list[count]:
        new_list.append(i)
    count += 2
new_list = set(new_list)
print(N - len(new_list))

### FIXED CODE ###

N, K = map(int, input().split())
S = [input().split() for _ in range(K*2)]
new_list = []
for i in range(5):
    S.append([])
S.append([])
for i in range(1,len(S)-2,2):
    for j in S[i]:
        new_list.append(j)

new_list = set(new_list)
print(N - len(new_list))
N = int(input())
prnit(N//2 + N%2)

### FIXED CODE ###

N = int(input())
print(N//2 + N%2)
s = input()
r_cnt = 0
b_cnt = 0
for color in s:
  if color == 'R':
    r_cnt += 1
    if r_cnt > (s.length/2):
      print('Yes')
      break
  else:
    b_cnt += 1
    if b_cnt > (s.length/2):
      print('No')
      break



 

 

### FIXED CODE ###

n=input()
s = input()
r_cnt = 0
b_cnt = 0
for color in s:
  if color == 'R':
    r_cnt += 1
  else:
    b_cnt += 1
else:
  if r_cnt > b_cnt:
    print('Yes')
  else:
    print('No')
N = cin()[0]
S = input()

def alpha2num(alpha):
    num = 0
    for index, item in enumerate(list(alpha)):
        num += pow(26, len(alpha) - index - 1) * (ord(item) - ord('a') + 1)
    return num

def rol_hash(l):

    b, h = 10 ** 6 + 7, 10 ** 9 + 7
    base = pow(b, l, h)
    hash_s = 0
    dic = {}
    for i in range(l):  hash_s = (hash_s * b + alpha2num(S[i])) % h
    dic[hash_s] = l - 1
    for i in range(N - l + 1):
        if i + l < N:
            hash_s = (hash_s * b - base * alpha2num(S[i]) + alpha2num(S[i + l])) % h
            if hash_s in dic:
                if dic[hash_s] < i:  return 1
            else:  dic[hash_s] = i + l - 1
    return 0

def is_ok(mid):
    return rol_hash(mid)

def binary_search(left, right):
    while (abs(right - left) > 1):
        mid = (left + right) // 2
        if is_ok(mid):  right = mid
        else:  left = mid
    return right

left = N + 1
right = -1
ret = binary_search(left, right)
if ret == right:  print(0)
else:  print(ret)

### FIXED CODE ###

def cin():  return list(map(int,input().split()))

def alpha2num(alpha):
    num = 0
    for index, item in enumerate(list(alpha)):  num += pow(26, len(alpha) - index - 1) * (ord(item) - ord('a') + 1)
    return num

def rol_hash(l):

    b, h = 1007, 10 ** 9 + 9
    base = pow(b, l, h)
    hash_s = 0
    dic = {}
    for i in range(l):  hash_s = (hash_s * b + alpha2num(S[i])) % h
    dic[hash_s] = l - 1
    for i in range(1, N - l + 1):
        hash_s = (hash_s * b - base * alpha2num(S[i - 1]) + alpha2num(S[i + l - 1])) % h
        if hash_s in dic:
            if S[dic[hash_s] - l + 1:dic[hash_s] + 1] == S[i:i + l] and dic[hash_s] < i:  return 1
        else:  dic[hash_s] = i + l - 1
    return 0

def is_ok(mid):  return rol_hash(mid)

def binary_search(left, right):
    while (abs(right - left) > 1):
        mid = (left + right) // 2
        if is_ok(mid):  right = mid
        else:  left = mid
    return right

N = cin()[0]
S = input()

left = N + 1
right = -1
ret = binary_search(left, right)
if ret == right:  print(0)
else:  print(ret)
N=int(input())
D=list(map(int,input().split()))
D.sort()
mi=D[0]
ma=D[N-1]
point=0
for j in range(mi,ma+1): #Kはj
  i=0
  while a[i]<j and i+1<N//2+1:
    i+=1
  if i==N//2:
    point+=1
print(point)
    
  

### FIXED CODE ###

N=int(input())
D=list(map(int,input().split()))
D.sort()
mi=D[0]
ma=D[N-1]
point=0
for j in range(mi,ma+1): #Kはj
    if D[N//2-1]<j<=D[N//2]:
        point+=1
print(point)
N = int(input())
A=[int(_) for _ in input().split()]

Maxcounter = 0
for i in range(1,N):
    counter = 0
    k = i
    while k < N:
      if (A[k-1]>=A[k]):
        counter += 1
        k += 1
        if Maxcounter <= counter:
            Maxcounter = counter
      else:
        break
      
print(Maxcounter)


### FIXED CODE ###

S = list(input())
T = list(input())

counter = 0
for i in range(0,3):
    if S[i] == T[i]:
        counter += 1

print(counter)
N = int(input())
X = input()
flag1 = 0
flag0 = 0


def popcount(n: int):
    bin_n = bin(n)
    return str(bin_n).count('1')


popcount_X = popcount(int(X, 2))

for i in range(N):
    count = 0
    if X[i] == '1':
        tmp = int(X)
        tmp -= 10 ** (N - i - 1)
        flag1 += 1
    else:
        tmp = int(X)
        tmp += 10 ** (N - i - 1)
        flag0 += 1
    tmp = int(str(tmp), 2)

    while True:
        if tmp == 0:
            print(count)
            break
        elif flag1:
            count += 1
            tmp = tmp % (popcount_X-1)
            flag1 = 0
        elif flag0:
            count += 1
            tmp = tmp % (popcount_X+1)
            flag0 = 0
        else:
            count += 1
            tmp = tmp % popcount(tmp)


### FIXED CODE ###

N = int(input())
S = input()
X = int(S, 2)
pcx = S.count('1')
# ビット反転で1が0になる場合
pc1 = X % (pcx - 1) if pcx > 1 else 0
# ビット反転で0が1になる場合
pc2 = X % (pcx + 1)


def f(j):
    cnt = 0
    while j:
        j %= bin(j).count('1')
        cnt += 1
    return cnt


for i, y in enumerate(S):
    k = N - i - 1
    if y == "0":  # modを分配するときは、分配してからもう１回modを作用させれば良い
        print(f((pc2 + pow(2, k, pcx + 1)) % (pcx + 1)) + 1)
    elif pcx > 1:
        print(f((pc1 - pow(2, k, pcx - 1)) % (pcx - 1)) + 1)
    else:
        print(0)
N, M, X = map(int, input().split())


C =[]
A = {}

for i in range(N):
    ipt = list(map(int, input().split()))
    C.append(ipt[0])
    A[i] = ipt[1:]

bestscore = 99999999999
def rec(n, score, money):
    global bestscore
    if n==N: return
    rec(n+1, score[:], money)

    money += C[n]
    for i in range(M):
        score[i] += A[n][i]
    

    for i in range(M):
        if score[i] < X:
            rec(n+1, score[:], money)
            return
    bestscore = min(bestscore, money)

score = [0 for i in range(N)]

rec(0, score, 0)
if bestscore == 99999999999:
    print(-1)
else:
    print(bestscore)

### FIXED CODE ###

import copy
N, M, X = map(int, input().split())


C =[]
A = {}

for i in range(N):
    ipt = list(map(int, input().split()))
    C.append(ipt[0])
    A[i] = ipt[1:]

bestscore = 99999999999
def rec(n, score, money):
    global bestscore
    if n==N: return
    s = copy.deepcopy(score)
    rec(n+1, s, money)

    money += C[n]
    for i in range(M):
        score[i] += A[n][i]
    

    for i in range(M):
        if score[i] < X:
            s = copy.deepcopy(score)
            rec(n+1, s, money)
            return
    bestscore = min(bestscore, money)

score = [0 for i in range(M)]

rec(0, score, 0)
if bestscore == 99999999999:
    print(-1)
else:
    print(bestscore)
s = list(map(str,input()))
t = list(map(str,input()))

ans = len(t)

for i in range(0,len(s)-len(t)+1):
    df = 0
        if s[i+j] != t[j]:
            df += 1
    ans = min(ans,df)

print(ans)

### FIXED CODE ###

s = list(map(str,input()))
t = list(map(str,input()))

ans = len(t)

for i in range(0,len(s)-len(t)+1):
    df = 0
    for j in range(0,len(t)):
        if s[i+j] != t[j]:
            df += 1
    ans = min(ans,df)

print(ans)
N = int(input())
S = str(input())
K = int(input())
ans = ""
for i in range(0, N):
    if(S[i] != S[K]):
        ans += "*"
    else:
        ans += S[K]
print(ans)


### FIXED CODE ###

N = int(input())
S = str(input())
K = int(input())
ans = ""
for i in range(0, N):
    if(S[i] != S[K-1]):
        ans += "*"
    else:
        ans += S[K-1]
print(ans)
import sys
import fractions
from collections import Counter, defaultdict, deque
from functools import reduce

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)


def I():
    return int(input())


def MI():
    return map(int, input().split())


def LI():
    return list(MI())


def LIN(n: int):
    return [I() for _ in range(n)]


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    k = I()

    def gcd(number):
        return fractions.gcd(fractions.gcd, number)

    sum = 0
    for a in range(1, k + 1):
        for b in range(1, k + 1):
            for c in range(1, k + 1):
                sum += gcd(a, b, c)

    print(sum)


if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys
import math
from collections import Counter, defaultdict, deque
from functools import reduce

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)


def I():
    return int(input())


def MI():
    return map(int, input().split())


def LI():
    return list(MI())


def LIN(n: int):
    return [I() for _ in range(n)]


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    k = I()

    def gcd(a, b, c):
        return math.gcd(math.gcd(a, b), c)

    sum = 0
    for a in range(1, k + 1):
        for b in range(1, k + 1):
            for c in range(1, k + 1):
                if a == b or a == c:
                    sum += math.gcd(b, c)
                elif b == c:
                    sum += math.gcd(a, c)
                else:
                    sum += gcd(a, b, c)

    print(sum)


if __name__ == "__main__":
    main()
import copy
def explore(key, flags):
    flags = copy.copy(flags)
    if flags[key-1]:
        return 0
    flags[key-1] = True
    if False not in flags:
        return 1
    elif key in graph:
        value = graph[key]
        ans = 0
        for i in value:
            ans += explore(i, flags)
        return ans
    else:
        return 0

n, m = map(int, input().split())
graph = {}
for i in range(m):
    a, b = map(int, input().split())
    if a in graph:
        graph[a].append(b)
    else:
        graph[a] = [b]
    if b in graph:
        graph[b].append(a)
    else:
        graph[b] = [a]

flags = [False for i in range(m)]
ans = explore(1, flags)
print(ans)


### FIXED CODE ###

import copy
def explore(key, flags):
    flags = copy.copy(flags)
    if flags[key-1]:
        return 0
    flags[key-1] = True
    if False not in flags:
        return 1
    elif key in graph:
        value = graph[key]
        ans = 0
        for i in value:
            ans += explore(i, flags)
        return ans
    else:
        return 0

n, m = map(int, input().split())
graph = {}
for i in range(m):
    a, b = map(int, input().split())
    if a in graph:
        graph[a].append(b)
    else:
        graph[a] = [b]
    if b in graph:
        graph[b].append(a)
    else:
        graph[b] = [a]

flags = [False for i in range(n)]
ans = explore(1, flags)
print(ans)
n, k = map(int, input().split())
a = list(map(lambda x: int(x) - 1, input().split()))
visited = [-1 for _ in range(n)]
visited[0] = 0
l = [0]
for i in range(k):
    nex = a[l[i]]
    if visited[nex] != -1:
        res = visited[nex]
        cyc = i + 1 - visited[nex]
        break
    else:
        l += [nex]
        visited[nex] = i + 1
print(l[res + (k - res) % cyc] + 1 if k > res else l[k] + 1)


### FIXED CODE ###

n, k = map(int, input().split())
a = list(map(lambda x: int(x) - 1, input().split()))
visited = [-1 for _ in range(n)]
visited[0] = 0
l = [0]
for i in range(k):
    nex = a[l[i]]
    if visited[nex] != -1:
        res = visited[nex]
        cyc = i + 1 - visited[nex]
        break
    else:
        l += [nex]
        visited[nex] = i + 1
else:
    res = k + 1
print(l[res + (k - res) % cyc] + 1 if k > res else l[k] + 1)
A,B,C=map(int(input().split()))
if A+B>=C:
	print("Yes")
else:
	print("No")

### FIXED CODE ###

A,B,C=map(int, input().split())
if A+B>=C:
	print("Yes")
else:
	print("No")
inputt = [input() for i in range(2)]
num = inputt[0]
listt = list(map(int, inputt[1].split()))

def hoge(listt):
  new_list = []
  for i in listt:
    if i % 2 == 0:
      new_list.append(i)
    else:
      return False
  return new_list

count = 0
while True;
  listt = hoge(listt)
  if listt == False:
    break
  count += 1

print(count)

### FIXED CODE ###

num = input()
listt = input().split()

def hoge(fuga):
    new_list = []
    for i in fuga:
        if int(i) % 2 == 0:
            new_list.append(int(i)/2)
        else:
            return False
    return new_list


count = 0
while True:
    listt = hoge(listt)
    if listt == False:
        break
    count += 1

print(count)
print(input(A,B,C))

if A==B and A/=C:
  print('Yes')
elif A==C and A/=B:
  print('Yes')
elif B==C and A/=B:
  print('Yes')
else:
  print('No')
  

### FIXED CODE ###

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

if a == b and a == c:
  print('No')
elif a != b and a != c and b!= c:
  print('No')
else:
  print('Yes')
a,b=map(int,input().spplit())
if a>12:
    print(int(b))	
elif 12>=a>=6:
    print(int(b/2)
else:
    print(0)

### FIXED CODE ###

a,b=map(int,input().split())
if a>12:
    print(int(b))	
elif 12>=a>=6:
    print(int(b/2))
else:
    print(0)
s, w = int(input().split())
if s>=w:
  print("unsafe")
else:
  print("safe")

### FIXED CODE ###

s, w = map(int, input().split())
if s<=w:
  print("unsafe")
else:
  print("safe")
N,Q=map(int,input().split())
s=[0]*N
tree=[[] for _ in range(N)]
counter=[0]*N
def pl(t,x):
    if t:
        for i in t:
            s[i]+=x
            pl(tree[i],x)
for _ in range(N-1):
    a,b=map(int, input().split())
    tree[a-1].append(b-1)
for _ in range(Q):
    p,x=map(int, input().split())
    s[p-1]+=x
    pl(tree[p-1],x)
s=[str(i) for i in s]
print(' '.join(s))


### FIXED CODE ###

from collections import deque

N,Q=map(int,input().split())
to=[[] for _ in range(N)]
count=[0]*N
for _ in range(N-1):
    a,b=map(int, input().split())
    to[a-1].append(b-1)
    to[b-1].append(a-1)
for _ in range(Q):
    p,x=map(int, input().split())
    count[p-1]+=x
q = deque()
q.append(0)
p=[True]*N
while q:
    i = q.pop()
    if p[i]:
        p[i]=False
        for j in to[i]:
            if p[j]:
                count[j]+=count[i]
                q.append(j)
print(*count)
n,x = map(int, raw_input().split())
lis = sorted(map(int, raw_input().split()))
def gcd(a, b):
    if a == 0:
        return b
    return gcd(b%a,a)
if n == 1:
    val = abs(lis[0]-x)
    print val
    exit()
import bisect
#print lis
idx = bisect.bisect_left(lis, x)
#print idx
if idx == 0:
    val = lis[0] - x
    flag = 0
    lmao = -1
    for i in range(1, n):
        if (lis[i] - x) % val != 0:
            flag = 1
            lmao = i
            break
    if flag == 0:
        print val
    else:
        factors = [] 
        for i in range(min(x, lis[lmao]), 0, -1):
            if x % i == 0 and lis[lmao] % i == 0:
                factors.append(i)
        for i in xrange(len(factors)):
            flag1 = 0
            for j in xrange(n):
                if abs(lis[j]-x) % factors[i] != 0:
                    flag1 = 1
                    break
            if flag1 == 0:
                print factors[i]
                break
elif idx == n:
    val = x - lis[-1]
    flag = 0
    lmao = -1
    for i in range(n-2, -1, -1):
        if (x - lis[i]) % val != 0:
            lmao = i
            flag = 1
            break
    if flag == 0:
        print val
    else:
        factors = [] 
        for i in range(min(x, lis[lmao]), 0, -1):
            if x % i == 0 and lis[lmao] % i == 0:
                factors.append(i)
        for i in xrange(len(factors)):
            flag1 = 0
            for j in xrange(n):
                if abs(lis[j]-x) % factors[i] != 0:
                    flag1 = 1
                    break
            if flag1 == 0:
                print factors[i]
                break
else:
    val = min(lis[idx]-x, x-lis[idx-1])
    flag = 0
    lmao = -1
    for i in range(idx, n, 1):
        if (lis[i]-x)%val != 0:
            flag= 1
            lmao = i
            break
    for i in range(idx-1, -1, -1):
        if (x-lis[i])%val != 0:
            lmao = i
            flag = 1
            break
    if flag == 0:
        print val
    else:
        factors = [] 
        for i in range(min(x, lis[lmao]), 0, -1):
            if x % i == 0 and lis[lmao] % i == 0:
                factors.append(i)
        for i in xrange(len(factors)):
            flag1 = 0
            for j in xrange(n):
                if abs(lis[j]-x) % factors[i] != 0:
                    flag1 = 1
                    break
            if flag1 == 0:
                print factors[i]
                break


#print bisect.bisect_left(lis, 38)

### FIXED CODE ###

n,x = map(int, raw_input().split())
lis = sorted(map(int, raw_input().split()))
def gcd(a, b):
    if a == 0:
        return b
    return gcd(b%a,a)
if n == 1:
    val = abs(lis[0]-x)
    print val
    exit()
val = 0
#print lis
for i in xrange(n):
    lis[i] -= x
    val = gcd(abs(lis[i]), val)
print val
s=input()

print(s*s*s)

### FIXED CODE ###

import sys 

s = int(sys.stdin.readline())
 
print(s*s*s)
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections

n,k = map(int,input().split())
a = list(map(int,input().split()))
for i in range(n):
    a[i]-=1

roop = []
pre = 0
for i in range(2*n):
    roop.append(pre)
    pre = a[pre]
cnt = [0]*n
s = ""
for i in range(len(roop)):
    cnt[roop[i]]+=1
    if cnt[roop[i]]>=2 and cnt[roop[i]]<3:
        s += str(roop[i])
ff = int(s[0])
s2 = s
for i in range(len(roop)):
    if roop[i]!=ff:
        s2  = str(roop[i]) + s2
    else:
        check = i
        break

if k<=len(s2):
    print(a[k-1]+1)
else:
    k-=check
    k%=len(s)
    print(a[check + k]+1)





### FIXED CODE ###

import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections

n,k = map(int,input().split())
a = list(map(int,input().split()))
for i in range(n):
    a[i]-=1

roop = [0]
for i in range(3*n):
    roop.append(a[roop[i]])
cnt =[0]*n
d = []
for i in range(len(roop)):
    cnt[roop[i]]+=1
    if cnt[roop[i]]>=3 and cnt[roop[i]]<4:
        d.append(roop[i])
for i in range(len(roop)):
    if roop[i] == d[0]:
        check = i
        break
if check == 0:
    k%=len(d)
    print(d[k]+1)
else:
    if k<check + len(d):
        print(roop[k]+1)
    else:
        k-=check
        k%=len(d)
        print(d[k]+1)
import sys

def solve (N):
    s=0
    for b in str(N):
        s = s + int(b)
    if N % s ==0:
        return 'Yes'
    else:
        return 'No'

# 関数 solve は，もちろん，問題に応じて書き換える
def solve(n):
   
# ここから下は，入力・出力形式が同じであれば，変えなくて良い．
def readQuestion():
    line = sys.stdin.readline().rstrip()
    return int(line)

def main():
    n = readQuestion()
    answer = solve(n)
    print(answer)
    
if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys

# 関数 solve は，もちろん，問題に応じて書き換える
def solve (N):
    s=0
    for b in str(N):

        s = s + int(b)
    if N % s ==0:
        return 'Yes'
    else:
        return 'No'
   

# ここから下は，入力・出力形式が同じであれば，変えなくて良い．
def readQuestion():
    line = sys.stdin.readline().rstrip()
    return int(line)

def main():
    n = readQuestion()
    answer = solve(n)
    print(answer)
    
if __name__ == '__main__':
    main()
n = int(input())
X = [0]*n
Y = [0]*n
for i in range(n):
  X[i],Y[i] = map(int,input().split())  
  
dic = {}
for i in range(n):
  for j in range(i+1,n):
    x = X[i]-X[j]
    y = Y[i]-Y[j]
    dic[(x,y)] = dic.get((x,y),0) + 1
    
print(n-max(dic.values()))

### FIXED CODE ###

n = int(input())
X = [0]*n
Y = [0]*n
for i in range(n):
  X[i],Y[i] = map(int,input().split())  
  
dic = {}
for i in range(n):
  for j in range(n):
    if i!=j:
      x = X[i]-X[j]
      y = Y[i]-Y[j]
      dic[(x,y)] = dic.get((x,y),0) + 1

if n == 1:
  print(1)
else:  
  print(n-max(dic.values()))
n, k = [int(x) for x in (input().split())]
a = [int(x) for x in (input().split())]

for i in range(n):
	if a[i] == 1:
		print(i)


### FIXED CODE ###

s = input()

if s == 'Rainy':
	s = 'Sunny'
elif s == 'Cloudy':
	s = 'Rainy'
else:
	s = 'Cloudy'
print(s)
n, x, t = map(int, input())
ans = n//x 
if n%x != 0:
  ans += 1
print(int(ans)*t)

### FIXED CODE ###

n, x, t = map(int, input().split())
ans = n//x 
if n%x != 0:
  ans += 1
print(int(ans)*t)
x = int(input())
n = 10 ** 5
primes = set(range(2, n+1))
for i in range(2, int(n**0.5+1)):
    primes.difference_update(range(i*2, n+1, i))
primes = list(primes)
import bisect
b = bisect.bisect_right(primes, x)
print(primes[b])

### FIXED CODE ###

x = int(input())
n = 2 *(10 ** 5)
primes = set(range(2, n+1))
for i in range(2, int(n**0.5+1)):
    primes.difference_update(range(i*2, n+1, i))
primes = list(primes)
import bisect
b = bisect.bisect_right(primes, x)
if x == primes[b - 1]:
    print(x)
else:
    print(primes[b])
#coding: utf-8
a, b = map(int, input().split())
result = 0

if(a>b):
    result += a
    a = a-1
else:
    resu += b
    b = b-1

result += max(a,b)
print(result)


### FIXED CODE ###

#coding: utf-8
a, b = map(int, input().split())
result = 0
     
if(a>b):
    result += a
    a = a-1
else:
    result += b
    b = b-1
     
result += max(a,b)
print(result)
'''
Created on Mar 22, 2013

@author: wukc
'''

from sys import stdin

a=map(int,stdin.readline().split())
a.sort()
print(" ".join(a[::-1]))

### FIXED CODE ###

'''
Created on Mar 22, 2013

@author: wukc
'''

from sys import stdin

a=map(int,stdin.readline().split())
a.sort()
print(" ".join(map(str,a[::-1])))
numa, numb = input().strip().split()
numa, numb = [int(numa), float(numb)]

numb *= 100
numb = int(numb)
ans = int((numa*numb)/100)
print(ans)

### FIXED CODE ###

import sys

number = int(input())
box = list(map(int,input().split()))

for var in box:
    if var == 0:
        print("0")
        sys.exit()

overflow = 1e18
ans = 1
for var in box:
    if overflow/var < ans:
        print("-1")
        sys.exit()
    ans *= var

if ans <= overflow:
    print(ans)
else:
    print(-1)
def L_common(str1,str2):
    d = [0 for i in range(len(str2)+1)]
    
    for n1 in str1:
        tmp = d[:]
        for (j,n2) in enumerate(str2):
            if n1 == n2:
                d[j+1] = tmp[j]+1
            elif d[j+1]<d[j]:
                d[j+1] = d[j]
    return d[len(str2)]

n = int(input())
stock = []
for i in range(n):
    x = input()
    y = input()
    if len(x)>len(y):
        stock.append(len(x)-L_common(x,y))
    else:
        stock.append(len(y)-L_common(x,y))

for i in stock:
    print(i)


### FIXED CODE ###

x = input(); n_x = len(x);
y = input(); n_y = len(y);
s = [[i+j for j in range(n_y+1)] for i in range(n_x+1)]
for i in range(n_x):
    for j in range(n_y):
        s[i+1][j+1] = min(s[i+1][j]+1,s[i][j+1]+1,s[i][j]+1*(x[i]!=y[j]))   
print(s[n_x][n_y])
N,Q = list(map(int,input().split()))
S = input()
L = []
R = []
for i in range(Q):
    a = list(map(int,input().split()))
    L.append(a[0])
    R.append(a[1])

S_count = []
count = 0
A_flag = False

for i in range(len(S)):
    if A_flag == True:
        if S[i] == "C" :
            count += 1
        A_flag = False
    else:
        if S[i] == "A" :
            A_flag = True
        else:
            A_flag = False
    S_count.append(count)

for i in range(Q):
    print(S_count[R[i] - 1] - S_count[L[i] - 1])

### FIXED CODE ###

b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")
input()
a = list(map(int, input().split()))
m = 0
end = 0
for i in range(len(a)):
  if end < len(a) - 2:
    for j in range(i, len(a) - 1):
      if a[j] >= a[j + 1]:
        m += 1
        end = j
        else:
          m = 0
          break
          print(m)

### FIXED CODE ###

input()
a = list(map(int, input().split(" ")))
count = 0
arrayCount = []
for i in range(0, len(a) - 1):
    if a[i] >= a[i + 1]:
        count += 1
    else:
        arrayCount.append(count)
        count = 0
arrayCount.append(count)
print(max(arrayCount))