Harryxun/stf_run huggingface dataset:
def main():
    N = int(input())
    H = [int(x) for x in input().split()]
    ans = []
    count = 0
    if N > 1:
        for i in range(1, N):
            if H[-i] <= H[-(i + 1)]:
                count += 1
            else:
                ans.append(count)
                count = 0
    else:
        ans.append(0)

    print(max(ans))


if __name__ == "__main__":
    main()

### FIXED CODE ###

def main():
    N = int(input())
    H = [int(x) for x in input().split()]
    ans = 0
    count = 0

    if N == 2:
        if H[0] >= H[1]:
            ans = 1
    elif N > 2:
        for i in range(1, N):
            j = i + 1
            if H[-i] <= H[-j]:
                count += 1
                if j == N:
                    if ans <= count:
                        ans = count
            else:
                if ans <= count:
                    ans = count
                count = 0
    print(ans)


if __name__ == "__main__":
    main()
import sys
from collections import deque
from copy import copy

N,K = list(map(int, input().split()))
V = deque(list(map(int, input().split())))

max_value = 0

def calc_max_value(V, k, l, r):
    store = deque([])
    for i in range(l):
        if len(V)>0:
            store.append(V.popleft())
            continue
        else:
            break
    for i in range(r):
        if len(V)>0:
            store.append(V.pop())
            continue
        else:
            break
    store = deque(sorted(store))
    for i in range(k-l-r):
        if len(store)>0:
            e = store.popleft()
            if e < 0:
                continue
            else:
                max_value.appendleft(e)
                break
        else:
            break
    max_value = sum(store)
    return max_value

    
for k in range(K+1):
    for l in range(K+1):
        for r in range(K+1-l):
            max_value = max(max_value, calc_max_value(copy(V), k, l, r))

print(max_value)


### FIXED CODE ###

import sys
from collections import deque
from copy import copy

N,K = list(map(int, input().split()))
V = deque(list(map(int, input().split())))

max_value = 0

def calc_max_value(V, K, k, l, r):
    store = deque([])
    for i in range(l):
        if len(V)>0:
            store.append(V.popleft())
            continue
        else:
            break
    for i in range(r):
        if len(V)>0:
            store.append(V.pop())
            continue
        else:
            break
    store = deque(sorted(store))
    for i in range(K-l-r):
        if len(store)>0:
            e = store.popleft()
            if e < 0:
                continue
            else:
                store.appendleft(e)
                break
        else:
            break
    max_value = sum(store)
    return max_value

    
for k in range(min(K+1,N+1)):
    for l in range(k+1):
        for r in range(k+1-l):
            max_value = max(max_value, calc_max_value(copy(V), K, k, l, r))

print(max_value)
s=input()
s[3]=8
print(s)

### FIXED CODE ###

s=list(input())
s[3]='8'
print(''.join(s))
a,b=map(int,input().split())
if a-2*b>=0:
  print(a-2*b)
else a-2*b<0:
  print(0)


### FIXED CODE ###

a,b=map(int,input().split())
if a-2*b>=0:
  print(a-2*b)
else:
  print(0)
n=int(input())
a=list(map(int,input().split()))
def main():
  if 0 in a:
    print(0)
  else:
  b=1
  for i in range(0,n):
    b*=a[i]

  if b<=10**8:
    print(b)
  else: print(-1)

### FIXED CODE ###

M=list(map(int,input().split()))

print(M[0]*M[1])
import sys

lst = []
for line in sys.stdin:
    num = int(line.strip())
    if num == 0:
        print lst.pop()
    else:
        lst.append(num)

### FIXED CODE ###

import sys

lst = []
for line in sys.stdin:
    if line.strip() :
        num = int(line.strip())
        if num == 0:
            print lst.pop()
        else:
            lst.append(num)
import sys,math
sys.setrecursionlimit(10**9)
from collections import defaultdict
 
IA = lambda: map(int,input().split())
IAS= lambda: map(str,input().split())
sum=100
for i in range(1:100):
  sum=sum+1
n=int(input())
print("{:.12f}".format(pow(n,3)/27.0))

### FIXED CODE ###

import sys, math

sys.setrecursionlimit(10 ** 9)
from collections import defaultdict

IA = lambda: map(int, input().split())
IAS = lambda: map(str, input().split())

sum=0
for i in range(10):
    sum+=1
n = int(input())
print("{:.12f}".format(pow(n, 3) / 27.0))
N, K = map(int, input().split())
import math

l = []
for i in range(K):
  a = math.factorial(N-K+1)/(math.factorial(N-K-i)*math.factorial(i+1))
  b = math.factorial(K-1)/(math.factorial(K-1-i)*math.factorial(i))
  ans = int(a)*int(b)
  l.append(int(ans))

for j in l:
  print(j%(10**9+7))


### FIXED CODE ###

N, K = map(int, input().split())
import math
mod =10**9+7

l = []
l.append(N-K+1)
for i in range(1, K):
  a = l[i-1] * (N-K-i+1) * (K-i) // ((i+1)*i)
  l.append(int(a))

for j in l:
  print(j%mod)
import sys
sys.setrecursionlimit(10**9)
N,K=list(map(int,input().strip().split(' ')))
A=[]
for _ in range(N):
    A+=[list(map(int,input().strip().split(' ')))]
dic={}
MOD=10**9+7
def findout(i,j,k):
    
    if k==1:
        if A[i][j]==1:
            return 1
        else:
            return 0
    if (i,j,k) in dic:
        return dic[(i,j,k)]
    N=len(A)
    a1=k//2
    a2=k-a1
    
    ans=0
    for node in range(N):
        ans+=(findout(i,node,a1)*findout(node,j,a2))%MOD
    dic[(i,j,k)]=ans
    return ans
ans=0
for i in range(4):
    for j in range(4):
        ans+=findout(i,j,K)
        ans%=MOD
print(ans)

### FIXED CODE ###

N,K=list(map(int,input().strip().split(' ')))
A=[]
for _ in range(N):
    A+=[list(map(int,input().strip().split(' ')))]
dic={}
MOD=10**9+7
power=1
while 2**power<=K:
    power+=1

dp=[[[0 for j in range(N)] for i in range(N)] for p in range(power+1) ]
for p in range(0,power+1):
    
    if p==0:
        for i in range(N):
            for j in range(N):
                if A[i][j]==1:
                    dp[p][i][j]=1
    else:
        for i in range(N):
            for j in range(N):
                for k in range(N):
                    dp[p][i][j]+=(dp[p-1][i][k]*dp[p-1][k][j])%MOD
                    dp[p][i][j]%=MOD

    
rep=bin(K)[2:][::-1]
final_ans=[[0 for i in range(N)] for j in range(N)]
need=[]
for i in range(len(rep)):
    if rep[i]=="1":
        need+=[i]

final=[[dp[need[0]][i][j] for j in range(N)] for i in range(N)]
for i in range(1,len(need)):
    ##start*dp[need[i]]
    temp_ans=[[0 for i in range(N)] for j in range(N)]
    for x in range(N):
        for y in range(N):
            temp=0
            for z in range(N):
                temp+=final[x][z]*dp[need[i]][z][y]
                temp%=MOD
            temp_ans[x][y]=temp
    final=[[temp_ans[i][j] for j in range(N)] for i in range(N)]
            
ans=0
for i in range(N):
    for j in range(N):
        ans+=final[i][j]
        ans%=MOD
print(ans)
import sys

input = sys.stdin.readline

L, R = map(int, input().split())

def main():
    LR = list(range(L, R+1))
    N = len(LR)
    if N >= 2019:
        ans = 0
    else:
        ansLi = LR[0] % 2019
        ansLj = LR[1] % 2019
        ansL = ansLi * ansLj

        ansRi = LR[-1] % 2019
        ansRj = LR[-2] % 2019
        ansR = ansRi * ansRj

        ans = min(ansL, ansR)

    return ans

print(main())

### FIXED CODE ###

import sys

input = sys.stdin.readline

L, R = map(int, input().split())

def main():
    if R // 2019 != L // 2019:
        ans = 0
    else:
        # ansLi = L % 2019
        # ansLj = (L+1) % 2019
        # ansL = ansLi * ansLj

        # ansRi = R % 2019
        # ansRj = (R-1) % 2019
        # ansR = ansRi * ansRj
        ansL = L*(L+1) % 2019
        ansR = R*(R-1) % 2019

        ans = min(ansL, ansR)

    return int(ans)

# print(main())

def search_all():
    if R // 2019 != L // 2019:
        return 0
    ans = float("inf")
    for i in range(L, R):
        for j in range(i+1, R+1):
            ans = min(i*j % 2019, ans)
            if ans == 0:
                break
    return ans

print(search_all())
N, M = map(int, input().split())
s = []
c = []
for m in range(M):
    si, ci = map(int, input().split())
    s.append(si)
    c.append(ci)

s = 10 ** (N - 1)
if N == 1:
    s -= 1

for i in range(s, 10 ** N):
    for m in range(M):
        if str(i)[s[m] - 1] != str(c[m]):
            break
    else:
        print(i)
        exit()

print(-1)


### FIXED CODE ###

N, M = map(int, input().split())
s = []
c = []
for m in range(M):
    si, ci = map(int, input().split())
    s.append(si)
    c.append(ci)

ss = 10 ** (N - 1)
if N == 1:
    ss -= 1

for i in range(ss, 10 ** N):
    for m in range(M):
        if str(i)[s[m] - 1] != str(c[m]):
            break
    else:
        print(i)
        exit()

print(-1)
#--import & define---------------------
import math

def yes():
    print("Yes")
def no():
    print("No")
#--memo--------------------------------
#mapを利用した入力
# x,y = map(int,input().split())

#forを利用した入力
#l = []
#for i in range():
#    l.append(int(input()))
#    print(i,l)
#--------------------------------------
l = []
for i in range(6):
   l.append(int(input()))

if l[0]-l[1]>l[5] or l[1]-l[2]>l[5] or l[2]-l[3]>l[5] or l[3]-l[4]>l[5] or:
    no()
else:
    yes()


### FIXED CODE ###

l = []
for i in range(6):
   l.append(int(input()))

if l[4]-l[0]>l[5]:
    print(":(")
else:
    print("Yay!")
a,b = map(int,inpout())
ans = a-2*b
if ans <= 0:
  print(0)
else:
  print(ans)

### FIXED CODE ###

a,b = map(int,input().split())
ans = a-2*b
if ans <= 0:
  print(0)
else:
  print(ans)
s=input()
if s="A":
    print("T")
elif s="T":
    print("A")
elif s="C":
    print("G")
else:
    print("C")

### FIXED CODE ###

s=input()
if s=="A":
    print("T")
elif s=="T":
    print("A")
elif s=="C":
    print("G")
else:
    print("C")
# -*- coding: utf-8 -*-

import sys
from collections import defaultdict


n, q = [int(x) for x in sys.stdin.readline().rstrip().split(" ")]

tree = defaultdict(set)
data = defaultdict(int)


def add(p, x):
    data[p] += x
    for p2 in tree[p]:
        add(p2, x)


for _ in range(n - 1):
    a, b = [int(x) for x in sys.stdin.readline().rstrip().split(" ")]
    tree[a].add(b)

for _ in range(q):
    p, x = [int(x) for x in sys.stdin.readline().rstrip().split(" ")]
    add(p, x)

print(" ".join([str(data[i + 1]) for i in range(n)]))


### FIXED CODE ###

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

import sys


sys.setrecursionlimit(10**6)


def main():
    n, q = map(int, sys.stdin.readline().split())

    tree = [[] for x in range(n + 1)]
    data = [0 for x in range(n + 1)]

    for _ in range(n - 1):
        a, b = map(int, sys.stdin.readline().split())
        tree[a].append(b)
        tree[b].append(a)

    for _ in range(q):
        p, x = map(int, sys.stdin.readline().split())
        data[p] += x

    def dfs(p, p2, x):
        data[p] += x
        for p3 in tree[p]:
            if p3 == p2:
                continue
            dfs(p3, p, data[p])

    dfs(1, 0, 0)

    print(" ".join([str(x) for x in data[1:]]))


if __name__ == "__main__":
    main()
n=int(input())

num=0

t,x,y=map(int,input().split())
num+=(x+y)
if t%num!=0:
  print("No")
  exit()
if n==1:
  print("Yes")
  
for i in range(n-1):
  t,x,y=map(int,input().split())
  num-=(x+y)
  num=abs(num)
  if t%num!=0:
    print("No")
    exit()
    
print("Yes")
  

### FIXED CODE ###

n=int(input())

num,a,b=0,0,0

for i in range(n):
  t,x,y=map(int,input().split())
  num,a,b=abs(t-num),abs(x-a),abs(y-b)
  su=a+b
  if num>=su and num%2 == su%2:
    ans="Yes"
  else:
    ans="No"
    break
      
print(ans)
a=int(input())
b=int(input())
if a>b:
   print("GREATER")
else if a<b:
    print("LESS")
else if a==b:
    print("EQUAL")

### FIXED CODE ###

a=int(input())
b=int(input())
if a>b:
   print("GREATER")
elif a<b:
    print("LESS")
elif a==b:
    print("EQUAL")
A, B = map(int, input().split())
0<=A<=100
2<=B<=100

if 0 <= A <= 5 :
    B = 0
elif 6 <= A <= 13 :
    B = B//2
else :
    B = B
    if B % 2 == 0 :
        print(B)
    else :
        break


### FIXED CODE ###

A, B = map(int, input().split())
0<=A<=100
2<=B<=100
if 0<=A<=5 :
    B=0
elif 6<=A<=12 :
    B=B//2
else :
    B=B
print(B)
N,M=map(int,input().split())
A=list(map(int,input().split()))
A.sort(reverse=True)
t=0
while True:
  maxi=A[0]
  if len(A)>1 :
    maxi_2=A[1]
    t+=1
    maxi=maxi//2
    if t==M :
      A[0]=maxi
      break
    elif maxi_2>maxi :
      A[0]=maxi_2
      A[1]=maxi
      for i in range(1,N):
        if A[i]<A[i+1]:
          A[i]=A[i+1]
          A[i+1]=maxi
        else:
          break     
      continue
    else:
      continue
  else :
    maxi=maxi//(2**M)
    A[0]=maxi
    break

amount=sum(A)
print(amount)

### FIXED CODE ###

N,M=map(int,input().split())
A=list(map(int,input().split()))
for i in range(N):
  A[i]*=-1
import heapq
heapq.heapify(A)
import math
for i in range(M):
  maxi=heapq.heappop(A)
  maxi=math.ceil(maxi/2)
  heapq.heappush(A,maxi)
  
ans=sum(A)*(-1)
print(ans)
# -*- coding: utf-8 -*-
from itertools import itertools_with_replacement
N,M,Q=map(int,input().split())
abcd=[]
for _ in range(Q):
    abcd.append(tuple(map(int,input().split())))
Abase=[]
for a in range(1,M+1):
    Abase=Abase+[a]
A=set(itertools.combinations_with_replacement(Abase,N))
ans=0
for i in A:
    temp=0
    for j in abcd:
        if i[j[1]-1]-i[j[0]-1]==j[2]:
            temp=temp+j[3]
    if temp>=ans:
        ans=temp
print(ans)

### FIXED CODE ###

# -*- coding: utf-8 -*-
K=int(input())
A,B=map(int,input().split())
i=1
ans=0
while B>=K*i:
    if A<=K*i:
        ans=1
        break
    i=i+1
if ans==1:
    print("OK")
else:
    print("NG")
N,K=map(int,input().split())
h=[int(input()) for i in range(N)]
h=sorted(h)
t=[]
for i in range(N-K+1):
  s=h[i+k-1]-h[i]
  t.append(s)
print(min(t))
  

### FIXED CODE ###

N,K=map(int,input().split())
h=list(int(input()) for i in range(N))
h=sorted(h)
t=[]
for i in range(N-K+1):
  s=h[i+K-1]-h[i]
  t.append(s)
print(min(t))
n, k = map(int, input().split())
nums = list(map(int, input().split()))
p = []
m = []

for i in nums:
    if i >= 0:
        p.append(i)
    else:
        m.append(i)

p.sort()
m.sort(reverse = True)

ans = 1
MOD = 1e9 + 7

if n == k:
    for i in nums:
        ans = ans * i % MOD
    print(int(ans))
    exit()

if not p and k % 2 == 1:
    for i in range(k):
        ans = ans * m[i] % MOD
    print(int(ans))
    exit()

ps = []
ms = []
cnt = 0
for i in range (k):
    if not p:
        ms.append(m.pop())
        continue
    if not m:
        ps.append(p.pop())
        cnt += 1
        continue
    
    if p[-1] >= abs(m[-1]):
        ps.append(p.pop())
    else:
        ms.append(m.pop())
        cnt += 1

if cnt % 2 == 1:
    if not p or m[-1] / ps[-1] >= p[-1] / ms[-1]:
        ps.pop()
        ms.append(m.pop())
    if not m or m[-1] / ps[-1] < p[-1] / ms[-1]:
        ms.pop()
        ps.append(p.pop())

for i in ps:
    ans = ans * i % MOD
for i in ms:
    ans = ans * i % MOD

print(int(ans))

### FIXED CODE ###

n,k = map(int,input().split())
A = list(map(int,input().split()))
mod = 10**9+7
plus = []
minus=[]
for i in A:
    if i>=0:
        plus.append(i)
    else:
        minus.append(i)
ok = False
if len(plus)>0:
    if n==k:
        ok = (len(minus)%2==0)
    else:
        ok = True
else:
    ok = (k%2==0)
ans = 1
if not ok:
    A.sort(key=abs)
    for i in range(k):
        ans *= A[i]
        ans %= mod
else:
    plus.sort()
    minus.sort(reverse=True)
    if k%2 == 1:
        ans *= plus.pop()
    P = []
    while len(plus) >= 2:
        P.append((plus.pop())*(plus.pop()))
    while len(minus) >= 2:
        P.append((minus.pop())*(minus.pop()))
    P.sort(reverse=True)
    for i in range(k//2):
        ans *= P[i]
        ans %= mod
print(ans)
N = int(input())
X = []
Y = []

for x in map(int, input().split()):
    X.append(x)

for y in map(int, input().split()):
    Y.append(y)

d_list = []

for i in  range(N):
    d = X[i] - Y[i]
    if d > 0:
        d_list.append(d)

if d_list:
    print(max(d_list) + min(d_list))
else:
    print(0)  

### FIXED CODE ###

N, *V = map(int, open(0).read().split())
s = 0
for i in range(N):
    v = V[i]
    c = V[i+N]
    s += (v - c if v - c > 0 else 0)

print(s)
m=2019
l,r=map(int,input().split())

if l==0 or l%m>r%m or m*(r%m)==r:
  print(0)
  exit()

import numpy as np
lr=m
for ii in np.arange(l,r):
  for jj in np.arange(ii+1,r+1):
    t=((ii%m)*(jj%m))%m
    if t==0:
        print(0)
        exit()
    if t<lr:
      lr=t
print(lr)

### FIXED CODE ###

m=2019
l,r=map(int,input().split())

if l==0 or l//m<r//m or l%m==0:
  print(0)
  exit()

import numpy as np
lr=m
for ii in np.arange(l,r):
  for jj in np.arange(ii+1,r+1):
    t=((ii%m)*(jj%m))%m
    if t==0:
        print(0)
        exit()
    if t<lr:
      lr=t
print(lr)
def find(Tree, x):
    if Tree[x] < 0:
        return x
    else:
        Tree[x] = find(Tree, x)
        return Tree[x] 

def unite(Tree, a, b):
    a, b = find(Tree, a), find(Tree, b)
    if a != b:
        if Tree[a] > Tree[b]:
            Tree[a] = Tree[a] + Tree[b]
            Tree[b] = a
        else:
            Tree[b] = Tree[b] + Tree[a]
            Tree[a] = b 

n, m = map(int, input().split())
UF = [-1 for i in range(n)]
for i in range(m):
    ai, bi = map(int, input().split())
    unite(UF, ai, bi)

ans = 0
for i in range(n):
    if UF[i] < 0: ans += 1 
print(ans - 1)

### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000)

def find(Data, x):
    if Data[x] < 0:
        return x
    else:
        Data[x] = find(Data, Data[x])
        return Data[x] 

def unite(Data, a, b):
    a, b = find(Data, a), find(Data, b)
    if a == b:
        pass
    elif Data[a] < Data[b]:
        Data[a] = Data[a] + Data[b]
        Data[b] = a
    else:
        Data[b] = Data[b] + Data[a]
        Data[a] = b 

n, m = map(int, input().split())
UF = [-1 for i in range(n)]
for i in range(m):
    ai, bi = map(int, input().split())
    ai, bi = ai - 1, bi - 1
    unite(UF, ai, bi)

ans = 0
for i in range(n):
    if UF[i] < 0: ans += 1 
print(ans - 1)
n=int(input())
xy=[map(int,input().split()) for _ in range(n)]
l=[]
for i in range(n-1):
    for j in range(i+1,n):
        l.append(math.sqrt((xy[i][0]-xy[j][0])**2 + (xy[i][1]-xy[j][1])**2))
print(sum(l)*2/n)

### FIXED CODE ###

import math
n=int(input())
xy=[list(map(int,input().split())) for _ in range(n)]
l=[]
for i in range(n-1):
    for j in range(i+1,n):
        l.append(math.sqrt((xy[i][0]-xy[j][0])**2 + (xy[i][1]-xy[j][1])**2))
print(sum(l)*2/n)
import numpy as np
N, L, T = map(int, input().split())
X = []
W = []
ant = [i for i in range(N)]
for i in range(N):
    xi, wi = map(int, input().split())
    X.append(xi)
    W.append(wi)

npX = np.array(X).astype(np.float)
npW = np.array(W).astype(np.float)
npW[npW == 2] = -1

def swap(ant, i, j):
    tmp = ant[i]
    ant[i] = ant[j]
    ant[j] = tmp
    return ant

ans = (npX + npW * T) % L

T %= L
if T > L - T:
    T = L - T
    npW *= -1
t = 0
while t < T:
    t += 0.5
    npX = (npX + npW * 0.5) % L
    colision = set([e for e in set(npX) if np.sum(npX == e) == 2])
    if len(colision) != 0:
        for e in colision:
            i, j = np.where(npX == e)[0].tolist()
            swap(ant, i, j)

for i in range(N):
    print(int(ans[ant.index(i)]))



### FIXED CODE ###

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

sign = 0
c = 0
for i in range(1,len(A)):
    dif = A[i] - A[i-1]
    if dif * sign < 0:
        c += 1
        sign = 0
        continue
    if dif != 0:
        sign = dif
print(c+1)
a = int(input())
b = int(input())

souwa = 0
n = b - a
for i in range(n):
    souwa += i

x = souwa - b

print(x)

### FIXED CODE ###

a,b = [int(i) for i in input().split()]
     
souwa = 0
n = b - a
for i in range(n+1):
    souwa += i
         
x = souwa - b
         
print(x)
A = input()
B = input()
C = input()
if A > C > B :
    print("Yes")
elif B > C > A :
    print("Yes")
else :
    print("No")


### FIXED CODE ###

A,B,C = map(int,input().split())
if A > C > B :
    print("Yes")
elif B > C > A :
    print("Yes")
else :
    print("No")
a,op,b=input().split())
if op=="+":
    print(int(a)+int(b))
else:
    print(int(a)-int(b))

### FIXED CODE ###

a,op,b=input().split()
if op=="+":
    print(int(a)+int(b))
else:
    print(int(a)-int(b))
a, b = map(it, inpput().split())
print((a + b) % 24)

### FIXED CODE ###

a, b = map(int, input().split())
print((a + b) % 24)
N = int(input())
sum = 0
for i in range(0,N+1):
  sum + i = sum
print(sum)

### FIXED CODE ###

N = int(input())
sum = 0
for i in range(0,N+1):
  sum+=i
print(sum)
x = input()

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

### FIXED CODE ###

x = int(input())

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

if c>=10:
  print('error')
  
  else:
    print(a+b)


### FIXED CODE ###

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

if a+b<10:
  print(a+b)
else:
  print("error")
r, c = [int(i) for i in input().split()]

data = []
sum_row = [0] * (c + 1)

for ri in range(r):
    data[ri].append([int(i) for i in input().split()])
    data[ri].append(sum(data[ri]))
    print(" ".join([str(d) for d in data[ri]]))
    for ci in range(c + 1):
        sum_row[ci] += data[ri] [ci]
print(" ".join([str(s) for s in sum_row]))

from pprint import pprint
pprint(data)
pprint(sum_row)

### FIXED CODE ###

r, c = [int(i) for i in input().split()]

data = []
sum_row = [0] * (c + 1)

for ri in range(r):
    data.append([int(i) for i in input().split()])
    data[ri].append(sum(data[ri]))
    print(" ".join([str(d) for d in data[ri]]))
    for ci in range(c + 1):
        sum_row[ci] += data[ri][ci]
print(" ".join([str(s) for s in sum_row]))
# -*- coding: utf-8 -*-
S = (input())
# 出力
# 奇数を取得
if(S[0] == s[1] == s[2]):
    print('No')
else:
    print('Yes')


### FIXED CODE ###

# -*- coding: utf-8 -*-
S = (input())
# 出力
# 奇数を取得
if(S[0] == S[1] == S[2]):
    print('No')
else:
    print('Yes')
import math

def isPrime(num):
    if num < 2:
        return False
    else:
        rootNum = math.floor(math.sqrt(num))
        for i in range(2,rootNum+1):
            if num % i == 0:
                return False
    return True

def solve():
    lst = []
    count = int(input())
    for i in range(count):
        ans = 0
        l, r = map(int, input().split())
        t = l
        while k <= r
            if isPrime(k) and isPrime((k+1)/2):
                ans += 1
            k += 2
        lst.append(str(ans))
    print('\n'.join(lst))
solve()


### FIXED CODE ###

print("{}".format(24 - int(input()) + 24))
import math
A,B = list(map(int,input().split()))
print(A*B/math.gcd(A,B))

### FIXED CODE ###

import fractions
A,B = list(map(int,input().split()))
print(int(A*B/fractions.gcd(A,B)))
a, b = map(int, input().split())
import math
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))

### FIXED CODE ###

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

def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
	
def lcm(x, y):
    return (x * y) // gcd(x, y)

print(lcm(a, b))