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):
s = input()
print(len(s)*'x')

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

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

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

Solution (Python):
S=input()
ans=''
for _ in range(len(S)):
    ans+='x'

print(ans)

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

print("x"*n)

Solution (Python):
s = input()

s_len = len(s)
ans = 'x' * s_len
print(ans)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

Solution (Python):
def A():
    temp = input().split()
    S = temp[0]
    T = temp[1]
    temp = [int(i) for i in input().split()]
    A = temp[0]
    B = temp[1]
    U = input()
    if U == S:
        print(A-1, B)
    else:
        print(A, B-1)

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

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

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

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()
print("x" * len(s))

Solution (Python):
s = len(str(input()))
ss = ["x"]*s
print("".join(ss))

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

Solution (Python):
s = list(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):
a = input()
l = len(a)
print("x"*l)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    main()

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""




s = input()

a = len(s)-1


print("x"*a)

Solution (Python):
S=input()
L = len(list(S))
ans = ""

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

print(ans)

Solution (Python):
s = input()

print('x' * len(s))

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




print("x"*s)

Solution (Python):
a=str(input())
l=len(a)
c=''
for i in range(l):
    c+='x'
print(c)

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

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

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

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



if __name__ == "__main__":
    main()

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

Solution (Python):
s = input()

n = len(s)

print("x" * n)

Solution (Python):
S=input()
N=len(S)
ans=""
for i in range(N):
    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('x'*len(s))

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

Solution (Python):
s = input()

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()
  
print("".join(["x" for i in s]))

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

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

for i in range(len(s)):
    a+='x'

print(a)

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

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

print('x' *s )

Solution (Python):

import sys
import numpy as np
from collections import deque
from itertools import combinations
sys.setrecursionlimit(10**9)


def main():
    S = input()
    x = ""
    for i in range(len(S)):
        x += "x"

    print(x)



if __name__ == "__main__":
  main()

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
S = input()

t = ""

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

print(t)

Solution (Python):
def repeat_x(n):
    if n == 0:
        return ""
    else:
        return "x"+repeat_x(n-1)
s = input()
print(repeat_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):
s = input()
print('x'* len(s))

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

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

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

s = input().strip()

print('x' * len(s))

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):
import sys
sys.setrecursionlimit(int(1e6))

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

Solution (Python):
s = input()

print("x"*len(s))

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

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

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):

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

Solution (Python):
S = input()

print("x" * len(S))

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

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

Solution (Python):
S = input()

print('x'*len(S))

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

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

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

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

Solution (Python):
from sys import stdout
printn = lambda x: stdout.write(str(x))
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):
def main():
    S = input()

    print("x" * len(S))


main()

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	N = IS()
	l = len(N)
	ans = ""
	for i in range(l):
		ans += 'x'
	print(ans)

main()

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

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

if __name__ == '__main__':
    main()

Solution (Python):


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

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

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

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

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

print(''.join( ['x'] * n))

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

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

Solution (Python):
from bisect import *
from collections import *
from fractions import gcd


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

Solution (Python):
S = input()

print("x" * len(S))

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

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

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

Solution (Python):

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

Solution (Python):

S = input()

ans = ''
for _ in range(len(S)):
    ans += 'x'

print(ans)

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy,copy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

def main():
    s = len(input())
    x = ['x']*s
    print(''.join(x))

if __name__=='__main__':
    main()

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

Solution (Python):
S = input()

out = ''
for s in S:
  out += 'x'
print(out)

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

Solution (Python):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


yn = 'YNeos'
ynflg = False
cnt = 0
ans = None

def lcm(a, b):
    return (a*b) // gcd(a,b)

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

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas



S = input()


print('x'*len(S))

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


if __name__ == '__main__':
    main()

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

Solution (Python):
S = input()

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

Solution (Python):

S=input()
s=""
for i in range(len(S)):
    s="".join((s,"x"))
print(s)

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

print("x" * count_s)

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

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

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

s = input().split()[0]

print('x'*len(s))

Solution (Python):
S = input()

print("x"*len(S))

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

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

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

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

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):
S = input()
print("x" * len(S))

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

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(input()) 
def ifn(): return float(input()) 
def isn(): return input().split() 
def imn(): return map(int, input().split()) 
def fmn(): return map(float, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, input().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD

S = input()

ans = ''
for _ in range(len(S)):
    ans += 'x'
print(ans)

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

Solution (Python):










s = input()

a = len(s)

ans = "x" * a

print(ans)

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

Solution (Python):


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

print(ans)

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

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

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

print(s)

Solution (Python):
import bisect
import numpy as np
import math
import itertools
def main():
    S = input()
    print("x" * len(S))


    return 0
if __name__ == '__main__':
    main()

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

S = readline().strip()

print('x' * len(S))

Solution (Python):
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda x: [ni() for _ in range(x)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda x: [na() for _ in range(x)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda x: [ns() for _ in range(x)]
nas = lambda: stdin.readline().split()

s = ns()
n = len(s)

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

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

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

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

Solution (Python):
def resolve():
    S = input()
    a = ''
    for s in S:
        a += 'x'
    print(a)
resolve()

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

Solution (Python):
print(''.join('x' for x in input()))

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

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

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

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

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

Solution (Python):

def solve():
    return 'x'*len(input())

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

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

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

print(ans)

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

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


if __name__ == "__main__":
    main()

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

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

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

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

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 = ans + 'x'

print(ans)

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

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

Solution (Python):
s = input()

ans = ["x"] * len(s)

print("".join(ans))

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

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

Solution (Python):
s = input()

print('x' * len(s))

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

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

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

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

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

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

Solution (Python):
s = input()
ans = ['x' for _ in range(len(s))]
print(*ans, sep="")

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()
l = len(s)
ans = ""
for i in range(l):
    ans += "x"
print(ans)

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


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


def S(): return input()


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = {False: 'No', True: 'Yes'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    s = S()
    li = ['x' for x in range(len(s))]
    ans = ''

    for i in li:
        ans += i

    print(ans)


if __name__ == '__main__':
    main()

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

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

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

if __name__ == '__main__':
    resolve()

Solution (Python):

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

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):
len_S = len(input())
print('x' * len_S)

Solution (Python):
import sys

stdin = sys.stdin

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

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

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

    
if __name__ == "__main__":
    main()

Solution (Python):
S = input()

l = len(S)

print("".join(["x" for i in range(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):
l = len(input())
print('x'*l)

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 = ans + 'x'
  
print(ans)

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

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

Solution (Python):
s = input()

print("x" * len(s))

Solution (Python):








mod = int(1e9+7)

def main():
    s = input()
    x = len(s)
    t = ['x'] * x
    print(''.join(t))
    return

if __name__=='__main__':
    main()

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

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

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

Solution (Python):
S=input()
ans=['x']*len(S)
print("".join(ans))

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

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

Solution (Python):
S = input()

print("x"*len(S))

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

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

Solution (Python):
S=input()

ans=''
for _ in range(len(S)):
  ans+='x'
print(ans)

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

Solution (Python):

s = input()



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

Solution (Python):
s = input()

ans = ''
for i in s:
  ans += 'x'

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 = input()
l = len(s)
print('x' * l)

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

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

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

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

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

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

Solution (Python):



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

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

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

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

Solution (Python):
s = input()

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

Solution (Python):
a=list(input())
for i in range(len(a)):
    a[i]='x'
print(''.join(a))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

S = read().decode().rstrip()

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):
l = len(input())
print("x"*l)

Solution (Python):


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


if __name__ == "__main__":
    resolve()

Solution (Python):
s = input()

print("x"*len(s))

Solution (Python):
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()

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

Solution (Python):

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

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


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


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


def read_str_n():
    return list(map(str, input().split()))


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


def mt(f):
    import time

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

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

    return wrap


@mt
def slv(S):
    return 'x' * len(S)


def main():
    S = read_str()
    print(slv(S))


if __name__ == '__main__':
    main()

Solution (Python):
A = input()
B = ''
for i in range(len(A)):
        B += 'x'

print(B)

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

Solution (Python):
def main():
    S = input()

    print('x' * len(S))


if __name__ == '__main__':
    main()

Solution (Python):
s = input()

print("x" * len(s))

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

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

Solution (Python):
s=list(input())
n=len(s)
l=[]
for i in range(n):
  l.append('x')
print(''.join(l))

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline

























def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	S = input()
	S = S[:-1]
	ans = ""
	for i in S:
		ans += "x"

	print(ans)

if __name__ == "__main__":
	main()

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

Solution (Python):
S = input()

ans = "x"*len(S)

print(ans)

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

main()

Solution (Python):
s = input()
print(''.join(['x' for c in s]))

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

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

Solution (Python):
if __name__ == '__main__':
    s = input()
    print("x" * len(s))

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

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

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

print(ans)

Solution (Python):

from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))


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



main()

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

Solution (Python):
s = input()

ans = ['x']*len(s)

print(*ans, sep ='')

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

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

if __name__ == '__main__':
    solve()

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

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

S = input()

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

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

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

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

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

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

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

Solution (Python):


s = input()


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

print("".join(map(str, a)))

Solution (Python):
s = input() 

print("x" * len(s))

Solution (Python):

S = str(input())

ans = "x"

print(ans*len(S))

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

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


if __name__ == "__main__":
    main()

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):
import sys
def input():
    return sys.stdin.readline()[:-1]

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

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

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

Solution (Python):
s = input()

print("x"*len(s))

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    S = input().strip()
    for _ in S:
        print("x", end="")
    
    

if __name__ == '__main__':
    main()

Solution (Python):
def input_int():
    return map(int, input().split())

def one_int():
    return int(input())

def one_str():
    return input()

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

S=one_str()

print("".join(["x"]*len(S)))

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

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

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

Solution (Python):



s = input()

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