Problem:
 Score : 100 points    Problem Statement You are given an integer K .
Print the string obtained by repeating the string ACL  K times and concatenating them.  For example, if K = 3 , print ACLACLACL .      Constraints  1 \leq K \leq 5  All values in input are integers.         Input Input is given from Standard Input in the following format:  K       Output Print the string obtained by repeating the string ACL  K times and concatenating them.        Sample Input 1 3      Sample Output 1 ACLACLACL

Solution (Python):
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
import math
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii():  return int(input())
def si():  return input()
def mi():  return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li():  return list(mi())
 
def dmain():
    sys.setrecursionlimit(1000000)
    threading.stack_size(1024000)
    thread = threading.Thread(target=main)
    thread.start()
    








 
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007

inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def getKey(item): return item[1] 
def sort2(l):return sorted(l, key=getKey,reverse=True)
def d2(n,m,num):return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo (x): return (x and (not(x & (x - 1))) )
def decimalToBinary(n): return bin(n).replace("0b","")
def ntl(n):return [int(i) for i in str(n)]
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
 
def ceil(x,y):
    if x%y==0:
        return x//y
    else:
        return x//y+1
 
def powerMod(x,y,p):
    res = 1
    x %= p
    while y > 0:
        if y&1:
            res = (res*x)%p
        y = y>>1
        x = (x*x)%p
    return res
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x
    
def isPrime(n) : 
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
    return True
 
 
 
def read():
    sys.stdin  = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
 
def main():

    
    

    
    n = int(input())
    print(n * 'ACL')
    
    




 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

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

ans='ACL'*K

print(ans)

Solution (Python):
import sys     
import math as mt
import bisect
input=sys.stdin.readline

t=1
def ncr_util():
    inv[0]=inv[1]=1
    fact[0]=fact[1]=1
    for i in range(2,300001):
        inv[i]=(inv[i%p]*(p-p//i))%p
    for i in range(1,300001):
        inv[i]=(inv[i-1]*inv[i])%p
        fact[i]=(fact[i-1]*i)%p
def solve():
    s='ACL'
    for i in range(k):
        print(s,end="")
    print()    
for _ in range(t):
    k=int(input())
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    (solve())

Solution (Python):
k = int(input())
ans=""
for i in range(k):
    ans=ans+"ACL"  
print(ans)

Solution (Python):
K = int(input())
print('ACL' * K)

Solution (Python):
import sys
import math


sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

K = ini()

s = "ACL"
ans = ""
for i in range(K):
    ans += s
print(ans)

Solution (Python):
k=int(input())
ans=""
for i in range(k):
    ans+="ACL"
print(ans)

Solution (Python):
k = int(input())
s = 'ACL'
r = ''
for i in range(k):
	r += s 
print(r)

Solution (Python):
K=int(input())
print("ACL"*K)

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

for i in range(k):
    print('ACL', end='')
print('')

Solution (Python):
K = int(input())
print('ACL' * K)

Solution (Python):
a = int(input())
print("ACL" * a)

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

print("ACL"*k)

Solution (Python):
K = int(input())
print("ACL"*K)

Solution (Python):
K = int(input())
print("ACL" * K)

Solution (Python):
n = int(input())
s=''
for i in range(n):
    s = s + 'ACL'
print(s)

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

for i in range(s):
  print("ACL", end="")

Solution (Python):
print(int(input()) * 'ACL')

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

s = "ACL"

print(s*n)

Solution (Python):
n = int(input())
s = "ACL"
a = ""
for i in range(n):
    a += s
print(a)

Solution (Python):
K = int(input())
print('ACL' * K)

Solution (Python):
print("ACL"*int(input()))

Solution (Python):
k = int(input())
s = "ACL"
ans=""
for i in range(k):
  ans+=s
print(ans)

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

print("ACL"*n)

Solution (Python):
N=int(input())
ans ="ACL"
for i in range(N-1):
    ans=ans+"ACL"
print(ans)

Solution (Python):
K = int(input())
print("ACL"*K)

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


for i in range(n):
    print("ACL",end="")
print()

Solution (Python):
for i in range(int(input())):
  print("ACL", end="")

Solution (Python):
K= int(input())
for i in range(K):
    print("ACL", end='')

Solution (Python):
def main():
    k = int(input())
    print('ACL' * k)


if __name__ == '__main__':
    main()

Solution (Python):
k = int(input())
for i in range(k):
    print("ACL", end="")

Solution (Python):
print('ACL'*int(input()))

Solution (Python):


K = int(input())

s = ''

for i in range(K):
    s = s + 'ACL'

print(s)

Solution (Python):
N = int(input())
a = ""

for i in range(N):
  a = a + str("ACL")
print(a)

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



ACL = 'ACL'

print(ACL * N)

Solution (Python):
K=int(input())
a=""
while K>0:
    a+="ACL"
    K-=1
print(a)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

def inp():
    return int(input())
def inps():
    return input().rstrip()
def inpl():
    return list(map(int, input().split()))
def inpls():
    return list(map(str, input().split()))
def _debug(obj):
    print(obj, file=sys.stderr)














n = inp()
for i in range(n):
    print("ACL", end="")
print()

Solution (Python):
K=int(input())
Ans=''
for i in range(K):
  Ans+='ACL'
  
print(Ans)

Solution (Python):
K = int(input())
result= ''
if K == 0:
    print(result)
else:
    for i in range(K):
        result += 'ACL'
    print(result)

Solution (Python):
k = input()
print('ACL' * int(k))

Solution (Python):
n=int(input())
ans = ""
for i in range(n):
  ans+="ACL"
  
print(ans)

Solution (Python):

n = int(input())

st = "ACL"

print(st * n)

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

print("ACL" * K)

Solution (Python):
print("ACL"*int(input()))

Solution (Python):
str='ACL'
n=int(input())
print(str*n)

Solution (Python):
K = int(input())
print(K*'ACL')

Solution (Python):
K = int(input())
print("ACL"*K)

Solution (Python):
a = int(input())
print("ACL" * a)

Solution (Python):
n=int(input())
print('ACL'*n)

Solution (Python):
k = int(input())
ans = "ACL"
print(ans * k)

Solution (Python):
n = int(input())
ans = ""
for i in range(n):
  ans = ans + "ACL"
  
print(ans)

Solution (Python):
K=int(input())
for i in range(K):
    print('ACL',end='')

Solution (Python):
k=int(input())
print("ACL"*k)

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

for i in range(K):
    print("ACL",end="")

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

temp = str()
for i in range(K):
	temp+='ACL'
print(temp)

Solution (Python):
def II(): return int(input())
k=II()

ans="ACL"*k
print(ans)

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

n=int(input())
print("ACL"*n)

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

ans=""

for i in range(k):
    ans=ans+"ACL"

print(ans)

Solution (Python):
k=int(input())
for i in range (k):
  print('ACL',end='')

Solution (Python):
K = int(input())
a = "ACL"

print(a*K)

Solution (Python):
def main():
    import sys
    def input():
        return sys.stdin.readline()[:-1]
    K=int(input())
    moji="ACL"
    ans=""
    for i in range(K):
        ans+=moji
    print(ans)
    
   


if __name__ == '__main__':
    main()

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

for i in range(k):
    print("ACL", end="")

Solution (Python):
K = int(input())
ans = 'ACL'*K
print(ans)

Solution (Python):
k=int(input())
s=""
for i in range(k):
    s=s+"ACL"

print(s)

Solution (Python):
import sys
K=int(input())
ans=[]
for i in range(K):
    ans+="ACL"
print(''.join(ans))

Solution (Python):
n=int(input())
print('ACL'*n)

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

for i in range(k):
    print("ACL",end="")

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

print("ACL"*K)

Solution (Python):
k=int(input())
print('ACL'*k)

Solution (Python):
s = "ACL"*int(input())
print(s)

Solution (Python):
n = int(input())
print("ACL"*n)

Solution (Python):
N=int(input())
for i in range(N):
  print('ACL',end='')

Solution (Python):
input = int(input())
ans = "ACL"
print(ans*input)

Solution (Python):
N = int(input())
for i in range(N):
    print('ACL',end="")

Solution (Python):
s = int(input())
print("ACL"*s)

Solution (Python):

K = int(input())
A = ''
for i in range(K):
  A += 'ACL'
print(A)

Solution (Python):
s=int(input())
for i in range(s):
  print("ACL", end="")
print()

Solution (Python):
def main():
    import sys
    sys.setrecursionlimit(311111)
    
    ikimasu = sys.stdin.buffer.readline
    ini = lambda: int(ins())
    ina = lambda: list(map(int, ikimasu().split()))
    ins = lambda: ikimasu().strip()
    tmp = ini()
    print(("ACL"*tmp))

    
    



    


        
        
        


    
        


        


    




















if __name__ == "__main__":
    main()

Solution (Python):
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
N = 300005
 

factorialNumInverse = [None] * (N + 1) 
 

naturalNumInverse = factorialNumInverse.copy() 
 


fact = factorialNumInverse.copy() 
 

def InverseofNumber(p): 
    naturalNumInverse[0] = naturalNumInverse[1] = 1
    for i in range(2, N + 1, 1): 
        naturalNumInverse[i] = (naturalNumInverse[p % i] * 
                                (p - int(p / i)) % p) 


def InverseofFactorial(p): 
    factorialNumInverse[0] = factorialNumInverse[1] = 1
  
    
    for i in range(2, N + 1, 1): 
        factorialNumInverse[i] = (naturalNumInverse[i] * 
                                  factorialNumInverse[i - 1]) % p 
  

def factorial(p): 
    fact[0] = 1
  
    
    for i in range(1, N + 1): 
        fact[i] = (fact[i - 1] * i) % p 
  

def Binomial(N, R, p): 
    
      
    
    ans = ((fact[N] * factorialNumInverse[R])% p * 
                      factorialNumInverse[N - R])% p 
    return ans 


def main():
    starttime=datetime.datetime.now()
    if(os.path.exists('input.txt')):
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")
    
    
    for _ in range(1):
        n=ri()
        print("ACL"*n)
        
        
        
        
        
                    
        
    
    endtime=datetime.datetime.now()
    time=(endtime-starttime).total_seconds()*1000
    if(os.path.exists('input.txt')):
        print("Time:",time,"ms")  
    
                
class FastReader(io.IOBase):
    newlines = 0

    def __init__(self, fd, chunk_size=1024 * 8):
        self._fd = fd
        self._chunk_size = chunk_size
        self.buffer = io.BytesIO()

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self, size=-1):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()


class FastWriter(io.IOBase):

    def __init__(self, fd):
        self._fd = fd
        self.buffer = io.BytesIO()
        self.write = self.buffer.write

    def flush(self):
        os.write(self._fd, self.buffer.getvalue())
        self.buffer.truncate(0), self.buffer.seek(0)


class FastStdin(io.IOBase):
    def __init__(self, fd=0):
        self.buffer = FastReader(fd)
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


class FastStdout(io.IOBase):
    def __init__(self, fd=1):
        self.buffer = FastWriter(fd)
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.flush = self.buffer.flush


if __name__ == '__main__':
    sys.stdin = FastStdin()
    sys.stdout = FastStdout()
    main()

Solution (Python):
print("ACL" * int(input()));

Solution (Python):
K = int(input())
print('ACL' * K)

Solution (Python):
k = int(input())
ans = ""
for i in range(k):
    ans+="ACL"
print(ans)

Solution (Python):
n = int(input())
string = "ACL"

print(string * n)

Solution (Python):
k=int(input())
print("ACL"*k)

Solution (Python):
def main():
    K = int(input())
    print('ACL'*K)
    return
    
if __name__ == '__main__':
    main()

Solution (Python):
print(int(input())*'ACL')

Solution (Python):
k=int(input())
print("ACL"*k)

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

for i in range(num):
    print("ACL",end="")

Solution (Python):
K = int(input())
print('ACL' * K)

Solution (Python):
print("ACL" * int(input()))

Solution (Python):
k=int(input())
print(k*'ACL')

Solution (Python):
k = int(input()); a = ""
for i in range(k):
    a += "ACL"
print(a)

Solution (Python):
K = int(input())
a = ''
for i in range(K) :
    a += 'ACL'
print(a)

Solution (Python):
K=int(input())
print("ACL"*K)

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

print("ACL"*k)

Solution (Python):
k = int(input())
print('ACL'*k)

Solution (Python):
K = int(input())
print("ACL"*K)

Solution (Python):
a = input()
print('ACL'*int(a))

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


ans = ""
for x in range(k):
    ans += "ACL"
    
    
print(ans)

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
INF = float('inf')
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
K = int(input())

s = 'ACL' * K
print(s)

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

print("ACL" * K)

Solution (Python):
def main():
    K = int(input())
    print('ACL' * K)

if __name__ == '__main__':
    main()

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

ans = ''
for i in range(K):
  ans += 'ACL'
print(ans)

Solution (Python):
n = int(input())
strr = ""
for num in range(n):
  strr += "ACL"
  
print(strr)

Solution (Python):
n = int(input())
ans = ''
for i in range(n):
  ans += 'ACL'
print(ans)

Solution (Python):
k = int(input())
for i in range(k):
  print("ACL", end="")

Solution (Python):
def readInt():
    return int(input())
def readList():
    return list(map(int,input().split()))
def readMap():
	return map(int,input().split())
def readStr():
    return input()
inf=float('inf')
mod = 10**9+7
import math
from itertools import permutations
def solve(K):
    return "ACL"*K

K=readInt()
print(solve(K))

Solution (Python):
K=int(input())
print("ACL"*K)

Solution (Python):
k=int(input())
print('ACL'*k)

Solution (Python):
K = int(input())
print('ACL' * K)

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

X = ""
for i in range(N):
    X += "ACL"
print(X)

Solution (Python):
print("ACL" * int(input()))

Solution (Python):
k=int(input())
tmp='ACL'
ans=''
for i in range(k):
    ans+=tmp
print(ans)

Solution (Python):
k = input()
q = ''
for i in range(int(k)):
    q += 'ACL'
print(q)

Solution (Python):
print("ACL" * (int(input())))

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

ans = "ACL" * K

print(ans)

Solution (Python):
K = int(input(""))
print("ACL"*K)

Solution (Python):
K = int(input())
c = 'ACL'
s = c * K
print(s)

Solution (Python):
k = int(input())
s = "ACL"
ans = ""
for i in range(k):
    ans += s
print(ans)

Solution (Python):
k=int(input())
string = 'ACL'

print(string*k)

Solution (Python):
N = int(input())
print("ACL" * N)

Solution (Python):

K = int(input())

print("ACL" * K)

Solution (Python):
N= int(input())
a = ''
b = 'ACL'
for i in range(N):
  a+=b
  
print(a)

Solution (Python):
K=int(input())
ans=[]
for i in range(K):
    ans.extend("ACL")
print("".join(ans))

Solution (Python):
print('ACL'*(int(input())))

Solution (Python):
n=int(input())
print("ACL"*n)

Solution (Python):
n=int(input())
s = ""
for i in range(n):
  s += "ACL"
print(s)

Solution (Python):
n=int(input())
for i in range(n):
    print("ACL",end='')

Solution (Python):
k = int(input())
for i in range(k):
    print('ACL', end="")

Solution (Python):
K=int(input())
L=''
for i in range(K):
    L+='ACL'
print(L)

Solution (Python):
print('ACL'*int(input()))

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

ans = "ACL"*k
print(ans)

Solution (Python):
k = int(input())
a = "ACL"
print(a * k)

Solution (Python):
import sys
from sys import stdin
def I():
    return stdin.readline().rstrip()
def MI():
    return map(int,stdin.readline().rstrip().split())
def LI():
    return list(map(int,stdin.readline().rstrip().split()))

k=int(I())
s='ACL'
ans=''
for i in range(k):
    ans=ans+s
print(ans)

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

A = str()

for _ in range(K):
    A += 'ACL'

print(A)

Solution (Python):
A="ACL"
K=int(input())
print(A*K)

Solution (Python):
def run(s):
    '''

    '''
    print('ACL'*s)

if __name__ == '__main__':
    s = int(input())

    run(s)

Solution (Python):
K = int(input())
print("ACL"*K)

Solution (Python):


"""
Created on Sat Sep 26 17:29:23 2020

@author: divyarth
"""

import sys
import heapq
import math





from collections import deque
from collections import defaultdict
from collections import Counter

modH=int(10**9)+7
I=lambda : list(map(int,input().split(' ')))
def PRINT(lst,sep=' '): print(sep.join(map(str,lst)))


n=int(input())    
print('ACL'*n)

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


def main():
    ans = "ACL" * K
    print(ans)


if __name__ == "__main__":
    main()

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

str = ""

for cnt in range(k):
    str += "ACL"

print(str)

Solution (Python):
K = int(input())
ans = ""
for _ in range(K):
  ans += "ACL"
print(ans)

Solution (Python):
k = int(input())
ans = ''
for i in range(k):
  ans += 'ACL'
print(ans)

Solution (Python):
K = int(input())
print('ACL' * K)

Solution (Python):
K = int(input())
w = ""
for i in range(K):
  w += "ACL"
print(w)

Solution (Python):
k = int(input())
for i in range(k):
    print("ACL",end = "")

Solution (Python):




n = int(input())
ans = ''


for i in range(n):
    ans = ans + 'ACL'


print(ans)

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

print(s*n)

Solution (Python):
str = "ACL"
result = ""
K = int(input())
for i in range(K):
  result += str
print(result)

Solution (Python):
k = int(input())
k2 = "ACL"*k
print(k2)

Solution (Python):
n=int(input())
print("ACL"*n)

Solution (Python):
def main():
    moji = "ACL"
    ans = ""
    K = int(input())
    for i in range(K) :
        ans = ans + moji

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush

sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplt(n): return [tuple(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

k = inp()
ans = 'ACL' * k
print(ans)

Solution (Python):

N = int(input())
ans =list("ACL")
print("".join(ans*N))

Solution (Python):
a = int(input())
for data in range(a):
    print("ACL", end="")

Solution (Python):

    
    


import sys, os.path


    
    

sys.setrecursionlimit(10 ** 5)

def mod(): return 10**9+7
def ii(): return int(sys.stdin.readline())
def si(): return sys.stdin.readline().strip()
def li(): return list(sys.stdin.readline().strip())
def mii(): return map(int, sys.stdin.readline().split())
def lii(): return list(map(int, sys.stdin.readline().strip().split()))



def solve():
    a = ii()
    print(a*"ACL")

for _ in range(1):
    solve()

Solution (Python):

k = int(input())
print('ACL'*k)

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

print("ACL"*k)

Solution (Python):
K = int(input())
a = ''
for i in range(K):
  a = a + 'ACL'
print(a)

Solution (Python):
def main():
    k = int(input())
    ans = ""
    for _ in range(k):
        ans += "ACL"
    return ans


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

Solution (Python):

k = int(input())
print('ACL' * k)

Solution (Python):
def solve(k):
    return "ACL" * k


def main():
    k = int(input())
    res = solve(k)
    print(res)


def test():
    assert solve(3) == "ACLACLACL"


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

Solution (Python):
k = int(input())
print('ACL' * k)

Solution (Python):


import sys

input = iter(sys.stdin.read().splitlines()).__next__

N = int(input())
print('ACL' * N)

Solution (Python):
K = int(input())
s = ''
for i in range(K):
    s = s + 'ACL'
print(s)

Solution (Python):
k = int(input())
for i in range(k):
    print("ACL", end="")
print()

Solution (Python):
k = int(input())
print('ACL' * k)

Solution (Python):
print('ACL'*int(input()))

Solution (Python):
print("ACL" * int(input()))

Solution (Python):
k = int(input())
for i in range(k):
    print('ACL',end="")

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

print('ACL' * int(input()))

Solution (Python):
k = int(input())
ans = ""

for i in range(k):
    ans += "ACL"

print(ans)

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

print("ACL" * k)

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

print('ACL'*k)

Solution (Python):
k = int(input())
word = ''

for i in range(k):
    word += 'ACL'
    
print(word)

Solution (Python):
k=int(input())
print("ACL"*k)

Solution (Python):
k = int(input())
ans = "ACL"*k
print(ans)

Solution (Python):
k = int(input())
print("ACL" * k)

Solution (Python):
K = int(input())
ans = ""
for i in range(K):
  ans += "ACL"
print(ans)

Solution (Python):
n=int(input())
print('ACL'*n)

Solution (Python):
a = 'ACL'
k = int(input())
print(a * k)

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

print('ACL'*N)

Solution (Python):
n = int(input())
print('ACL'*n)

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

ans=""
for i in range(k):
    ans+="ACL"

print(ans)

Solution (Python):
s = "ACL"
K = int(input())

ans = ""
for i in range(K):
    ans += s

print(ans)

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

for i in range(K):
  print("ACL", end = "")

Solution (Python):
k=int(input())
print('ACL'*k)

Solution (Python):
K = int(input())
for _ in range(K):
    print("ACL", end="")
print()

Solution (Python):
k=int(input())
result = ''
for i in range(k):
  result += 'ACL'
print(result)

Solution (Python):
k = int(input())
print("ACL" * k)

Solution (Python):
i = int(input())
print("ACL" * i)

Solution (Python):
k = int(input())
print('ACL'*k)

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

ans = ''
for i in range(k):
    ans += 'ACL'

print(ans)

Solution (Python):
s = int(input())
ss = 'ACL'*s
print(ss)

Solution (Python):
n = int(input())
a = ""
for i in range(n):
    a = "ACL" * n
print(a)

Solution (Python):
import sys

K = int(sys.stdin.readline())
print("ACL" * K)

Solution (Python):
print("ACL" * int(input()))

Solution (Python):
aaa="ACL"
x=int(input())
print(aaa*x)

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

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


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

def main():
    k = int(input())
    print("ACL" * k)

main()

Solution (Python):



import sys


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


def main():
    n = int(std_in())
    print("ACL" * n)


if __name__ == "__main__":
    main()

Solution (Python):
S = int(input())
print('ACL'*S)

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

acl = "ACL"
ans = ""

for i in range(K):
    ans += acl
print(ans)

Solution (Python):
k = int(input())
a = ""
for _ in range(k):
  a += 'ACL'
print(a)

Solution (Python):
k=int(input())
print("ACL"*k)

Solution (Python):
from collections import Counter
import string
import math
import sys
def array_int():
    return [int(i) for i in sys.stdin.readline().split()]
def vary(number_of_variables):
    if number_of_variables==1:
        return int(sys.stdin.readline())
    if number_of_variables>=2:
        return map(int,sys.stdin.readline().split()) 
def makedict(var):
    return dict(Counter(var))
mod=100000007
import math
fact=[1]
MAX=100001
mod=998244353
for i in range(1,MAX):
	fact.append((fact[-1]*i)%mod)
def ncr(n , k): 
    global mod,fact
    num=fact[n]
    den=((fact[n-k])*(fact[k]))%mod
    return (num*pow(den,mod-2,mod))%mod
k=vary(1)
print('ACL'*k)

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

print('ACL'*k)

Solution (Python):
x = input()

print('ACL' * int(x))

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

ans = ''
for i in range(K):
    ans += 'ACL'

print(ans)

Solution (Python):
ans=[]
K=int(input())
for i in range(K):
    ans.append("ACL")
print(*ans,sep="")

Solution (Python):
K = int(input())
print('ACL'*K)

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


s = ""

for i in range(K):
    s += "ACL"

print(s)

Solution (Python):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    
    
    n=int(readline())
    ans=""
    for _ in range(n):
        ans+="ACL"
    print(ans)
    
    

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

Solution (Python):
import math



N = int(input())

s = ""
for i in range(N):
    s+="ACL"
print(s)

Solution (Python):
k=int(input())
ans=""
for i in range(k):
    ans=ans+"ACL"
print(ans)

Solution (Python):
K=int(input())
ans='ACL'*K
print(ans)

Solution (Python):
s = "ACL"
k = int(input())
ans = ""
for _ in range(k):
    ans += s
print(ans)

Solution (Python):
k = int(input())
for i in range(k):
  print('ACL', end='')

Solution (Python):
import sys
import bisect
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
  return int(readline())
def reads():
  return map(int, readline().split())

K=read()

a="ACL"
print(a*K)

Solution (Python):
for i in range(int(input())):
    print("ACL", end="")
print()

Solution (Python):
k = int(input())
for i in range(k):
    print('ACL', end='')
print('')

Solution (Python):
K = int(input())
s = ''
for i in range(K):
    s += 'ACL'
print(s)

Solution (Python):
print('ACL'*int(input()))