Harryxun/stf_run huggingface dataset:
n=int(input())
ans=0
for a in range(1,n-1):
	for b in range(1,n-a):
		if n-a*b<=0:
			continue
		else:
			ans=+=1
print(ans)

### FIXED CODE ###

def resolve():
    #n=int(input())
    #a,b=map(int,input().split())
    #x=list(map(int,input().split()))
    #a=[list(map(lambda x:int(x)%2,input().split())) for _ in range(h)]
    n=int(input())
    ans=0
    for a in range(1,n):
      if n-a*a<=0:
        break
      else:
        ans+=1
    for a in range(1,n-1):
      for b in range(a+1,n):
        if n-a*b<=0:
          break
        else:
          ans+=2
    print(ans)

if __name__ == '__main__':
    resolve()
import math

s = input()
if len(s) < 3:
    print(0)
    exit(0)
l = []
for i in range(2):
    l.append(s[len(s) // 3 * i:len(s) // 3 * (i + 1)])
l.append(s[len(s) // 3 * 2:])
ans = 0
for i, s in enumerate(l):
    for i in reversed(range(int(math.log2(len(s)))+1)):
        w = 2**i
        while "A" + "BC" * w in l[i] or "A" * w + "BC" in l[i]:
            m = l[i].count("A" + "BC" * w)
            l[i] = l[i].replace("A" + "BC" * w, "BC" * w + "A")
            m += l[i].count("A" * w + "BC")
            l[i] = l[i].replace("A" * w + "BC", "BC" + "A" * w)
            ans += w * m
s = ''.join(l)
for i in reversed(range(int(math.log2(len(s)))+1)):
    w = 2**i
    while "A" + "BC" * w in s or "A" * w + "BC" in s:
        m = s.count("A" + "BC" * w)
        s = s.replace("A" + "BC" * w, "BC" * w + "A")
        m += s.count("A" * w + "BC")
        s = s.replace("A" * w + "BC", "BC" + "A" * w)
        ans += w * m
print(ans)


### FIXED CODE ###

s = input()
n = len(s)
st = ''
i = 0
while i < n:
    if i < n - 1 and s[i] == 'B' and s[i + 1] == 'C':
        st += 'D'
        i += 1
    else:
        st += s[i]
    i += 1
ans = 0
ac = 0
for c in st:
    if c in ('B', 'C'):
        ac = 0
    elif c == 'A':
        ac += 1
    elif c == 'D':
        ans += ac
print(ans)
w, h, x, y = list(map(int, input().split()))
print(w * h / 2, 1 int((w==x*2) and (h==y*2)))


### FIXED CODE ###

w, h, x, y = list(map(int, input().split()))
print(w * h / 2, 1 if (w==x*2) and (h==y*2) else 0)
N,K = map(int(input().split()))
A = list(map(int,input().split())))
g = A[0]
import fractions
for i in range(1,N):
    g = fractions.gcd(g,A[i])
if K % g == 0:
    if K <= M:
        print('POSSIBLE')
    else:
        print('IMPOSSIBLE')
else:
    print('IMPOSSIBLE')

### FIXED CODE ###

N,K = map(int,input().split())
A = list(map(int,input().split()))
g = A[0]
import fractions
for i in range(1,N):
    g = fractions.gcd(g,A[i])
if K % g == 0:
    if K <= max(A):
        print('POSSIBLE')
    else:
        print('IMPOSSIBLE')
else:
    print('IMPOSSIBLE')
a,b=int(input().split())
print((a*(a-1))//2+(b*(b-1))//2)

### FIXED CODE ###

a,b=list(map(int, input().split()))
print((a*(a-1))//2+(b*(b-1))//2)
h,w = list(map(int,input().split()))

mat = []
for i in range(h):
    array = list(map(int,input().split()))
    mat.append(array)

count=0
s=""

for i in range(0,h//2+1,2):
    for j in range(w):
        if mat[i][j]%2 !=0:
            mat[i][j]-=1
            count+=1
            if (j+1)==w:
                mat[i+1][j]+=1
                s+=' '.join(map(str,[i+1,j+1,i+2,j+1]))
                s+='\n'
            else:
                mat[i][j+1]+=1
                s+=' '.join(map(str,[i+1,j+1,i+1,j+2]))
                s+='\n'
    
    i+=1
    for j in range(w-1,0,-1):
        if mat[i][j]%2!=0:
            mat[i][j]-=1
            count+=1
            if (j-1)==0:
                mat[i-1][j]+=1
                s+=' '.join(map(str,[i+1,j+1,i,j+1]))
                s+='\n'
            else:
                mat[i][j-1]+=1
                s+=' '.join(map(str,[i+1,j+1,i+1,j]))
                s+='\n'

if h%2!=0:
    i=h-1
    for j in range(w):
        if mat[i][j]%2 !=0:
            if(j+1!=w):
                mat[i][j]-=1
                mat[i][j+1]+=1
                s+=' '.join(map(str,[i+1,j+1,i+1,j+2]))
                s+='\n'
                count+=1                

print(count)
print(s)


### FIXED CODE ###

H,W = map(int,input().split())
src =[list(map(int,input().split())) for i in range(H)]

order=[]
for i in range(H):
    if i%2==0:
        for j in range(W):
            order.append((i,j))
    else:
        for j in reversed(range(W)):
            order.append((i,j))

ans=[]

for(y1,x1),(y2,x2) in zip(order,order[1:]):
    if src[y1][x1]%2:
        ans.append((y1+1,x1+1,y2+1,x2+1))
        src[y2][x2]+=1
print(len(ans))
for row in ans:
    print(*row)
n, k = map(int, input().split())
a = [0] + list(map(int, input().split()))
root = [1]
for i in range(1000):
    next_num = a[root[-1]]
    root.append(next_num)

if k < n+1:
    print(root[k])
    exit()

loop_end = n 
loop_start = n-1
while(root[loop_start]!=root[loop_end]):
    loop_start -= 1
period = loop_end - loop_start
k %= period
while k < n:
    k += period
print(root[k])


### FIXED CODE ###

n, k = map(int, input().split())
a = [0] + list(map(int, input().split()))
root = [1]
for i in range(2*n+1000):
    next_num = a[root[-1]]
    root.append(next_num)

if k < n+1:
    print(root[k])

else: 
    loop_end = n 
    loop_start = n-1
    while(root[loop_start]!=root[loop_end]):
        loop_start -= 1
    period = loop_end - loop_start
    k %= period
    while k < n:
        k += period
    print(root[k])
n=int(input())
la=sorted(list(map(int,input().split())))
lb=list(map(int,input().split()))
lc=sorted(list(map(int,input().split())))
def lower(n,l):
  left=-1
  right=len(l)
  while right>left+1:
    mid=left+right
    mid=mid//2
    if n>l[mid]:
      left=mid
    elif n<l[mid]:
      right=mid
  return left+1
def upper(n,l):
  def lower(n,l):
  left=-1
  right=len(l)
  while right>left+1:
    mid=left+right
    mid=mid//2
    if n>l[mid]:
      left=mid
    elif n<l[mid]:
      right=mid
  return len(l)-right
c=0
for i in lb:
  c+=lower(i,la)*upper(i,lb)
print(c)

### FIXED CODE ###

import bisect
n=int(input())
la=sorted(map(int,input().split()))
lb=sorted(map(int,input().split()))
lc=sorted(map(int,input().split()))
countb=[]
count1=0
for i in range(n):
  index=bisect.bisect_left(la,lb[i])
  countb.append(index)
countb2=[]
sum=0
for i in range(n):
  sum+=countb[i]
  countb2.append(sum)
ans=0
for i in range(n):
  index=bisect.bisect_left(lb,lc[i])
  if index==0:
    pass
  else:
    ans+=countb2[index-1]
print(ans)
a, b, c, d = map(int, input().split())
while 1:
    c -= b
    if(c <= 0):
        print("Yes")
        break
    a -= d:
    if(a <= 0):
        print("No")
        break


### FIXED CODE ###

import math
a, b, c, d = map(int, input().split())
if math.ceil(c / b) <= math.ceil(a / d):
  print("Yes")
else:
  print("No")
import fractions
n = int(input())
a = list(map(int, input().split()))
s = [0]
small = 10**9
c = 0
for i in range(n-1):
    s.append(fractions.gcd(a[i], a[i+1]))
    if fractions.gcd(a[i], a[i+1]) <= small:
        small = fractions.gcd(a[i], a[i+1])
        c = i+1
s.append(fractions.gcd(a[n-1], a[0]))
if fractions.gcd(a[n-1], a[0]) <= small:
    small = fractions.gcd(a[n-1], a[0])
    c = n
if c != 1 and c != n:
    if s[c-1] > s[c+1]:
        d = c+1
    else:
        d = c-1
if c == 1:
    if s[n] > s[2]:
        d = 2
    else:
        d = n
if c == n:
    if s[n-1] > s[1]:
        d = 1
    else:
        d = n-1
del s[c]
del s[d]
del s[0]
if n == 2:
    ans = max(a)
else:
    ans = min(s)
print(ans)

### FIXED CODE ###

from fractions import gcd
n = int(input())
a = list(map(int, input().split()))
s1 = [0]*(n+1)
s2 = [0]*(n+1)
s1[0] = 0
s1[1] = a[0]
s2[0] = 0
s2[n] = a[n-1]
for i in range(2, n+1):
    s1[i] = gcd(s1[i-1], a[i-1])
    s2[n-i+1] = gcd(s2[n-i+2], a[n-i])
if s1[n-1] >= s2[2]:
    ans = s1[n-1]
else:
    ans = s2[2]
for i in range(2, n):
    b = gcd(s1[i-1], s2[i+1])
    if ans <= b:
        ans = b
print(ans)
n,a,b=map(int,input().split())
c=[i+1 for i in range(n)]
e=0
for i in range(n):
    d[i]=c[i]%10+(c[i]//10)%10+(c[i]//100)%10+(c[i]//1000)%10+(c[i]//10000)%10
    if d[i]>=a and d[i]<=b:
        e+=c[i]
print(e) 


### FIXED CODE ###

n,a,b=map(int,input().split())
c=[i+1 for i in range(n)]
d=[i+1 for i in range(n)]
e=0
for i in range(n):
    d[i]=c[i]%10+(c[i]//10)%10+(c[i]//100)%10+(c[i]//1000)%10+(c[i]//10000)%10
    if d[i]>=a and d[i]<=b:
        e+=c[i]
print(e)
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192

### FIXED CODE ###

import random
d=int(input())
c=list(map(int,input().split()))
s=[list(map(int,input().split())) for _ in range(d)]



for i in range(d):
    print(random.randrange(1,27))
p = int(input().split()[1])
s = input()
if 10 % p == 0:
  r = sum(i for i, x in enumerate(s, 1) if int(x) % p == 0)
else:
  d = [1] + [0] * (p - 1)
  s, y = 0, 1
  for x in reversed(s):
    t = (t + int(x) * y) % p
    d[t] += 1
    y = y * 10 % p;
  r = sum(i * (i - 1) // 2 for i in d)
print(r)

### FIXED CODE ###

from itertools import accumulate
from collections import Counter

p = int(input().split()[1])
a = list(map(int, input()))
if 10 % p == 0:
  r = sum(i for i, x in enumerate(a, 1) if x % p == 0)
else:
  a = accumulate(x * pow(10, i, p) for i, x in enumerate(reversed(a), 1))
  c = Counter(x % p for x in a) 
  c[0] += 1
  r = sum(i * (i - 1) // 2 for i in c.values())
print(r)
a,b=input().split()
a=int(a)
b=int(b)
c=1
d=0
if a>b:
  for i in range(a):
    if a%i==0 and b%i==0:
      a=a/i
      b=b/i
      c=c*i
  print(a*b*c)
if a<b:
  for i in range(b):
    if a%i==0 and b%i==0:
      a=a/i
      b=b/i
      c=c*i
  print(a*b*c)

### FIXED CODE ###

a,b=input().split()
a=int(a)
b=int(b)
e=a
d=b
c=1
if a>b:
  for i in range(1,e):
    if a%(e-i)==0 and b%(e-i)==0:
      a=a/(e-i)
      b=b/(e-i)
      c=c*(e-i)
  print(int(a*b*c))
if a<b:
  for i in range(1,d):
    if a%(d-i)==0 and b%(d-i)==0:
      a=a/(d-i)
      b=b/(d-i)
      c=c*(d-i)
  print(int(a*b*c))
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))

N, C = mi()
D = li2(C)
S = li2(N)

table = dp2(0, 3, C)
'''
#for num in range(3):
    #for start in range(num, N, 3):
        for color in range(C):
            i = 0
            j = start
            print(i, j)
            while True:
                table[num][color] += D[S[i][j]-1][color]
                if j < 1 or i >= N:
                    break
                j -= 1
                i += 1
'''
for i in range(N):
    for j in range(N):
        for color in range(C):
            table[(i+j)%3][color] += D[S[i][j]-1][color]

ans = float('inf')
for i in range(C):
    for j in range(C):
        for k in range(C):
            if i == j or j == k or k == i:
                continue
            ans = min(ans, table[0][i] + table[1][j] + table[2][k])

print(ans)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))

N, C = mi()
D = li2(C)
S = li2(N)

table = dp2(0, C, 3)
'''
#for num in range(3):
    #for start in range(num, N, 3):
        for color in range(C):
            i = 0
            j = start
            print(i, j)
            while True:
                table[num][color] += D[S[i][j]-1][color]
                if j < 1 or i >= N:
                    break
                j -= 1
                i += 1
'''
for i in range(N):
    for j in range(N):
        for color in range(C):
            table[(i+j)%3][color] += D[S[i][j]-1][color]

ans = float('inf')
for i in range(C):
    for j in range(C):
        for k in range(C):
            if i == j or j == k or k == i:
                continue
            ans = min(ans, table[0][i] + table[1][j] + table[2][k])

print(ans)
import math

x,y = map(int,input().split())

print((x * y) // math.gcd(x, y))



### FIXED CODE ###


import math
import fractions

x,y = map(int,input().split())

print((x * y) // fractions.gcd(x, y))
a, b = int(input())
s = a+b
t = a-b
p = a*b
li = [s, t, p]
li.sort()
print(li[-1])

### FIXED CODE ###

a, b = map(int, input().split())
s = a+b
t = a-b
p = a*b
li = [s, t, p]
li.sort()
print(li[-1])
N = int(input())
s = []
for i in range(N):
	s.append(input())
c = 0
for j in len(s):
	c += s[i].count("AB")
a = 0
b = 0
for k in range(len(s)):
	if s[i][-1] == "A":
    	a += 1
for l in range(len(s)):
	if s[i][0] == "B":
    	b += 1
print(c+Math.min(a,b))


### FIXED CODE ###

N = int(input())
S = [input() for _ in range(N)]
ans = 0
ba = b = a = 0
for s in S:
    ans += s.count('AB')
    if s[0] + s[-1] == 'BA':
        ba += 1
    if s[0] == 'B':
        b += 1
    if s[-1] == 'A':
        a += 1
ans += min(a, b)
if a == b == ba and b:
    ans -= 1
print(ans)
a, s = input().split()
a = int(a)

if a >= 3200:
  print(s)
else:
  print('red')

### FIXED CODE ###

a = int(input())
s = input()

if a >= 3200:
  print(s)
else:
  print('red')
a,b,c,k = map(int, input().split())

la = [1]*a
lb = [0]*b
lc = [-1]*c
m = 0
l = la + lb + lc 

for i in range(k):
    m = m + l[i]
print(m)


### FIXED CODE ###

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

if k < a:
    print(k)
elif a <=k  and k <= a+b:
    print(a)
elif a + b < k and k <= a  + b + c:
    print(a-k+a+b)
a, b  = [int(i) for i in input().split()]
     
souwa = 0
n = b - a
for i in range(n):
    souwa += i
     
x = souwa - b
     
print(x)

### FIXED CODE ###

n = int(input())
if n<1000:
    print('ABC')
else:
    print('ABD')
N = int(input())
D, X = input().split()

result = int(X)
temp_D  = int(D) - 1
for _ in range(N):
  A = int(input())
  result += temp_D // A
result += N

print(result)

### FIXED CODE ###

a = input()
b = input()
c = input()
d = input()
print(min((int(a), int(b))) + min((int(c), int(d))))
a,b,c = map(int, input().split())
l = [int(input()) for _ in range(a)]
flag = True
l = sorted(l)
max_T = 10**18
def ok(k):
    s = k
    for i in l:
        hp = i - c * k
        if hp > 0:
            s -= -(-hp // (b - c))
        if s < 0:
            return False
    return True
def binary_search(l,r):
    mid = (l + r) // 2
    if l == r:
        return l
    elif ok(mid):
        return bbb(l,mid)
    else:
        if mid == l:
            mid += 1
            
        return bbb(mid,r)
binary_search(0,max_T)

### FIXED CODE ###

a,b,c = map(int, input().split())
l = [int(input()) for _ in range(a)]
flag = True
l = sorted(l)
max_T = 10**18
def ok(k):
    s = k
    for i in l:
        hp = i - c * k
        if hp > 0:
            s -= -(-hp // (b - c))
        if s < 0:
            return False
    return True
def binary_search(l,r):
    mid = (l + r) // 2
    if l == r:
        return l
    elif ok(mid):
        return binary_search(l,mid)
    else:
        if mid == l:
            mid += 1
            
        return binary_search(mid,r)
ans = binary_search(0,max_T)
print(ans)
import math
N,K=map(int,input().split())
print(int(math.factorial(N)/math.factorial(N-K)))

### FIXED CODE ###

N,K=map(int,input().split())
print(K*(K-1)**(N-1))
def solve():
    n = int(input())
    al = [int(i) for i in input().split()]
    memos = [0]*n
    for i in range(n):
        memos[i] = i - (al[i] - 1)
    # print(memos)
    ans = 0
    for idx in range(n):
        if memos[idx] == 0:
            if idx == 0:
                memos[idx], memos[idx+1] = memos[idx+1]-1, memos[idx]+1
            else:
                if memos[idx-1] > memos[idx+1]:
                    memos[idx-1], memos[idx] = memos[idx]-1, memos[idx-1]+1
                else:
                    memos[idx], memos[idx+1] = memos[idx+1]-1, memos[idx]+1
            ans += 1
        # print(memos)
    print(ans)

if __name__=="__main__":
    solve()

### FIXED CODE ###

def solve():
    n = int(input())
    al = [int(i) for i in input().split()]
    memos = [0]*n
    for i in range(n):
        memos[i] = i - (al[i] - 1)
    # print(memos)
    ans = 0
    for idx in range(n):
        if memos[idx] == 0:
            if idx != n - 1:
                memos[idx+1], memos[idx] = memos[idx+1]-1, memos[idx]+1
            else:
                memos[idx], memos[idx-1] = memos[idx-1]+1, memos[idx]-1
            ans += 1
        # print(memos)
    print(ans)

if __name__=="__main__":
    solve()
n,m=map(int,input().split())
lst=[list(input().split()) for i in range(m)]
x,y=0,0
cnt=['?']+[0]*n
cnt2=[0]+[0]*n
for i in lst:
  if i[1]=='WA':
    pin=int(i[0])
    if cnt[pin]!='AC':
      cnt2[pin]+=1
  elif i[1]=='AC':
    cnt[int(i[0])]='AC'

x=cnt.count('AC')

for i in range(len(cnt)+1):
  if cnt[i]=='AC':
    y+=cnt2[i]
print(x,y)

### FIXED CODE ###

n,m=map(int,input().split())
lst=[list(input().split()) for i in range(m)]
x,y=0,0
cnt=['?']+[0]*n
cnt2=[0]+[0]*n
for i in lst:
  if i[1]=='WA':
    pin=int(i[0])
    if cnt[pin]!='AC':
      cnt2[pin]+=1
  elif i[1]=='AC':
    cnt[int(i[0])]='AC'

x=cnt.count('AC')

for i in range(len(cnt)):
  if cnt[i]=='AC':
    y+=cnt2[i]
print(x,y)
# a から bで　cでもdでも割り切れないものの数を調べる
import math

Input = input()
a, b, c, d = Input.split()
a, b, c, d = int(a), int(b), int(c), int(d)

c_min = int(a/c) if a % c == 0 else int(a/c) + 1
c_max = int(b/c)
delta_c = c_max - c_min + 1

d_min = int(a/d) if a % c == 0 else int(a/d) + 1
d_max = int(b/d)
delta_d = d_max - d_min + 1

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

cd = lcm(c, d)
cd_min = int(a/cd) if a % c == 0 else int(a/cd) + 1
cd_max = int(b/cd)
delta_cd = cd_max -cd_min + 1

# cとdで割り切れる数
num_cd = delta_c + delta_d - delta_cd
print( b-a+1 - num_cd)

### FIXED CODE ###

from fractions import gcd
Input = input()
a, b, c, d = Input.split()
a, b, c, d = int(a), int(b), int(c), int(d)
delta_c = b//c - (a-1)//c
delta_d = b//d - (a-1)//d
def lcm(x, y):
    return (x * y) // gcd(x, y)
cd = lcm(c, d)
delta_cd = b//cd - (a-1)//cd
num_cd = delta_c + delta_d - delta_cd
print( b-a+1 - num_cd, end='')
A,B=input().split();
if B<=0:
    if A+B<=A*B:
        print(A*B);
    else:
        print(A+B);
else:
    if A-B<=A*B:
        print(A*B);
    else:
        print(A-B);

### FIXED CODE ###

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

print(max(a+b, a-b, a*b))
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
from functools import reduce

def segfunc(a,b):
    if a == 0 or b == 0:
        return max(a, b)
    if a < b:
        a, b = b, a
    r = a % b
    if r == 0:
        return b
    return segfunc(b, r)

def gcd_list(numbers):
    return reduce(segfunc, numbers)

def init(init_val):
    #set_val
    for i in range(n):
        seg[i+num-1]=init_val[i]    
    #built
    for i in range(num-2,-1,-1) :
        seg[i]=segfunc(seg[2*i+1],seg[2*i+2]) 
    
def update(k,x):
    k += num-1
    seg[k] = x
    while k:
        k = (k-1)//2
        seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
    
def query(p,q):
    if q<=p:
        return ide_ele
    p += num-1
    q += num-2
    res=ide_ele
    while q-p>1:
        if p&1 == 0:
            res = segfunc(res,seg[p])
        if q&1 == 1:
            res = segfunc(res,seg[q])
            q -= 1
        p = p//2
        q = (q-1)//2
    if p == q:
        res = segfunc(res,seg[p])
    else:
        res = segfunc(segfunc(res,seg[p]),seg[q])
    return res


n = ii()
#A = sorted(li())
A = li()

#####単位元######
'''
if n == 2:
    print(max(A))
    exit()
elif n == 3:
    ide_ele = max(segfunc(A[0], A[1]), segfunc(A[1], A[2]), segfunc(A[0], A[2]))
else:
    #ide_ele = max(segfunc(A[-1], A[-2]), segfunc(A[-3], A[-4]))
    ide_ele = max(segfunc(A[0], A[1]), segfunc(A[2], A[3]))
    print(segfunc(A[0], A[1]), segfunc(A[2], A[3]))
'''
ide_ele = 0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num

init(A)
ans = 0

#ans = max(query(1, n), ans)
#for i in range(1, n-1):
for i in range(n):
    #print(i, query(0, i), query(i+1, n))
    ans = max(segfunc(query(0, i), query(i+1, n)), ans)
#ans = max(query(0, n-1), ans)

print(ans)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))

A, B, T = mi()

print(B * (T//A))
import sys

read = sys.stdin.read
readline = sys.stdin.readline

N, M, *A = map(int, read().split())
A = tuple(zip(*[iter(A)] * M))

# 各スポーツに参加している人数
p = [0] * (M + 1)
# 人iはn番目に好きなスポーツに参加している
sports = [0] * (N + 1)
answer = []


def solve(s, n, p, sports):
    # nは開催しているスポーツの数
    # sは新たに開催をやめるスポーツ
    p[s] = 0
    if n == M:
        for i in A:
            p[i[0]] += 1
        p_max = max(p)
        answer.append(p_max)
        cancel = [idx for idx, i in enumerate(p) if i == p_max]
        for i in cancel:
            solve(i, n - 1, p, sports)
    elif n == 1:
        pass
    else:
        for idx, i in enumerate(A, 1):
            if i[sports[idx]] == s:
                sports[idx] += 1
                p[i[sports[idx]]] += 1
        p_max = max(p)
        answer.append(p_max)
        cancel = [idx for idx, i in enumerate(p) if i == p_max]
        for i in cancel:
            solve(i, n - 1, p, sports)


solve(0, M, p, sports)
print(min(answer))


### FIXED CODE ###

import sys

read = sys.stdin.read
readline = sys.stdin.readline

N, M, *A = map(int, read().split())
A = list(map(list, map(reversed, zip(*[iter(A)] * M))))

# 各スポーツに参加している人数
p = [0] * (M + 1)
canceled = set()
answer = []


def solve(s, n):
    # nは開催しているスポーツの数
    # sは新たに開催をやめるスポーツ
    if n == 1:
        answer.append(N)
    elif n == M:
        for i in A:
            p[i[-1]] += 1
        p_max = max(p)
        answer.append(p_max)
        cancel = p.index(p_max)
        solve(cancel, n - 1)
    else:
        canceled.add(s)
        p[s] = 0
        for i in range(N):
            if A[i][-1] in canceled:
                while A[i][-1] in canceled:
                    A[i].pop()
                p[A[i][-1]] += 1
        p_max = max(p)
        answer.append(p_max)
        cancel = p.index(p_max)
        solve(cancel, n - 1)


solve(0, M)
print(min(answer))