Harryxun/stf_run huggingface dataset:
input(num)

multiple = num * num * num

print(multiple)


### FIXED CODE ###

x = input()

x = int(x) 
mul = x

for i in range(0, 2):
	mul = mul * x

print(mul)
import sys

if __name__ == "__main__":
  for line in sys.stdin:
    anis, legs = line.split(' ')
    if legs % 2 == 1 or legs > anis * 4 or legs < anis * 2:
      print("No")
    else:
      print("Yes")
      
          

### FIXED CODE ###

import sys

if __name__ == "__main__":
    for line in sys.stdin:
        anis, legs = map(int, line.split(' '))
        if legs % 2 == 1 or legs > anis * 4 or legs < anis * 2:
            print("No")
        else:
            print("Yes")
N = int(input())
if N % 2 =1:
  n = int((N+1)/2)
else:
  n = int(N/2)
res = n/N
print(res)

### FIXED CODE ###

N = int(input())
if N % 2 ==1:
  n = int((N+1)/2)
else:
  n = int(N/2)
res = n/N
print(res)
import random

def calc(t, D, s):
  last = [0 for _ in range(26)]
  value = 0
  for i in range(D):
    day = i + 1
    value += s[i][t[i]-1]
    last[t[i]-1] = day
    for j in range(26):
      value -= c[j] * (day - last[j])
  return value

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

t = random.sample(range(1, 27), k=D)

val = calc(t, D, s)
for _ in range(1000):
  d_rand = random.randrange(1, D+1)
  q_rand = random.randrange(1, 27)
  old = t[d_rand-1]
  t[d_rand-1] = q_rand
  if val < calc(t, D, s):
    t[d_rand-1] = old
  else:
    val = calc(t, D, s)

for i in range(D):
  print(t[i])

### FIXED CODE ###

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(s[i].index(max(s[i]))+1)
l = map(int(raw_input(), 16).split())

if l[0] < l[1]:
  print("<")
elif l[0] = l[1]:
  print ("=")
elif l[0] > l[1]:
  print(">")


### FIXED CODE ###

l = input().split()
l2 = [int(s, 16) for s in l]

if l2[0] < l2[1]:
  print("<")
elif l2[0] == l2[1]:
  print ("=")
elif l2[0] > l2[1]:
  print(">")
w, h, x, y= map(int,input().split())

f = 0
if x <= w/2 and y <= h/2:
    if y/x == h/w and x == w/2 and y == h/2:
        s = h*w/2
        f = 1
    elif y/x == h/w and (x < w/2 or y < h/2):
        s = h*w/2
    else:
        s1 = x*h
        s2 = w*y
        s = max(s1,s2)
        if s1 == s2:
            f=1
    print(s,f)
elif x > w/2 and y <= h/2:
    if (h-y)/x == h/w:
        s = h*w/2
    else:
        s1 = (w-x)*h
        s2 = w*y
        s = max(s1,s2)
        if s1 == s2:
            f=1
    print(s,f)
elif x > w/2 and y > h/2:
    if y/x == h/w:
        s = h*w/2
    else:
        s1 = (w-x)*h
        s2 = w*(h-y)
        s = max(s1,s2)
        if s1 == s2:
            f=1
    print(s,f)
elif x <= w/2 and y > h/2:
    if (h-y)/x == h/w:
        s = h*w/2
    else:
        s1 = x*h
        s2 = w*(h-y)
        s = max(s1,s2)
        if s1 == s2:
            f=1
    print(s,f)

### FIXED CODE ###

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

f = 0
s = h*w/2
if x == w/2 and y == h/2:
    f = 1

print(s,f)
N = int(input())
L = map[int,input().split()]

ans = 1
for i in L
	if  L(:i)>L(i):
		continue
    else:
		ans = ans+1

### FIXED CODE ###

N = int(input())
H = list(map(int,input().split()))
NowHeight = 0
ans = 0
for i in range(N):
  if NowHeight <= H[i]:
    NowHeight = H[i]
    ans += 1
print(ans)
N = int(input())
W = []
for j in range(N):
  W.append(input())
  j += 1


i = 0
while i < N:
  m = W[i-1]
  n = W[i]
  if m[-1:] == n[:1]:
    i += 1
  else:
    print('No')
    exit()
else:
  W.sort()
  for k in range(N):
      m = W[i]
      n = W[i+1]
      if m == n:
        print('No')
        exit()
print('Yes')

### FIXED CODE ###

N = int(input())
W = [0] * N
for i in range(N):
    W[i] = input()
if len(set(W)) != N:
    print('No')
    exit()
for i in range(N - 1):
    w1 = W[i]
    w2 = W[i+1]
    if w1[-1] != w2[0]:
        print('No')
        exit()
print('Yes')
import math
n=int(input())
a=list(map(int,input().split()))
m1=min(a)

def a_gcd(t,y):
    return math.gcd(t,y)

if m1==1:
    print(m1)
    exit()
for i in range(n):
    m1=a_gcd(m1,a[i])
    if m1==1:
        break

print(m1)

### FIXED CODE ###

"""
import math
n=int(input())
a=list(map(int,input().split()))
m1=min(a)

def a_gcd(t,y):
    return math.gcd(t,y)

if m1==1:
    print(m1)
    exit()
for i in range(n):
    m1=a_gcd(m1,a[i])
    if m1==1:
        break

print(m1)
"""
import fractions
n=int(input())
a=list(map(int,input().split()))
m1=min(a)

def a_gcd(t,y):
    return  fractions.gcd(t,y)

if m1==1:
    print(m1)
    exit()
for i in range(n):
    m1=a_gcd(m1,a[i])
    if m1==1:
        break

print(m1)
from gcd import math
K=int(input())
res=0
for i in range(1,K+1):
     for j in range(1,K+1):
            for k in range(1,K+1):
                res=res+gcd(gcd(i,j),k)
print(res)

### FIXED CODE ###

from math import gcd 
K=int(input())
res=0
for i in range(1,K+1):
     for j in range(1,K+1):
            for k in range(1,K+1):
                res += gcd(gcd(i,j),k)
print(res)
import sys
 
ff = sys.stdin
 
while True :
    a, b = map(int, ff.readline().split())
    if (a == 0) & (b == 0) : break
    elif a < b :
		print(a, b)
    else :
		print(b, a)

### FIXED CODE ###

import sys

for in_str in sys.stdin:
    comp_list = list(map(int, in_str.split(" ")))
#    a, b = map(int, in_str.split())
    a = comp_list[0]
    b = comp_list[1]
    if a == 0 and b == 0 : break
    elif a < b :
        print(a, b)
    else :
        print(b, a)
def _quick_sort(array, left, right):
    if left >= right: return

    # ピボットを決定
    pivot = median(array[left], array[(left + (right - left) // 2)], array[right])
    l = left
    r = right

    # ピボットを中心に分ける
    while True:
        # ピボットより小さい値を左、大きい値を右に移動する
        while array[l] < pivot:
            l += 1
        while pivot < array[r]:
            r -= 1
        if (r <= l): break

        # 見つかった要素を交換
        tmp = array[l]
        array[l] = array[r]
        array[r] = tmp
        l += 1
        r -= 1

    # 左右に分けた部分を再帰的にクイックソート
    _quick_sort(array, left, l - 1)
    _quick_sort(array, r + 1, right)

def quick_sort(array):
    _quick_sort(array, 0, len(array)-1)

def median(x, y, z):
    if x < y:
        return (y if y < z else z) if x < z else x
    else:
        return (x if x < z else z) if y < z else y

n=input()
S=[]
for i in input().split():
    S.append(int(i))
S=quick_sort_(S)
word=int(int(n)/2)
s=int(S[word])-int(S[word-1])
s2=int(S[word+1])-int(S[word])
print(s)


### FIXED CODE ###

import numpy as np
n=input()
S=[]
for i in input().split():
    S.append(int(i))
S=np.array(S)
word=int(int(n)/2)
asa=S.argsort()
s=int(S[asa[word]])-int(S[asa[word-1]])
print(s)
def gcd(x, y):
    r = modlog(x, y)
    while r != 0:
        x = y
        y = r
        r = modlog(x, y)
    return y

def modlog(x, y):
    r = x % y
    return r

if __name__ == '__main__' :
    N,X = map(int, input().split())
    x = list(map(int, input().split()))

    dist_list = [abs(d-X) for d in x]

    alpha = gcd(dist_list[0],dist_list[1])
    for d in dist_list:
        alpha = gcd(alpha,d)

    print(alpha)

### FIXED CODE ###

if __name__ == '__main__' :
    A,B = list(map(int, input().split()))
    if A%2 == 0 or B%2 == 0:
        print('No')
    else:
        print('Yes')
n = int(input())
possible = [1]
i=1
while i <= 100000:
  i = i*6
  possible+=[i]
i=1
while i <= 100000:
  i = i*9
  possible+=[i]
possible.sort(reverse =1)
ans = 1
table = set(possible)
while True:
  if n in table:
    print(ans)
    break
  ans+=1
  nexttable = set()
  for num in table:
    for p in possible:
      if num + p <100000
        nexttable.add(num+p)
  table = table | nexttable

### FIXED CODE ###

n = int(input())
possible = [1]
i=1
while i <= 100000:
  i = i*6
  possible+=[i]
i=1
while i <= 100000:
  i = i*9
  possible+=[i]
possible.sort(reverse =1)
ans = 0
table = set([n])
while True:
  if 0 in table:
    print(ans)
    break
  ans+=1
  nexttable = set()
  for num in table:
    for p in possible:
      if num - p >= 0:
        nexttable.add(num-p)
  table =nexttable
n,k = map(int,input().split())
*l, = map(int,input().split())
seenl = [1]
seen = {1}
temp=1
for i in range(k):
  temp=l[temp-1]
  if temp in seen:
    lenloop = len(seenl)-seenl.index(temp)
    r = (k-i-1)%lenloop
    temp = seenl[seenl.index(temp):][r]
    break
  seenl.append(temp)
  seen.add(temp)
print(temp)

### FIXED CODE ###

t,s = [str(input()) for _ in range(2)]
if s[:-1] == t:
	print('Yes')
else:
	print('No')
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from bisect import bisect_right

n = int(readline())
a = list(map(int, readline().split()))
a.sort()
if a[0] <= 0 and a[-1] >= 0:
    print(sum(map(lambda x: abs(int(x)), a)))
    idx = bisect_right(a, 0)
    x = a[0]
    y = a[idx]
    for aa in a[1:idx]:
        print(y, aa)
        y -= aa
    for aa in a[idx + 1:]:
        print(x, aa)
        x -= aa
    print(y, x)
else:
    if a[0] < 0:
        print(-sum(a) + 2 * a[-1])
        a = a[::-1]
    else:
        print(sum(a) - 2 * a[0])
    x = a[0]
    y = a[-1]
    for aa in a[1:-1]:
        print(x, aa)
        x -= aa
    if a[0] < 0:
        y, x = x, y
    print(y, x)


### FIXED CODE ###

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from bisect import bisect_right

n = int(readline())
a = list(map(int, readline().split()))
a.sort()
if a[0] <= 0 and a[-1] >= 0:
    print(sum(map(lambda x: abs(int(x)), a)))
    idx = bisect_right(a, 0)
    idx -= 1 if idx == n else 0
    x = a[0]
    y = a[idx]
    for aa in a[1:idx]:
        print(y, aa)
        y -= aa
    for aa in a[idx + 1:]:
        print(x, aa)
        x -= aa
    print(y, x)
else:
    if a[0] < 0:
        print(-sum(a) + 2 * a[-1])
        a = a[::-1]
    else:
        print(sum(a) - 2 * a[0])
    x = a[0]
    y = a[-1]
    for aa in a[1:-1]:
        print(x, aa)
        x -= aa
    if a[0] < 0:
        y, x = x, y
    print(y, x)
m,n = map(int, input.split())
if n >= 1<<m:
  print(-1)
  
else:
  ans = [i for i in range((1<<m)-1, -1 -1)]
  ans.remove(n)
  ans.append(n)
  for i in range(1<<m):
    if i == n:
      continue
    else:
      ans.append(i)
  ans.append(n)
print(' '.join (map(str，ans)))

### FIXED CODE ###

m,n = map(int, input().split())
if n >= 1<<m:
  print(-1)
   
else:
  if m == 1:
    if n == 1:
      print(-1)
    else:
      print(0,0,1,1)
  else:
    ans = [i for i in range((1<<m)-1, -1, -1)]
    ans.remove(n)
    ans.append(n)
    for i in range(1<<m):
      if i == n:
        continue
      else:
        ans.append(i)
    ans.append(n)
    print(" ".join(map(str, ans)))
s = input()
t= input()
dp=[[0]*len(s) for i in range(len(t))]
for i in range(len(t)):
    for j in range(len(s)):
        if t[i] == s[j]:
            dp[i][j] = dp[i-1][j-1] + 1
        else:
            dp[i][j] = max(dp[i][j-1], dp[i-1][j])
i, j = len(s),len(t)
ans = ""
while i>0 and j > 0:
    if s[i-1] == t[j-1]:
        ans += s[i-1]
        i -= 1
        j -= 1
    elif dp[j][i] > dp[j-1][i]:
        j -= 1
    else:
        i -= 1
print(ans[::-1])

### FIXED CODE ###

S = input()
T = input()
 
# dp[i][j] := Sのi文字目, Tのj文字目まで見た場合のLCS
dp = [[0] * (len(T) + 1) for i in range(len(S) + 1)]
 
for i in range(1, len(S) + 1):
    for j in range(1, len(T) + 1):
        if S[i - 1] == T[j - 1]:
            dp[i][j] = dp[i - 1][j - 1] + 1
        else:
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
 
ans = ''
i, j = len(S), len(T)
while i > 0 and j > 0:
    if S[i - 1] == T[j - 1]:
        ans += S[i - 1]
        i, j = i - 1, j - 1
    elif dp[i][j - 1] > dp[i - 1][j]:
        j -= 1
    else:
        i -= 1
 
print(ans[::-1])
def invNum(A):
    if len(A)==1: return 0
    cnt = 0
    for i in range(1,len(A)):
        if A[0] > A[i]: cnt += 1
    return cnt + invNum(A[1:])


if __name__=='__main__':
    n = int(input()) 
    print(invNum(list(map(int,input().split()))))

### FIXED CODE ###

cnt = 0
def merge(L,R):
    global cnt
    n = len(L)+len(R)
    lenL = len(L)
    A = []
    i = j = 0
    L.append(-1)
    R.append(-1)
    for _ in range(n):
        if L[i] > R[j]:
            A.append(L[i])
            i += 1
        else:
            A.append(R[j])
            j += 1
            cnt += lenL-i
    return A

def mergeSort(A):
    if len(A)==1: return A
    m = len(A)//2
    return merge(mergeSort(A[:m]),mergeSort(A[m:])) 

if __name__=='__main__':
    n = int(input()) 
    A = list(map(int,input().split()))
    mergeSort(A[::-1])
    print(cnt)
def main():
    from math import gcd
    from functools import reduce
    from operator import mul
    n, *t = map(int, open(0).read().split())
    g = reduce(gcd, t)
    ans = reduce(mul, t) // g
    print(ans)


if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    from fractions import gcd
    from functools import reduce

    def cal(a, b):
        t = a * b // gcd(a, b)
        return t

    n, *t = map(int, open(0).read().split())
    ans = reduce(cal, t)
    print(ans)


if __name__ == '__main__':
    main()
a = int(input()) // 値の数
b = list(map(int, input().split()))
count = 0
while(1):
  for i in range(0, a, 1):
    if (b[i] % 2 == 1) :
      break;
  for i in range(0, a, 1):
    b[i] /= 2
    count += 1
print(count)

### FIXED CODE ###

a = int(input())
b = list(map(int, input().split()))
count = 0
while(1):
  flag = 0
  for i in range(0, a, 1):
    if (b[i] % 2 == 1) :
      flag = 1
  if (flag == 1) :
    break
  for i in range(0, a, 1):
    b[i] /= 2
  count += 1
print(count)
N = int(input())
AB_list = [list(map(int, input().split())) for i in range(N)]

kouho_list = []

for i, AB in enumerate(AB_list):
    for j,ab in enumerate(AB_list[i+1:]):
        kouho_list.append((AB[0]-ab[0] ,AB[1]-ab[1]))

from collections import Counter
kouho_counter = Counter(kouho_list).most_common()
#print(kouho_counter)
result = len(AB_list) - kouho_counter[0][1]

'''
候補は49 + 48 + 47 + ...
この候補の中で、一番えらばれているものをp,qとして設定する
その後、ループを回して、実際にコストを計算する

'''



#print(AB_list)
print(result)

### FIXED CODE ###

N = int(input())
AB_list = [list(map(int, input().split())) for i in range(N)]

if len(AB_list) ==1:
    print(1)
    exit(0)

AB_list = sorted(AB_list,key=lambda a:a[0])
kouho_list = []
for i, AB in enumerate(AB_list):
    for j,ab in enumerate(AB_list):
        if i == j:
            continue
        kouho_list.append((ab[0]-AB[0] ,ab[1]-AB[1]))

from collections import Counter
kouho_counter = Counter(kouho_list).most_common()
pq = list(kouho_counter[0][0])

onaji_list = []
#print(kouho_counter)

result = []
for i,ab in enumerate(AB_list):
    for j,ab2 in enumerate(AB_list):
        if i == j:
            continue
        if ab[0] + pq[0] == ab2[0] and ab[1] + pq[1] == ab2[1]:
            result.append(tuple(ab2))
            continue
        #if ab[0] - pq[0] == ab2[0] and ab[1] - pq[1] == ab2[1]:
            #result.append(tuple(ab2))


#print(result)
result = list(set(result))
#print(onaji_list)
#print(result)
print(len(AB_list)-len(result))





'''
候補は49 + 48 + 47 + ...
この候補の中で、一番えらばれているものをp,qとして設定する
その後、ループを回して、実際にコストを計算する

'''


#print(AB_list)
a, b = map(int, input().split())
    if a == b:
        print("Draw")
    elif a == 1:
        print("Alice")
    elif b == 1:
        print("Bob")
    elif a > b:
        print("Alice")
    else:
        print("Bob")

### FIXED CODE ###

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

if a == b:
    print("Draw")
elif a == 1:
    print("Alice")
elif b == 1:
    print("Bob")
elif a > b:
    print("Alice")
else:
    print("Bob")
n, l = map(int, input().split())
s = []
for _ in range(n):
  s.append(input())
s = sorted(s)
r = ""
for i in s:
  r += i
print(r)

### FIXED CODE ###

A = list(map(int, input().split()))
c_7 = 0
c_5 = 0
for i in A:
  if i == 7:
    c_7 += 1
  if i == 5:
    c_5 += 1
if c_7 == 1 and c_5 == 2:
  print("YES")
else:
  print("NO")
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr
A,B = [int(i) for i in input().split()]
ans = 1
lia = factorization(A)
lib = factorization(B)
na = len(lia)
nb = len(lib)
a = [0] * na
b = [0] * nb
for i in range(na):
    a[i] = lia[i][0]
for i in range(nb):
    b[i] = lib[i][0]
M = max(a[-1],b[-1])
li = [0] * (M+10)
for i in range(na):
    li[a[i]] +=1
for i in range(nb):
    li[b[i]] +=1
for i in range(2,M+1):
    if li[i] == 2:
        ans+=1
print(ans)

### FIXED CODE ###

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr
A,B = [int(i) for i in input().split()]
if A == 1 and B==1:
    print(1)
else:
    ans = 1
    lia = factorization(A)
    lib = factorization(B)
    na = len(lia)
    nb = len(lib)
    a = [0] * na
    b = [0] * nb
    for i in range(na):
        a[i] = lia[i][0]
    for i in range(nb):
        b[i] = lib[i][0]
    a_ = set(a)
    b_ = set(b)
    if na >= nb:
        for i in range(nb):
            if b[i] in a_:
                ans+=1
        print(ans)
        exit()
    else:
        for i in range(na):
            if a[i] in b_:
                ans+=1
        print(ans)
        exit()
from collections import Counter
import heapq

def find_key_from_value(input_dict, target_value):
  return  [key for key, value in input_dict.items() if value == target_value][0]

N = int(input())
V= list(map(int,input().split()))
eve, odd  = Counter([V[i] for i in range(0,N,2)]), Counter([V[i] for i in range(1,N,2)])
if len(eve) == len(odd):
  print(N//2)
  exit()

eve_largests = heapq.nlargest(2,eve.values())
odd_largests = heapq.nlargest(2,odd.values())

if eve_largests[0] != odd_largests[0]:
  eve_largest, odd_largest = eve_largests[0], odd_largests[0]
else:
  if len(eve_largests[0]) == 1 and len(odd_largests[0]) == 2:
    eve_largest, odd_largest = eve_largests[0], odd_largests[1]
  elif len(eve_largests[0]) == 2 and len(odd_largests[0]) == 1:
    eve_largest, odd_largest = eve_largests[1], odd_largests[0]
  else:
    if eve_largests[1] >= odd_largests[1]:
      eve_largest, odd_largest = eve_largests[1], odd_largests[0]
    else:
       eve_largest, odd_largest = eve_largests[0], odd_largests[1]
    
eve_key = find_key_from_value(eve, eve_largest)
odd_key = find_key_from_value(odd, odd_largest)  
  
print(N-eve[eve_key]-odd[odd_key])

### FIXED CODE ###

from collections import Counter
import heapq

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

if len(set(Vs)) == 1:
  print(N//2)
  exit()

Veve, Vodd = [],[]
idx = 0
for v in Vs:
  if idx%2 == 0: Veve.append(v)
  else: Vodd.append(v)
  idx += 1

Veve_cnt, Vodd_cnt = [], []
[heapq.heappush(Veve_cnt, [-num,val]) for val, num in Counter(Veve).items()]
[heapq.heappush(Vodd_cnt, [-num,val]) for val, num in Counter(Vodd).items()]

neg_num, val = heapq.heappop(Veve_cnt)
eve_val = val
eve_num = -neg_num

neg_num, val = heapq.heappop(Vodd_cnt)
odd_val = val
odd_num = -neg_num

if eve_val != odd_val:
  print(N-eve_num-odd_num)
else:
  if len(Vodd_cnt) != 0:odd_num2 = -heapq.heappop(Vodd_cnt)[0]
  else:odd_num2 = -float('inf')

  if len(Veve_cnt) != 0:eve_num2 = -heapq.heappop(Veve_cnt)[0]
  else:eve_num2 = -float('inf')

  print(min(N-eve_num2-odd_num,N-eve_num-odd_num2))
N, M = map(int, input().split())
num = ['0'] * N
si = False
error = False

for i in range(M):
    s, c = input().split()
    if num[int(s)-1] in ['0', c]:
        num[int(s)-1] = c
        if s == '1':
            s1 = True
    else:
        error = True
        break

if not s1:
    num[0] = '1'
if num[0] == '0' or error:
    print(-1)
else:
    print(''.join(num))


### FIXED CODE ###

N, M = map(int, input().split())
num = ['0'] * N
s1 = False
error = False

for i in range(M):
    s, c = input().split()
    if num[int(s)-1] in ['0', c]:
        num[int(s)-1] = c
        if s == '1':
            s1 = True
    else:
        error = True
        break

if N != 1 and not s1:
    num[0] = '1'
if (N != 1 and num[0] == '0') or error:
    print(-1)
else:
    if N != 1 and not s1:
        num[0] = '1'
    print(''.join(num))
n = input()
  max = -(10**9)
  min = input()

  for i in range(0, n-1):
    a = input()
    if max < a - min:
      max = a - min
    if a < min:
      min = a

  print max

### FIXED CODE ###

n = int(raw_input())
minv = int(raw_input())
maxv = -1*10**9
  
for j in range(n-1):
  nums = int(raw_input())  
  diff = nums - minv
  if maxv < diff:
    maxv = diff
  if nums < minv:
    minv = nums
  
print maxv
N = int(input())

a=pow(10,n,10**9+7)
b=pow(9,n,10**9+7)
c=pow(8,n,10**9+7)
print((a-2*b+c)%(10**9+7))

### FIXED CODE ###

n = int(input())

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

M, D = MAP()
ans = 0
for m in range(1, M+1):
	for d in range(1, D+1):
		if len(str(d)) == 2:
			d1 = int(str(d)[1])
			d10 = int(str(d)[0])
			if 2 <= d1 and 2 <= d10 and d1*d10 == m:
				ans += 1
print(ans)

### FIXED CODE ###

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

M, D = MAP()
ans = 0
for m in range(1, M+1):
	for d in range(1, D+1):
		if len(str(d)) == 2:
			d1 = int(str(d)[1])
			d10 = int(str(d)[0])
			if 2 <= d1 and 2 <= d10 and d1*d10 == m:
				ans += 1
print(ans)
k = int(input())
s = input()

s_li = []
for i in s:
    s_li.append(i)

if len(s_li) > k:
    s_str = s_li[:k]
    print(''.join(s_str) + "...")
else:
    print(''.join(s_str))
    

### FIXED CODE ###

#In[]:
k = int(input())
s = input()

if len(s) > k:
    s_str = s[:k]
    print(s_str + "...")
else:
    print(s)