Problem:
 Score : 200 points    Problem Statement  Given is a string S . Replace every character in S with x and print the result.      Constraints   S is a string consisting of lowercase English letters.  The length of S is between 1 and 100 (inclusive).         Input  Input is given from Standard Input in the following format:  S       Output  Replace every character in S with x and print the result.        Sample Input 1 sardine      Sample Output 1 xxxxxxx  Replacing every character in S with x results in xxxxxxx .       Sample Input 2 xxxx      Sample Output 2 xxxx       Sample Input 3 gone      Sample Output 3 xxxx

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

S = input()

N = len(S)
print('x' * N)

Solution (Python):
s = input()
print('x'*len(s))

Solution (Python):
def main():
    s = input()
    print('x'*len(s))



if __name__ == '__main__':
    main()

Solution (Python):
S = input()
ans = 'x' * len(S)
print(ans)

Solution (Python):
S = input()

print('x' * len(S))

Solution (Python):
print("x" * len(input()))

Solution (Python):

"""

s, t = input().split()
a, b = map(int, input().split())
u = input()

if s == u:
    print(max(0, a-1), b)
else:
    print(a, max(0, b-1))

"""
s = input()

print("x" * len(s))

Solution (Python):
S = input()
N = len(S)
print('x' * N)

Solution (Python):
s = str(input())
for _ in range(len(s)):
    print('x',end='')

Solution (Python):

from itertools import product, permutations, combinations
from bisect import bisect_right,bisect_left
INF = float('inf')

S=input()
print(len(S) * "x")

Solution (Python):


def main():
    s = input()
    lens = len(s)
    print('x' * lens)
main()

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

def main():
    print('x' * len(input()))

if __name__ == '__main__':
    main()

Solution (Python):
s = input()
print('x' * len(s))

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

print('x'*len(readline().strip()))

Solution (Python):
s = input()
ans = []
for i in range(len(s)):
    ans.append("x")
print("".join(ans))

Solution (Python):
s=input()
print('x'*len(s))

Solution (Python):
S = input()

for i in range(len(S)):
  print("x", end="")

Solution (Python):
s=input()
ans=''

for i in range(len(s)):
  ans+="x"
  
print(ans)

Solution (Python):
s = len(input())
print('x' * s)

Solution (Python):

S = input()
num = len(S)
print("x"*num)

Solution (Python):
s=input()
print('x'*len(s))

Solution (Python):

S = input()
l = len(S)
print('x' * l)

Solution (Python):
S = input()


length = len(S)


print('x'*length)

Solution (Python):
s=input()
l = len(s)
print(''.join(['x']*l))

Solution (Python):
a = input()
N = len(a)
print("x"*N)

Solution (Python):





def main():
    S = input()

    print("x" * len(S))


if __name__ == '__main__':
    main()

Solution (Python):
a=len(input())
b=""
for i in range(a):
    b+='x'
print(b)

Solution (Python):
print(len(input()) * "x")

Solution (Python):
S=input()
print("x"*len(S))

Solution (Python):
s = input()

print("".join("x"*len(s)))

Solution (Python):
S = input()
for i in range(len(S)):
    print('x', end="")

Solution (Python):


S = input()

L = len(S)

ans = ""

for i in range(L):
  ans += "x"

print(ans)

Solution (Python):
s = input()
l = len(s)
print("x"*l)

Solution (Python):
print("x" * len(list(input())))

Solution (Python):
s = input()


a = 'x' * len(s)
print(a)

Solution (Python):


from collections import defaultdict

con = 10 ** 9 + 7

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


def main():
	S = input()
	N = len(S)
	print("x" * N)


if __name__ == '__main__':
	main()

Solution (Python):
s = len(list(input()))
print("x" * s)

Solution (Python):







import math
import string

def intinput():
    return int(input())

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

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

S = input()
a = len(S)
print('x'*a)

Solution (Python):
s = input()
print("x" * len(s))

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

Solution (Python):
S=input()
print("x"*len(S))

Solution (Python):
print(len(input())*"x")

Solution (Python):
def examA():
    S, T = LSI()
    A, B = LI()
    U = SI()
    if S==U:
        print(A-1,B)
    else:
        print(A,B-1)
    return

def examB():
    S = SI()
    N = len(S)
    ans = ""
    for i in range(N):
        ans += "x"
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    examB()

"""

"""

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
s = input()
x = "x"*len(s)
print(x)

Solution (Python):
import sys

s = sys.stdin.readline().rstrip()

def main():
    return 'x' * len(s)

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

Solution (Python):
s = input()
x = ""
for _ in range(len(s)):
    x +="x"
print(x)

Solution (Python):
s=len(input())
ans="x"*s
print(ans)

Solution (Python):
s = input()
s = "".join(["x" for i in range(len(s))])
print(s)

Solution (Python):
s=input()
n=len(s)
ans='x'*n
print(ans)

Solution (Python):
S = input()

print("".join(["x" for _ in range(len(S))]))

Solution (Python):
s=input()
print("x"*len(s))

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

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
s = str(input())
print('x' * len(s))

Solution (Python):
def main():
    s = input()
    N = len(s)
    print('x' * N)

    

main()

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

print('x'*n)

Solution (Python):
S = input()
a = []
for _ in range(len(S)):
    a.append('x')
print(''.join(a))

Solution (Python):
s=input()
print("x"*(len(s)))

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):

S = list(input())

ans = []
for i in range(len(S)):
    ans.append('x')

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

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
s = input()
print("x" * len(s))

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

for i in range(len(s)):
    s[i] = 'x'

print("".join(s))

Solution (Python):

def main():
    from sys import stdin, setrecursionlimit
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    s = input()
    print('x'*len(s))

if __name__ == '__main__':
    main()

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
S = input()

print("x" * len(S))

Solution (Python):
a = input()
l = len(a)
print("x"*l)

Solution (Python):
S = len(input())
print('x'*S)

Solution (Python):
S = input()

print('x'*len(S))

Solution (Python):
s = input()
print('x' * len(s))

Solution (Python):
s = input()
print('x' * len(s))

Solution (Python):
def main():

    S = input()
    return "x"  * len(S)

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

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
mod=10**9+7

s=input()
n=len(s)
print("x"*n)

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

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

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

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

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

def comb(n, k, modp):
    vn = vk = vn_k = 1
    for i in range(1, n+1):
        vn = vn * i % modp
        if i == k:
            vk = vn
        if i == n-k:
            vn_k = vn
    return vn * get_inv(vk, modp) * get_inv(vn_k, modp) % modp

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



def main():
    S = input()
    print('x'*len(S))



main()

Solution (Python):
s = input()
print("x" * len(s))

Solution (Python):
S = input()
print("x" * len(S))

Solution (Python):
n = len(input())
print(''.join(['x' for _ in range(n)]))

Solution (Python):
s = str(input())
print('x'*len(s))

Solution (Python):
s=input()
print('x'*len(s))

Solution (Python):
s = input()
n = len(s)
print("x"*n)

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math

import itertools



import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default






def main():
    s=input()
    a=""
    for i in range(len(s)):
        a=a+"x"
    print(a)


if __name__ == "__main__":
    main()

Solution (Python):
s = str(input())
print(''.join(['x' for _  in range(len(s))]))

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


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

Solution (Python):
S=input()
ans=[]
for i in range(len(S)):
    ans.append("x")
print(*ans,sep="")

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

Solution (Python):
s = input()
print('x' * len(s))

Solution (Python):
s = input()
print('x' * len(s))

Solution (Python):
S = str(input())
N = len(S)

for _ in range(N):
    print ('x', end = '')
print ()

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
S = raw_input()

ans = ""
for i in range(len(S)):
    ans = ans + "x"

print ans

Solution (Python):
import sys
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

s = S()
N = len(s)
print("x"*N)

Solution (Python):
s = input()
ans = ''
for i in range(len(s)):
    ans += 'x'
print(ans)

Solution (Python):
s = input()
print('x'*len(s))

Solution (Python):
s=input()

print("x"*len(s))

Solution (Python):


from collections import deque, defaultdict
import itertools as ite
import sys
import math
from decimal import *

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

S = raw_input()
print "x" * len(S)

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
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
from operator import mul
from functools import reduce
import pprint
sys.setrecursionlimit(10 ** 9)


INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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 = 1000000007


print(len(S()) * 'x')

Solution (Python):
S = input()
print(len(S)*'x')

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
s=input()
ng=len(s)
ss='x'*ng
print(ss)

Solution (Python):
s = input()
ans = 'x' * len(s)
print(ans)

Solution (Python):
import sys
import math
from collections import defaultdict

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N,num):
    if N<=0:
        return [[] for _ in range(num)]
    elif num==1:
        return [I() for _ in range(N)]
    else:
        read_all = [tuple(II()) for _ in range(N)]
        return map(list, zip(*read_all))



S = str(input())

print('x'*len(S))

Solution (Python):
S = input()

print('x' * len(S))

Solution (Python):

S = input()
print("x"*len(S))

Solution (Python):
S = input().strip()
print("x" * len(S))

Solution (Python):
s = input()
ans = 'x'*len(s)
print(ans)

Solution (Python):
s=input()
print("x"*len(s))

Solution (Python):
S = input()

ans = ""
for i in range(len(S)):
    ans += "x"

print(ans)

Solution (Python):
S = str(input())

print('x'*len(S))

Solution (Python):
def main():
    print( 'x'*len( input()))
if __name__ == '__main__':
    main()

Solution (Python):
s = input()
print('x' * len(s))

Solution (Python):
from sys import stdin
s = str(stdin.readline().rstrip())
l = len(s)
print("x"*l)

Solution (Python):
S = input()
print('x' * len(S))

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

    S = input().rstrip('\n')
    print('x' * len(S))


if __name__ == '__main__':
    main()

Solution (Python):
s=input()
ans=""
for i in range(len(s)):
  ans+="x"
print(ans)

Solution (Python):
s = input()

print('x' * len(s))

Solution (Python):
s = input()
print("x" * len(s))

Solution (Python):
print("x"*len(input()))

Solution (Python):
S = input()
print("x"*len(S))

Solution (Python):
S = input()
ans = 'x' * len(S)
print(ans)

Solution (Python):

N=len(input())
print("x"*N)

Solution (Python):
s = input()
print("x"*(len(s)))

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):


iim = lambda: map(int, input().rstrip().split())

def resolve():
    s = input().rstrip()

    print("x" * len(s))

if __name__ == "__main__":
    resolve()

Solution (Python):
s=input()
print('x'*len(s))

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

s = input().rstrip()

l = len(s)

print("x" * l)

Solution (Python):
s = input()
x="x"
print(x*len(s))

Solution (Python):
s = input()

print("x" * len(s))

Solution (Python):
import sys
input = sys.stdin.readline
print('x' * len(input().strip()))

Solution (Python):
S = input()
print("x"*len(S))

Solution (Python):
S = input()
print("x"*len(S))

Solution (Python):
s = input()
a = ""
for i in range(len(s)):
    a += "x"
print(a)

Solution (Python):
U = input()
ans = ''
for i in U:
    ans += 'x'
print(ans)

Solution (Python):
print('x' * len(input()))

Solution (Python):
print("x"*len(input()))

Solution (Python):
S = input()
print("x"*len(S))

Solution (Python):
print("x"*len(input()))

Solution (Python):
S = input()
print("x"*len(S))

Solution (Python):
s = input()
print("x" * len(s))

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
S = input()
print("x" * len(S))

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

Solution (Python):
def main():
    s = input()
    print("x" * len(s))


if __name__ == '__main__':
    main()

Solution (Python):
S = input()
L = len(S)

print('x'*L)

Solution (Python):

x = input()
print(len(x)*"x")

Solution (Python):
s = input()
print('x' * (len(s)))

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
s = input()
n = len(s)
print('x' * n)

Solution (Python):
S = input()

print('x'* len(S))

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

print("x" * N)

Solution (Python):
S = input()

print('x' * len(S))

Solution (Python):
S = input()
l = len(S)
print('x'*l)

Solution (Python):
s = input()
n = len(s)
print( 'x' * n )

Solution (Python):
s = input()
ans = ""

for i in range(len(s)):
    ans += "x"
print(ans)

Solution (Python):
s=len(input())
print("x"*s)

Solution (Python):
s = input()
print('x'*len(s))

Solution (Python):

import re
import math
import itertools
from copy import deepcopy
import fractions
import random
from heapq import heappop,heappush
import time
import sys
readline = sys.stdin.readline

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def fac_list(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s

s=input()
print("x"*len(s))

Solution (Python):
s=input()
print('x'*len(s))

Solution (Python):
S=input()
n=len(S)
print("x"*n)

Solution (Python):
s = input()
length = len(s)
ss = ''
for i in range(length):
    ss += 'x'

print(ss)

Solution (Python):
s = input()
a = 'x' * len(s)
print(a)

Solution (Python):
S = input()
n = len(S)
print(''.join(['x' for _ in range(n)]))

Solution (Python):
s = input()

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

Solution (Python):
s = input()
print("x" * len(s))

Solution (Python):
s = str(input())
n = len(s)
print("x"*n)

Solution (Python):
s = list(input())
print("x" * len(s))

Solution (Python):
n=len(input())
print('x'*n)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)

S = input()
l = len(S)
ans = ['x' for _ in range(l)]

print("".join(ans))

Solution (Python):
S = input()
ans = "x"*len(S)
print(ans)

Solution (Python):
import math
import calendar
import fractions
import itertools

s = input()
a = len(s)
ans = ""
for i in range(a):
    ans += "x"
print(ans)

Solution (Python):
S = input()
print("x" * len(S))

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):
s=input()

print(len(s)*"x")

Solution (Python):
S = input()

print("x"*len(S))

Solution (Python):
print("x" * len(input()))

Solution (Python):
s=list(input())
ans=""
for i in range(len(s)):
    ans+="x"
print(ans)

Solution (Python):

import sys
input = sys.stdin.readline
INF = 10**9

s = input().rstrip()
print("x" * len(s))

Solution (Python):
s = str(input())
n = len(s)
for _ in range(n):
  print("x",end="")

Solution (Python):
S = input()

ans = "x" * len(S)

print(ans)

Solution (Python):
s = input()

for i in range(len(s)):
    print('x', end="")

Solution (Python):

s = str(input())

for i in range(len(s)):
    print('x', end = '')

Solution (Python):



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

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

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

def main():
    s = input()
    print('x'*len(s))


if __name__ == '__main__':
    main()

Solution (Python):
S = input()
print("x" * len(S))

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

Solution (Python):
S = input()
for i in range(len(S)):
  print('x', end='')
print()

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

Solution (Python):
s = input()
ans = []
for i in range(len(s)):
    ans.append("x")
print("".join(ans))

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
s = input()

print('x'*len(s))

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

Solution (Python):
S = input()

print("x"*len(S))

Solution (Python):
s = input()
print("x" * len(s))

Solution (Python):
print("x"*len(input()))

Solution (Python):
S = input()
L = len(S)

print("x" * L)

Solution (Python):
S = input()

print('x'*len(S))

Solution (Python):
s = input()
print('x' * len(s))

Solution (Python):
s = input()

print('x' * len(s))

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):
s = input()
print('x' * len(s))

Solution (Python):
print("x"*len(input()))

Solution (Python):
S = input()
print("x" * len(S))

Solution (Python):
import math,itertools,fractions,heapq,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  s=S()
  x=len(s)

  ans=['x' for _ in range(x)]
  return ''.join(ans)


print(main())

Solution (Python):
S=input()

for i in range(len(S)):
    print("x",end="")
print()

Solution (Python):
S = input()
N = len(S)

for i in range(N):
    print("x", end="")

print()

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    s = S()
    print('x' * len(s))

main()

Solution (Python):
Ss = input()

print('x'*len(Ss))

Solution (Python):
S = input()
N = len(S)
print("x"*N)

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):
s = input()
ans = ""
for i in range(len(s)):
    ans += "x"
print(ans)

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

S = input()
print('x' * len(S))

Solution (Python):
S = input().strip()
print('x' * len(S))

Solution (Python):
def main():
    S = input()
    print("x"*len(S))
    return

if __name__ == "__main__":
    main()

Solution (Python):
def main():
    S = input()
    print('x' * len(S))



if __name__ == "__main__":
    main()

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


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret


S = input()

print('x' * len(S))

Solution (Python):
s = input()
print('x'*len(s))

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
from sys import stdin
s = stdin.readline().rstrip()
print("x"*len(s))

Solution (Python):
import sys
input = sys.stdin.readline
S = input()[: -1]
print("x" * len(S))

Solution (Python):
s=input()
n=len(s)
t="x"*n
print(t)

Solution (Python):
S=input()
l = len(S)
ans = "x" * l
print(ans)

Solution (Python):
S = input()
print("x" * len(S))

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

s=input()
n=len(s)
D=["x"]*n
print(*D,sep="")

Solution (Python):
S = input()
print('x'*len(S))

Solution (Python):
s = input()

print('x' * len(s))

Solution (Python):
n=len(input())
print("x"*n)

Solution (Python):
S = len(input())

print('x'*S)

Solution (Python):
s = input()
print('x'*len(s))

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

s = input()
n = len(s)
ans = 'x'*n
print(ans)

Solution (Python):
s = input()
print('x'*len(s))

Solution (Python):
X = input()

print("x" * len(X))

Solution (Python):
S = input()
print("x"*len(S))

Solution (Python):

S = input()
print("x" * len(S))

Solution (Python):
def I(): return int(input())
def MI(): return map(int, input().split())
def LMI(): return list(map(int, input().split()))


S = input()
print('x' * len(S))

Solution (Python):
S = input()
ans = [""]*len(S)
for i in range(len(S)):
    ans[i] = "x"
print("".join(ans))

Solution (Python):
S=input()
print('x'*len(S))

Solution (Python):
print('x'*len(input()))

Solution (Python):
def main():
    S = input()
    print("x" * len(S))


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    S = input()
    N = len(S)
    print("x"*N)


if __name__ == '__main__':
    main()

Solution (Python):
print("x"*len(input()))

Solution (Python):
s = input()
print('x'*len(s))

Solution (Python):
S = input()
for _ in range(len(S)):
    print("x",end="")

Solution (Python):
s = input()

print('x'*len(s))

Solution (Python):
s=input()
print("x"*len(s))

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
S = input()
ans = ""
for i in range(len(S)):
    ans += "x"
print(ans)

Solution (Python):
def main():
    S = input()
    print('x' * len(S))


main()

Solution (Python):
s=input()
print("x" * len(s))

Solution (Python):
import sys


def main():
    s = sys.stdin.readline().strip()

    a = []
    for _ in s:
        a.append('x')

    print(''.join(a))


if __name__ == '__main__':
    main()

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
S = input()
n = len(S)
print('x'*n)

Solution (Python):
s = input()

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

print(ans)

Solution (Python):

S = input()

lis = ["x"] * len(S)

print ("".join(lis))

Solution (Python):
def main():
    s = input()
    n = len(s)

    print('x' * n)


if __name__ == '__main__':
    main()

Solution (Python):
S = input()
print("x" * len(S))

Solution (Python):
s=input()
print("x"*len(s))

Solution (Python):
s = str(input())
for i in range(len(s)):
    print('x', end='')
print('')

Solution (Python):
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

print('x'*len(ns()))

Solution (Python):
S = input()
print('x' * len(S))

Solution (Python):
s = input()
print("x"*len(s))

Solution (Python):
s = input()

ans = "x" * len(s)
print(ans)

Solution (Python):
S= input()
l = len(S)
print("x"*l)

Solution (Python):
S = input()
N = len(S)
print('x'*N)

Solution (Python):
S = input()

t = "x" * len(S)

print(t)

Solution (Python):
S=input()
N=len(S)
print("x"*N)

Solution (Python):
S = input()
print('x'*len(S))

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


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


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


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

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

s = input()

print("x" * len(s))

Solution (Python):
print "x"*len(raw_input())

Solution (Python):
S = input()

print("x"*len(S))

Solution (Python):
s = input()

print('x'*len(s))

Solution (Python):
print("x"*len(input()))