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):
print("ACL"*int(input()))

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

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

ans = "ACL" * k

print(ans)

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

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+="ACL"
print(S)

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

Solution (Python):
def resolve():
    
    
    
    
    k=int(input())
    x='ACL'
    ans=''
    for i in range(k):
        ans+=x
    print(ans)
      
      
if __name__ == '__main__':
    resolve()

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

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

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

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
K = input(str())
a = 'ACL'

if K == '1':
    print(a)

if K == '2':
    print(a * 2)

if K == '3':
    print(a * 3)

if K == '4':
    print(a * 4)

if K == '5':
    print(a * 5)

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

k = I()
print("ACL"*k)

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

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())
s = ""
for _ in range(k):
  s += "ACL"
print(s)

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

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

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

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

print("ACL" * K)

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

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

Solution (Python):

K = int(input())
a = "ACL"*K
print(a)

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

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

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

Solution (Python):
import math
from math import gcd,pi,sqrt
INF = float("inf")
MOD = 10**9 + 7

import sys
sys.setrecursionlimit(10**6)
import itertools
import bisect
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]


def main():
    k = i_input()
    print("ACL"*k)


    

 

if __name__=="__main__":
    main()

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

print("ACL" * k)

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

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

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

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

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

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

Solution (Python):
def A():
    K = int(input())
    print('ACL'*K)
def B():
    A,B,C,D = map(int,input().split())
    left = max(A,C)
    right = min(B,D)
    if(left <= right):
        print('Yes')
    else:
        print('No')
A()

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

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

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

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

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

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())


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

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

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

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

Solution (Python):
import sys
from collections import deque
import bisect
import copy
import heapq
import itertools
import math
import random
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


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


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
import sys
INF = 1 << 60
MOD = 10**9 + 7 
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    print("ACL" * int(input()))
resolve()

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

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

print("ACL" * K)

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

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

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

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

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

print("ACL"*N)

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

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

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

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

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

Solution (Python):
import sys
k = int(sys.stdin.readline().strip())
print('ACL'*k)

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

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

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

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

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

Solution (Python):

K = int(input())

print("ACL"* K)

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

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

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007



def main():
	k = int(input())
	
	
	ret = 'ACL'*k
	return ret
	
	

isTest=False

def pa(*vl):
	if not isTest:
		return
	for v in vl:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

print('ACL' * int(read()))

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

print("ACL" * N)

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

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

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

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

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

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

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

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
import numpy as np

Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1] 
for i in range(2, 10**5 + 1):
    fact.append((fact[-1] * i) % Mod)
    inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
    factinv.append((factinv[-1] * inv[-1]) % Mod)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n - r] % p
    
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res
 
 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)
def pow_k(x, n):
 
    if n == 0:
        return 1
 
    K = 1
    while n > 1:
        if n % 2 != 0:
            K *= x
        x *= x
        n //= 2
 
    return K * x
def main():  
    print("ACL"*int(input()))

if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
def main():
    k = int(input())
    for i in range(k):
        print('ACL', end='')
if __name__ == "__main__":
    main()

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

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

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

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

print(s)

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

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

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

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

if K == 1:
    print("ACL")
elif K == 2:
    print("ACLACL")
elif K == 3:
    print("ACLACLACL")
elif K == 4:
    print("ACLACLACLACL")
else:
    print("ACLACLACLACLACL")

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

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

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

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

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

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

print(s * K)

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

if K == 1:
    print("ACL")
elif K == 2:
    print("ACLACL")
elif K == 3:
    print("ACLACLACL")
elif K == 4:
    print("ACLACLACLACL")
else:
    print("ACLACLACLACLACL")

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

print("ACL" * K)

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

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

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

Solution (Python):

K = int(input())


l = ['A', 'C', 'L']


if 1<= K <= 5:
    K_letters = K*l
    out_letters = ''.join(K_letters)
    print(out_letters)

else:
    print('error')

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

print('ACL' * N)

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

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

Solution (Python):
k=int(input())
if k==1:
  print('ACL')
elif k==2:
  print('ACLACL')
elif k==3:
  print('ACLACLACL')
elif k==4:
  print('ACLACLACLACL')
elif k==5:
  print('ACLACLACLACLACL')

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

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

print("ACL"*K)

Solution (Python):

import sys;input = sys.stdin.readline
inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]

print('ACL'*inp())

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

strings = []
for i in range(K):
    strings += 'ACL'

print(*strings,sep="")

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

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

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

print(s)

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

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

print(str)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

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

print('ACL' * n)

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

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

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

print("ACL" * k)

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

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

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

if(x < 1 or x > 5):
  print("")
else:
  for i in range(x):
    print("ACL",end='')

Solution (Python):
def func(K):
  result = ""
  for i in range(K):
    result += "ACL"
  return result

if __name__ == "__main__":
    K = int(input())
    print(func(K))

Solution (Python):
def read_int(x):
  return int(x)

def repeat(ch,n):
  return ''.join(list(map(lambda _: ch,range(n))))

def main():
  cnt = read_int(input())
  print(repeat("ACL",cnt))
  
main()

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

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

print(k*'ACL')

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

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

a = 'ACL'

for i in range(N-1):
	a+= 'ACL'
print(a)

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

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

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

Solution (Python):
import copy
import math
import time
import statistics
import math
import itertools
import bisect
import sys
from decimal import *
from collections import deque


def get_int():
    return int(input())

def get_string():
    return input()

def get_int_list():
    return [int(x) for x in input().split()]

def get_string_list():
    return input().split()

def get_int_multi():
    return map(int, input().split())

def get_string_char_list():
    return list(str(input()))



sys.setrecursionlimit(10 ** 6)

def main():
    start = time.time()

    n = get_int()
    s = ""
    for _ in range(n):
        s += "ACL"

    print(s)


if __name__ == '__main__':
    main()

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

Solution (Python):
def repeat_acl(K: int) -> str:
    return "ACL" * K


if __name__ == "__main__":
    K = int(input())
    ans = repeat_acl(K)
    print(ans)

Solution (Python):





import math
import fractions
import sys
import bisect
import heapq  
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""


def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

    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



def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod



def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

inf = 10 ** 18
mod = 10 ** 9 + 7

k = ir()
s = 'ACL'
a = [s for i in range(k)]
print(*a, sep='')

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

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

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

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

Solution (Python):
k = int(input())
s = 'ACL'
retVal = ''

for _ in range(k):
    retVal += s

print(retVal)

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

S='ACL'*K
print(S)

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

print("ACL" * K)

Solution (Python):


def solve():
   return 'ACL'*int(input())

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):


def main():
    n = int(input())
    ans = 'ACL'
    ans *= n

    print(ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
k = int(input())
ans =[]
a ='ACL'
for i in range(k):
  ans.append(a)

print(''.join(ans))

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

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

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

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

print(word * n)

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

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

print(b)

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

K = i()
print('ACL'*K)

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

Solution (Python):
import math
import collections
import itertools
import copy

def YesNo(Bool):
    if(Bool):
        print("YES")
    else:
        print("NO")
    return

class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

def resolve():
    K=int(input())

    ans="ACL"*K

    print(ans)
    
resolve()

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

Solution (Python):
_str = ""
_k = int(input())
for _i in range(_k):
  _str += "ACL"
print(_str)

Solution (Python):
k=int(input())
list=[str("ACL")]*k
ans = str()
for i in range(k):
  ans = ans+str(list[i])
print(ans)

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

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():

    word = "ACL"
    k = I()
    print(word*k)

main()

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

print('ACL'*K)

Solution (Python):
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp

INF = inf
MOD = 1000000007

k = int(input())

tmp = 0
res = ""

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

print(res)

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

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

print('')

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

print("ACL" * n)

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

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

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

Solution (Python):
_int = int(input())
_string = ""
for i in range(_int):
  _string += "ACL"


print(_string)

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

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

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

print(ans)

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

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

answer="ACL"*K
print(answer)

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

print("ACL"*K)

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

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

Solution (Python):
def main():
    import sys
    K=int(sys.stdin.readline())
    print('ACL'*K)



main()

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

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

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

Solution (Python):
k = int(input())
str1 = "ACL"
str2 = "ACL"
for i in range(k-1):
  str1 = "".join([str1,str2])
print(str1)

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

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

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

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

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

print("ACL"*K)

Solution (Python):

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

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

if a == 1:
    print("ACL")
elif a == 2:
    print("ACLACL")
elif a == 3:
    print("ACLACLACL")
elif a == 4:
    print("ACLACLACLACL")
else:
    print("ACLACLACLACLACL")

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

Solution (Python):
A = input()
B = "ACL"
C = "ACL"
for i in range(int(A)-1):
  B = B + C 
print(B)

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

print ("ACL" * x)

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

t = "ACL"*k
print(t)

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

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())



for i in range(K):

  print("ACL", end='')

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

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

Solution (Python):







 

 
k = int(input())

'''

'''
'''
n = input()
a = [int(input()) for i in range(n)]
'''
'''
n,m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(m)]
'''
 





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

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

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

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

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

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

Solution (Python):

k = input()

str = ""
for i in range(int(k)):
  str += "ACL"
 
print(str)

Solution (Python):
def main():
    K = int(input())
    result = solve(K)
    print(result)


def solve(K: int) -> str:
    return 'ACL' * K


if __name__ == '__main__':
    main()

Solution (Python):

import os
import sys
from math import *
from collections import *


from bisect import *
from io import BytesIO, IOBase
def vsInput():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]





print('ACL'*Int())

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

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

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

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

output = 'ACL'*n
print(output)

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

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

if __name__ == "__main__":
    main()

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):
ary = 'ACL'
k = int(input())
count=''

for i in range(k):
    count += ary
    
print(count)

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

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

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

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

Solution (Python):

if __name__ == "__main__":
    N = int(input())
    ret = "ACL" * N
    print(ret)