Problem:
 Score: 200 points    Problem Statement  We have a string S consisting of lowercase English letters.  If the length of S is at most K , print S without change.  If the length of S exceeds K , extract the first K characters in S , append ... to the end of them, and print the result.      Constraints   K is an integer between 1 and 100 (inclusive).  S is a string consisting of lowercase English letters.  The length of S is between 1 and 100 (inclusive).         Input  Input is given from Standard Input in the following format:  K  S       Output  Print a string as stated in Problem Statement.        Sample Input 1 7
nikoandsolstice      Sample Output 1 nikoand...  nikoandsolstice has a length of 15 , which exceeds K=7 .  We should extract the first 7 characters in this string, append ... to the end of them, and print the result nikoand... .       Sample Input 2 40
ferelibenterhominesidquodvoluntcredunt      Sample Output 2 ferelibenterhominesidquodvoluntcredunt  The famous quote from Gaius Julius Caesar.

Solution (Python):
def main():
    k = int(input())
    s = str(input())
    if len(s) <= k:
        print(s)
    else:
        print(s[:k] + '...')


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


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

k = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()

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

Solution (Python):
k = int(input())
s = input()
if k >= len(s):
  print(s)
else:
  print(s[:k] + "...")

Solution (Python):
k = int(input())
s = input()
l = len(s)
if l <= k:
    print(s)
else:
    print(s[0:k]+'...')

Solution (Python):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def str_inp():
    '''
    文字列をリストとして読み込む
    '''
    return list(input()[:-1])


k = inp()
s = str_inp()
if len(s) <= k:
    print("".join(s))
else:
    print("".join(s[:k]) + "...")

Solution (Python):
k=int(input())
s=input()
if len(s)<=k:
    print(s)
else:
    print(s[:k]+'...')

Solution (Python):
K = int(input())
S = input()
if(len(S) <= K):
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
K = int(input())
S = input()

if K >= len(S):
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
K = int(input())
S = input()

if(K <len(S)):
    print(S[0:K]+"...")
else:
    print(S)

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    print(s[:k]+'...')

Solution (Python):


def output_S(S, K):
    if len(S)<=K: return S
    else: return S[0:K] + "..."

def main():
    K = int(input())
    S = input()
    print(output_S(S, K))

if __name__ == "__main__":
    main()

Solution (Python):

def main():
  k = int(input())
  s = input()

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

main()

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K]+'...')

Solution (Python):
k=int(input())
s=input()
if len(s) <= k:
  print(s)
else:
  print(f"{s[:k]}...")

Solution (Python):
k=int(input())
s=input()
if len(s)<=k:
  print(s)
else:
  print(s[:k]+"...")

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):
k = int(input())
s = input()

if len(s)<=k:
    print(s)
else:
    print(s[:k]+'...')

Solution (Python):
K = int(input())
S = input()

print(S[0:K] + '...' if K < len(S) else S)

Solution (Python):
k=int(input())
s=input()
if len(s)<=k:
  print(s)
else:
  print(s[0:k]+'...')

Solution (Python):
k=int(input())
s=input()
print(s if len(s)<=k else s[:k]+'...')

Solution (Python):
from sys import stdin
K = int(stdin.readline().rstrip())
S = (stdin.readline().rstrip())
if len(S) <= K:
    print(S)
else:
    print(S[:K]+"...")

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):
def main():
    K=int(input())
    S=input()
    if len(S) <= K:
        print(S)
    else:
        print(S[:K]+'...')

main()

Solution (Python):


K = int(input())
S = str(input())

if len(S) <= K:
    print(S)
else:
    print(S[0:K]+'...')

Solution (Python):
def solve():
    K = int(input())
    S = input()

    if len(S) <= K:
        print(S)
    else:
        print(S[:K] + '...')
if __name__ == '__main__':
    solve()

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
  print(s)
else:
  print(s[:k]+'...')

Solution (Python):
import sys
import math

k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
  print(S)
else:
  print(S[:K] + "...")

Solution (Python):
K = int(input())
S = input()
if len(S)>K:
  print(S[0:K]+"...")
else:
  print(S)

Solution (Python):
K = int(input())
S = str(input())
if len(S) <= K:
    print(S)
else:
    print(S[:K]+'...')

Solution (Python):
k = int(input())
s = input()

a = ""
if len(s) <= k:
    a = s
else:
    a = s[:k] + "..."

print(a)

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K],end='')
    print("...")

Solution (Python):
k = int(input())
s = input()

ans = None
if len(s) <= k:
    ans = s
else:
    ans = s[:k] + '...'

print(ans)

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):






K = int(input())
S = input()

if K >= len(S):
    print(S)
else:
    ans = S[:K] + "..."
    print(ans)

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    k = int(input())
    s = input().strip()
    if len(s) > k:
        print(s[:k] + '...')
    else:
        print(s)


if __name__ == '__main__':
    main()

Solution (Python):
k=int(input())
s=input()
if len(s)<=k:
    print(s)
else:
    ans=""
    for i in range(k):
        ans+=s[i]
    ans+="..."
    print(ans)

Solution (Python):
k = (int)(input())
s=input()
if len(s)>k:
    print(s[:k]+'...')
else:
    print(s)

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + "...")

Solution (Python):
k = int(input())
s = input()

if len(s) <=k:
  print(s)
else:
  print("{}...".format(s[0:k]))

Solution (Python):
import sys
K = int(sys.stdin.readline().rstrip())
S = sys.stdin.readline().rstrip()

N = len(S)

if N > K:
  ans = S[:K] + '...'
else:
  ans = S
  
print(ans)

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
  ans = S
else:
  ans = S[:K] + '...'
print(ans)

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
  print(S)
else:
  print(S[:K]+"...")

Solution (Python):
n = int(input())
s = input()

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

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6) 
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque 


from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush




def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)

def main():
    mod = 10**9+7
    

    K = int(input())
    S=input()
    
    
    
    


    if len(S)<=K:
        print(S)
    else:
        print(S[0:K]+"...")




if __name__ == "__main__":
    main()

Solution (Python):
K = int(input())
S = str(input())
if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






k=ii()
arr=list(ss())

if len(arr)<=k:
    print("".join(arr))
else:
    print("".join(arr[:k])+"...")

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


def solve(K: int, S: str):
    if len(S) <= K:
        print(S)
    else:
        print(S[:K]+"...")
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    K = int(next(tokens))  
    S = next(tokens)  
    solve(K, S)


if __name__ == '__main__':
    main()

Solution (Python):
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


def main():
	K = int(input())
	S = input()
	M = len(S)
	if K >= M:
		print(S)
	else:
		ans = S[:K] + "..."
		print(ans)





if __name__ == '__main__':
	main()

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
if len(S) > K:
    ans = S[0:K]+"..."
    print(ans)

Solution (Python):
def main():
    K = int(input())
    S = input()
    if len(S) <= K:
        print(S)
    else:
        print(S[:K] + '...')


if __name__ == '__main__':
    main()

Solution (Python):
k=int(input())
s=input()

if len(s)<=k:
  print(s)
else:
  print(s[:k]+'...')

Solution (Python):
def main():
    k = int(input())
    s = input()
    if len(s) > k:
        print(s[:k] + "...")
    else:
        print(s)
    return

if __name__ == "__main__":
    main()

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+'...')

Solution (Python):
k=int(input())
s=input()

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

Solution (Python):
k=int(input())
s=input()
print(s if len(s) <= k else s[0:k]+"...")

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
  print(s)
else:
  print(s[:k]+'...')

Solution (Python):
k = int(input())
s = input()
if len(s) > k:
    print(s[:k] + '...')
else:
    print(s)

Solution (Python):
import itertools as iter
import math as m

def main():
    K = int(input())
    S = input()
    if len(S) <= K:
        print(S)
    else:
        print(S[:K] + "...")

if __name__ == '__main__':
    main()

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):
k = int(input())
s = input()
if len(s)<=k:
    print(s)
else:
    ans = s[:k] + '...'
    print(ans)

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    ans = s[:k] + '...'
    print(ans)

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
K=int(input())
S=input()

if len(S) <=K:
  print(S)
  exit()

else:
  print(S[:K] + "...")

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    print(s[:k], end='')
    print('...')

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
K=int(input())
S=input()

if len(S)<=K:
    print(S)
else:
    print(S[:K]+"...")

Solution (Python):
k = int(input())
st = input()
if len(st)<=k:
    print(st)
else:
    x = len(st)-k
    print(st[:k]+"...")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
    exit()
print(S[:K] + '...')

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
k=int(input())
s=str(input())

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

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + "...")

Solution (Python):
k = int(input())
s = input()
if len(s) > k:
    print('{}...'.format(s[:k]))
else:
    print(s)

Solution (Python):
def resolve():
	k = int(input())
	s = input()
	if len(s) > k:
		print(s[:k] + '...')
	else:
		print(s)
resolve()

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):

K = int(input())
S = input()

l = len(S)
if(l <= K):
    print(S)
else:
    print('{}...'.format(S[:K]))

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

k=I()
s=SI()

if len(s)<=k:
    print(s)
else:
    print(s[0:k],end="")
    print("...")

Solution (Python):
k=int(input())
s=input()

if len(s)<=k:
    print(s)
else:
    print(s[0:k:]+"...")

Solution (Python):
k = int(input())
s = str(input())

if len(s) <= k:
    print(s)
else:
    ans = s[:k] + '...'
    print(ans)

Solution (Python):
K = int(input())
S = input()

if K >= len(S):
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
def main():
    k = int(input())
    s = input()
    if len(s) > k:
        return s[:k] + '...'
    else:
        return s


if __name__ == '__main__':
    print(main())

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[0:k]+"...")

Solution (Python):
k = int(input())
s = input()
print(s if len(s)<=k else s[:k]+'...')

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):

k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    moji = s[:k] + '...'
    print(moji)

Solution (Python):
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math



k = int(input())
s = input()

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

Solution (Python):
from collections import Counter 
from collections import defaultdict
from collections import deque
from functools import reduce
import math
import itertools
import heapq
import numpy as np
import sys
sys.setrecursionlimit(10**6)




ceil=lambda x,y: (x+y-1)//y
input_list = lambda : list(map(int,input().split()))


k=int(input())
s=input()
l=len(s)

if l>k:
    s=s[:k]+"..."

print(s)

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + "...")

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print('{0}{1}'.format(S[:K],'...'))

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()

def main():
    k = int(input())
    s = input()
    if len(s) <= k:
        print(s)
    else:
        print(s[:k] + '...')

if __name__ == '__main__':
    main()

Solution (Python):
k = int(input())
s  = input()
l = len(s)
if l<=k:
  print(s)
else:
  a = s[:k]
  print(a+"...")

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + "...")

Solution (Python):
k=int(input())
s=input()
l=len(s)
if l<=k:
  print(s)
else:
  print(s[:k]+'...')

Solution (Python):
import sys

k, s = sys.stdin.read().split()
k = int(k)
def main():
    if len(s) <= k:
        print(s)
    else:
        print(s[:k] + '...')

if __name__ == '__main__':
    main()

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    a = s[:k]
    a += "..."
    print(a)

Solution (Python):
K = int(input())
S = input()

if len(S) <=K:
    print(S)

if len(S) > K:
    print(S[:K] + "...")

Solution (Python):
K = int(input())
S = input()
n = len(S)
if n <= K:
    print(S)
else:
    print(S[:K]+"...")

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K]+"...")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
  print(S)
else:
  print(S[:K] + '...')

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    print(s[: k] + '...')

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[0:k] + "...")

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    print(s[:k]+'...')

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
  print(s)
else:
  print(s[:k] + '...')

Solution (Python):
K = int(input())
S = input()
lens = len(S)
if lens <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
k=int(input())
s=list(input())
if len(s)<=k:
  print(''.join(s))
else:
  s2=s[0:k]
  for i in range(3):
    s2.append('.')
  print(''.join(s2))

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):
k=int(input())
s = input()
if len(s)<=k:
  print(s)
else:
  print(s[:k]+'...')

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)
else:
    s = s[:k] + '...'
    print(s)

Solution (Python):

import sys


def solve(K: int, S: str):
    if len(S) > K:
        print(S[:K]+"...")
    else:
        print(S)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    K = int(next(tokens))  
    S = next(tokens)  
    solve(K, S)

if __name__ == '__main__':
    main()

Solution (Python):
k=int(input())
s=input()
if len(s)<=k:
  print(s)
else:
  print(s[:k]+'...')

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[0:k]+'...')

Solution (Python):

k = int(input())
s = input()
n = len(s)

if n <= k:
    print(s)
else:
    print(s[0:k] + '...')

Solution (Python):
K = int(input())
S = input()

if len(S) > K:
    print(S[:K] + '...')
else:
    print(S)

Solution (Python):
k=int(input())
s=input()
print(s if len(s)<=k else s[:k]+"...")

Solution (Python):
k = int(input())
s = str(input())
if len(s) <= k:
    print(s)
else:
    ans = s[0:k]+'...'
    print(ans)

Solution (Python):
from sys import stdin
input = stdin.readline

K = int(input())
S = input().rstrip()

if len(S) > K:
    print(S[0: K] + "...")
else:
    print(S)

Solution (Python):
k=int(input())
s=input()





if len(s)<=k:
    print(s)
else:
    print(s[:k],"...",sep="")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
def resolve():
    k=int(input())
    s=input()
    if len(s)<=k:
        print(s)
    else:
        print(s[:k]+'...')

if __name__ == '__main__':
    resolve()

Solution (Python):
K=int(input())
S=input()

if len(S)<=K:
  print(S)
else:
  print(S[0:K]+"...")

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(f'{s[:k]}...')

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):
def main():
    K = int(input())
    S = input()

    if len(S) <= K:
        print(S)
    else:
        print(S[:K] + '...')


if __name__ == '__main__':
    main()

Solution (Python):
k = int(input())
s = input()
if(len(s) <= k):
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):
K = int(input())
S = input()
if len(S)<=K:
  print(S)
else:
  print(S[:K]+"...")

Solution (Python):
k=int(input())
s=input()

if len(s) <= k:
    print(s)
else:
    print(s[:k],end="")
    print("...")

Solution (Python):
K = int(input())
S = input()
if(len(S)<=K):
    print(S)
else:
    print(S[:K]+"...")

Solution (Python):
k=int(input())
s=input()

lens=len(s)
if lens<=k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
k = int(input().strip())
s = input().strip()
if len(s) <= k:
    print(s)
else:
    print(s[:k] + '...')

Solution (Python):
k = int(input())
s = input()
if len(s)<=k:
    print(s)
else:
    print(s[:k] + "...")

Solution (Python):
K=int(input())
S=input()
if len(S)<=K:
    print(S)
else:
    print(S[:K],"...",sep="")

Solution (Python):
K = int(input())
S = input()

if len(S) > K:
    print(S[:K] + "...")
else:
    print(S)

Solution (Python):
K = int(input())
S = input()

if len(S) > K:
    print(S[:K] + '...')
else:
    print(S)

Solution (Python):
k = int(input())
s = input()
n = len(s)
if n <= k:
    print(s)
else:
    a = s[0:k]
    print(a,end='')
    print('...')

Solution (Python):
K=int(input())
S=input()

if K<len(S):
    print(S[:K]+"...")
else:
    print(S)

Solution (Python):
K=int(input())
S=input()
if len(S)<=K:
  print(S)
else:
  print(S[:K]+'...')

Solution (Python):
k = int(input())
s = input()
n = len(s)

if n <= k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
K = int(input())
S = input()

res = S[:K]
if K < len(S):
    res += "..."
print(res)

Solution (Python):
from sys import stdin
import sys

K=int(input())
S=input()
if len(S)<=K:
    print(S)
else:
    print(S[:K]+'...')

Solution (Python):
k=int(input())
s=input()

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

Solution (Python):
k = int(input())
s = input()

if len(s) <= k:
    print(s)

else:
    print(s[:k]+'...')

Solution (Python):
def resolve():
    k = int(input())
    s = input()
    if len(s) <= k:
        print(s)
    else:
        print(s[:k] + "...")


if __name__ == '__main__':
    resolve()

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):
k = int(input())
s = input()
if(len(s) <= k):
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
k = int(input())
s=input()
if len(s)<=k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
def main():
    K = int(input())
    S = input()
    len_S = len(S)
    if K >= len_S:
        print(S)
    else:
        print(S[:K] + '...')


if __name__ == "__main__":
    main()

Solution (Python):
















def solve():
    K = int(input())
    S = input()

    if len(S) <= K:
        return S
    else:
        return S[:K] + '...'


def main():
    print(solve())


if __name__ == "__main__":
    main()

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):
import sys


def _s(): return sys.stdin.readline().strip()


def _i(): return int(sys.stdin.readline().strip())


def main():
    k = _i()
    s = _s()
    if len(s) <= k:
        return s
    else:
        return s[:k] + "..."


if __name__ == "__main__":
    print(main())

Solution (Python):

k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K]+'...')

Solution (Python):
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]





K = ii()
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + '...')

Solution (Python):
k=int(input())
s=input()
ls=len(s)
if ls<=k:
    print(s)
else:
    print(s[:k]+"...")

Solution (Python):
k = int(input())
s = input()
if len(s) > k:
    print(s[0:k] + '...')
else:
    print(s)

Solution (Python):
K = int(input())

S = str(input())

s = len(S)

if s <= K:
    print (S)
else:
    print (S[:K], end = '')
    print ('...')

Solution (Python):
from sys import stdin
def main():
    
    readline=stdin.readline
    K=int(readline())
    S=readline().strip()

    if len(S)<=K:
        print(S)
    else:
        print(S[:K]+"...")
if __name__=="__main__":
    main()

Solution (Python):
n=int(input())
s=input()
if len(s) > n:
  print(s[:n] + '...')
else:
  print(s)

Solution (Python):
K = int(input())
S = input()
if len(S)<=K:
  print(S)
else:
  print(S[:K] + '...')

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K]+"...")

Solution (Python):
















mod = 998244353
INF = 1<<29
lINF = 1<<35

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

def main():
    k = int(input())
    s = input()
    t = s[:k]
    if s==t:
        print(t)
    else:
        print(t+"...")
    return

if __name__=='__main__':
    main()

Solution (Python):
k = int(input())
s = input()

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

Solution (Python):

K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    K=ii()
    S=input()
    if len(S)<=K:
        print(S)
    else:
        print(S[:K]+'...')

main()

Solution (Python):
K = int(input())
S = input().strip()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")

Solution (Python):
k = int(input())
s= input()

if k < len(s):
    print(s[:k]+'...')
else:
    print(s)

Solution (Python):
import sys
import math
import itertools

k = int(input())
s = input()
if (len(s) <= k):
    print(s)
else:
    print(s[0:k]+'...')

Solution (Python):
k = int(input())
s = input()
nagasa = len(list(s))
if nagasa <= k:
    print(s)
else:
    ans = s[:k]
    ans += "." * 3
    print(ans)

Solution (Python):
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K]+"...")

Solution (Python):
k=int(input())
s=input()
if len(s)<=k:
    print(s)
else:
    print(s[:k]+'...')

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

k = int(input())
s = input()
if len(s)<=k:
    print(s)
else:
    ans = ""
    for i in range(k):
        ans += s[i]
    ans += "..."
    print(ans)

Solution (Python):
K=int(input())
S=input()
if len(S)<=K:
  print(S)
else:
  print(S[:K]+"...")

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print("{}...".format(S[:K]))

Solution (Python):
k = int(input())
s = input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+'...')

Solution (Python):
K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K]+'...')

Solution (Python):
K = int(input())
S = input()
print(S if len(S) <= K else S[:K]+"."*3)

Solution (Python):
k=int(input())
s=input()
if len(s) <= k:
    print(s)
else:
    print(s[:k]+'...')

Solution (Python):
K = int(input())
S = input()
print(S if len(S)<=K else S[:K]+"...")

Solution (Python):


K = int(input())
S = input()

if len(S) <= K:
    print(S)
else:
    print(S[:K] + "...")