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):
import sys
import math
import bisect

def main():
    n = int(input())
    s = ['ACL'] * n
    print(''.join(s))

if __name__ == "__main__":
    main()

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

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

ans = "ACL" * K

print(ans)

Solution (Python):



import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    K = i2n()
    print('ACL' * K)
    return

main()

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

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

print('ACL'*k)

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

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

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

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

print("ACL" * s)

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

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

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

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

print("ACL"*k)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

A = str()
for i in range(x):
  A = A + 'ACL' 
  i += 1
 
print(A)

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

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

print(o)

Solution (Python):
moji = 'ACL'

K = int(input())
for i in range(K):
  if i==0:
    out = moji
  else:
    out = out + moji
print(out)

Solution (Python):

def resolve():
    import sys

    input = sys.stdin.readline

    n = int(input().rstrip())
    print("".join("ACL" for _ in range(n)))
    



if __name__ == "__main__":
    resolve()

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

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

acl = 'ACL'
op = ''
for k in range(K):
  op += acl

print(op)

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):








def solve(K):
    print('ACL' * K)


if __name__ == '__main__':
    
    K = int(input())
    
    
    
    
    solve(K)

Solution (Python):
N = int(input())
ACL_str = []
for i in range(N):
    ACL_str.append('ACL')
mojiretu = ''.join(ACL_str)
print(mojiretu)

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

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

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

print(s)

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

print("ACL" * n)

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

print('ACL' * k)

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

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

ans = 'ACL'

for i in range(0,K-1):
  ans = ans + 'ACL'

print(ans)

Solution (Python):
ans = ""

k = int(input())

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

print(ans)

Solution (Python):
import sys
import os



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


def str_array():
    return input().strip().split()

def gcd(a,b):
    if b == 0:
        return a
    return gcd(b, a % b);x

def take_input():
	if os.environ.get("check"):
		sys.stdin = open('input.txt', 'r') 
		sys.stdout = open('output.txt', 'w')
		
take_input()


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

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, combinations, chain, product
from functools import lru_cache
from collections import deque, defaultdict
from operator import itemgetter
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()
    print('ACL'*K)











main()

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

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

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

i = 0
ans = ""

for i in range(k):

    ans += "ACL"
    

    i += 1

print(ans)

Solution (Python):



import collections
import sys
import copy
import re
import math


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():
    K = I()

    ans = ""

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

    


if __name__ == '__main__':
    main()

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

Solution (Python):

import sys


def solve(K: int):
    print(''.join(['ACL'] * 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))  
    solve(K)

if __name__ == '__main__':
    main()

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

n = ''

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

print(n)

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

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

output = 'ACL' * K
print(output)

Solution (Python):

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

print(s)

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

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

for num in range(k):
    s += "ACL"

print(s)

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

print('ACL'*num)

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

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

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

print("ACL"*n)

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

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

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):
N = int(input())
for i in range(N):
    print("ACL",end="")

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

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

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

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

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

l = []
for i in range(k):
    l.append('ACL')

print(''.join(l))

Solution (Python):
k = int(input())
i = 1
ans = "ACL"
while i < k:
    ans += "ACL"
    i += 1

print(ans)

Solution (Python):
s = int(input())
for i in range(s):
  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())
string = "ACL"
print(string * K)

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

if k == 1:
    print("ACL")
if k == 2:
    print("ACLACL")
if k == 3:
    print("ACLACLACL")
if k == 4:
    print("ACLACLACLACL")
if k == 5:
    print("ACLACLACLACLACL")

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

Solution (Python):

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

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

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

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

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

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


if __name__ == "__main__":
    solve()

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

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

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

for i in range(n):
    blank += acl
print(blank)

Solution (Python):
a=int(input())
b=[];m=[]
for c in range(a):
    d="ACL"
    b.append(d)
m=''.join(b)
print(m)

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

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

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

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

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

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

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

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

Solution (Python):
print(*['ACL']*int(input()),sep='')

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

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

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

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

Solution (Python):
import sys

a = int(sys.stdin.readline().strip())

print("ACL" * a)

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())
ans = ""

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

print(ans)

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

Solution (Python):
k=int(input())
s="ACL"
r=k*s
for j in range(len(r)):
  print(r[j],end="")

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

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

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

Solution (Python):

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

Solution (Python):
import sys
s = 'ACL'
n = int(sys.stdin.readline().rstrip("\n"))
print(s*n)

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

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

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

print(string)

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

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

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

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

a = ""

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

print("{}".format(a))

Solution (Python):
if __name__=="__main__":
  k=int(input())
  print('ACL'*k)

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

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

Solution (Python):
S = int(input())
R = "ACL"

  
print(R * S)

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

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

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

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())
string = 'ACL'
for i in range(K - 1):
    string = string + 'ACL'

print(string)

Solution (Python):





def solve(K):
    return "ACL" * K



def main():
    K = int(input())
    a = solve(K)
    print(a)


if __name__ == '__main__':
    main()

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

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

print("ACL"*K)

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

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

if __name__ == "__main__":
    main()

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

Solution (Python):

import sys
input=sys.stdin.readline

def main():
    string=""
    n = int(input())
    for i in range(n):
        string+="ACL"
    print(string)


if __name__=="__main__":
    main()

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

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

Solution (Python):
"""
ACL0926_A
"""

k=int(input())
acl='ACL'

for i in range(0,k-1):
    acl += 'ACL'
    
print(acl)

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

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

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

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

ans = ''.join(l)
print(ans)

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):
k=int(input())
for i in range(0,k) :
    print("ACL",end='')

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

Solution (Python):
k = int(input())
X= "ACL"

print(X*k)

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

result = ''

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

print(result)

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

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

print(X)

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

print(''.join(word))

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

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

Solution (Python):

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


main()

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())
ans = "ACL"*K
print(ans)

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

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from math import gcd
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from pprint import pprint


sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]

mod=10**9+7

print("ACL"*I())

Solution (Python):
k = int(input())
l = list()
for i in range(k):
    l.append("ACL")
print("".join(l))

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):
n = int(input())
for i in range(n):
  print("ACL", end = "")

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

Solution (Python):

"""
Created on Sat Sep 26 21:02:43 2020

@author: liang
"""
K = int(input())
ans = ""

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

print(ans)

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

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

ans = 'ACL'

for _ in range(n-1):
  ans = ans + 'ACL'

print(ans)

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


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


print(b)

Solution (Python):



n = input()
n = int(n)

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

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

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

Solution (Python):
n = int(input())
a = ["ACL"]*n
print(''.join(a))

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

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

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

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

output = ""

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

print(output)

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

S = "ACL"

for i in range(K-1):
  S += "ACL"
  
print(S)

Solution (Python):
a = int(input())
s = ['ACL']
w =[]
for i in range(a):
    w += s
print(''.join(w))

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

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

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


if __name__ == '__main__':
    main()

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

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

for i in range(K - 1):
    S += "ACL"

print(S)

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

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

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

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

Solution (Python):
import sys
n = int(sys.stdin.readline().strip())
for idx in range(n):
    sys.stdout.write('ACL')
sys.stdout.write('\n')

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

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

Solution (Python):
N=int(input())
base = ["ACL"]*N
print("".join(base))

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

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

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(k*'ACL')

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

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

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

Solution (Python):
k=int(input())
l=["ACL"]*k
print("".join(l))

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

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

Solution (Python):
N = input()

s = ''

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

print(s)

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

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

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

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

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

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

print(stringa)

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

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

Solution (Python):
import sys
from math import ceil as C, floor as F, sqrt, gcd as G
from collections import defaultdict as D, Counter as CNT
from functools import reduce as R
import heapq as HQ

class Heap:
  def __init__(self, data, reverse=False):
    self.reverse = -1 if reverse else 1
    self.data = [self.reverse * d for d in data]
    HQ.heapify(self.data)
  def push(self, x): return HQ.heappush(self.data, self.reverse * x)
  def pop(self): return self.reverse * HQ.heappop(self.data) 

ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alp = 'abcdefghijklmnopqrstuvwxyz'
def _X(): return sys.stdin.readline().rstrip().split(' ')
def _S(ss): return tuple(ss) if len(ss) > 1 else ss[0]
def S(): return _S(_X())
def Ss(): return list(S())
def _I(ss): return tuple([int(s) for s in ss]) if isinstance(ss, tuple) else int(ss)
def I(): return _I(S())
def _Is(ss): return list(ss) if isinstance(ss, tuple) else [ss]
def Is(): return _Is(I())

n = I()
print('ACL' * n)

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    K = int(input())
    print("ACL" * K)


main()

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

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

print(answer)

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

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

Solution (Python):

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

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

b='ACL'
print(b*a)

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







t = "ACL" * K

print(t)

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

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

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

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

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


a = int(input())
ss = ''


s = 'ACL'

for i in range(a):
    ss += s

print("{}".format(ss))

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

print('ACL'*K)

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

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

print(ans)

Solution (Python):





import sys,os
from io import BytesIO, IOBase
import collections,itertools,bisect,heapq,math,string
from decimal import *


BUFSIZE = 8192

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




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

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

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

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

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

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

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

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

print(ans)

Solution (Python):
N=int(input())
A='ACL'

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

print(A)

Solution (Python):
t=int(input())
str1="ACL"
str2=""
for i in range(0,t):
  str2=str2[0:]+str1[0:]
print(str2)

Solution (Python):

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

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

if __name__ == "__main__":
  resolve()

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

str = "ACL"
ans = ""

for i in range(K):
    ans += str

print(ans)

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