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

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    k = int(input())
    res = ""
    for _ in range(k):
        res += "ACL"
    print(res)

if __name__ == '__main__':
    resolve()

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

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



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

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

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

Solution (Python):

import sys, re
from decimal import *
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, floor, trunc, log
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

n = INT()
print("ACL"*n)

Solution (Python):

import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter


import sys


readline = sys.stdin.readline

INF = 1 << 60


def read_int():
    return int(readline())


def read_int_n():
    return list(map(int, readline().split()))


def read_float():
    return float(readline())


def read_float_n():
    return list(map(float, readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def ep(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.perf_counter()
        ret = f(*args, **kwargs)
        e = time.perf_counter()

        ep(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(K):
    return "ACL" * K


def main():
    k = read_int()
    print(slv(k))


if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

k = ni()

print('ACL'*k)

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


print('ACL' * K)

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys, math
from itertools import accumulate
sys.setrecursionlimit(10**9)

def input():
    return sys.stdin.readline()[:-1]

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

def ii():
    return int(input())

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]


def main():
    K = ii()
    print('ACL'*K)

if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
def main():

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



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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    K = int(readline())
    ans = 'ACL'*K
    print(ans)


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

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

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

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

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

Solution (Python):

import sys,io,os,time
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"

input = sys.stdin.readline


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









'''


import collections,sys,threading
sys.setrecursionlimit(10**9)
threading.stack_size(10**8)



threading.Thread(target=solve).start()
'''

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

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

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

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

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):
a = 'ACL'
k = int(input())
print(a * k)

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
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 ** 6)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

K = k()

print("ACL"*K)

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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
print("ACL" * N)

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

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

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

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

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

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

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

Solution (Python):


from itertools import *
def Yes(f): print('Yes' if f else 'No')
def YES(f): print('YES' if f else 'NO')
def ispow(x): return int(x ** 0.5) ** 2 == x


res = 0
M = 10 ** 9 + 7




n = int(input())



print('ACL' * n)

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

Solution (Python):
from collections import defaultdict
from collections import deque
from collections import Counter
import math
import itertools

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

s = "ACL"
k = readInt()

print(s*k)

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

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

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

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

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for _ in range(n)]
def LIR(n):
    return [LI() for _ in range(n)]
def SR(n):
    return [S() for _ in range(n)]
def LSR(n):
    return [LS() for _ in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    k = I()
    print("ACL"*k)
    return


if __name__ == "__main__":
    solve()

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

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

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

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

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

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

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

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

Solution (Python):



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

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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