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



Sample input:
sardine


Sample output:
xxxxxxx

Submission status: Accepted

Solution code:
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
# show_flg = True


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

Submission status: Accepted

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

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

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
# coding: utf-8
S=input()
n=len(S)
print('x'*n)

Submission status: Accepted

Solution code:
s=input()

print("x"*len(s))

Submission status: Accepted

Solution code:
len_S = len(input())
print('x' * len_S)

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

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

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

Submission status: Accepted

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

    
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
S = input()

l = len(S)

print("".join(["x" for i in range(l)]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# import math
# import decimal
# import queue
# import bisect
# import heapq
# import time
# import itertools

mod = int(1e9+7)

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

if __name__=='__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = str(input())

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

Submission status: Accepted

Solution code:
S = input()

print("x"*len(S))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S=input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#n = int(input())
s = input()
#da = list(map(int,input().split()))
#a,b = map(int,input().split())

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

Submission status: Accepted

Solution code:
s = input()

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

print(ans)

Submission status: Accepted

Solution code:
# coding: utf-8
# = int(input())
# = [int(x) for x in input().split()]
s = input()
ans = ""
for i in range(len(s)):
    ans += "x"
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
s = input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#B
s = input()
print('x'*len(s))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:


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


if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
import sys
import math
import bisect

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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()

Submission status: Accepted

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

print(B)

Submission status: Accepted

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

    print('x' * len(S))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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

##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)

##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順

# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順

##### 無限 #####
# f_inf = float('inf')

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

Submission status: Accepted

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

main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
#gcdは3.4.3だとfractionsにある
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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input()

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

print(*ans, sep ='')

Submission status: Accepted

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

if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# = map(int, input().split())
# = int(input())
s = input()
# = list(map(int, input().split()))

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

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

Submission status: Accepted

Solution code:
s = input() 

print("x" * len(s))

Submission status: Accepted

Solution code:
# B
S = str(input())

ans = "x"

print(ans*len(S))

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#n = int(input())
#s, t = map(str, input().split())
#a, b = map(int, input().split())
s = input()

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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)

Submission status: Accepted

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



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
from itertools import product, permutations, combinations
from bisect import bisect_right,bisect_left
INF = float('inf')

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

Submission status: Accepted

Solution code:
#coding:utf-8

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

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.readline

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#B
S = input()
num = len(S)
print("x"*num)

Submission status: Accepted

Solution code:
# https://atcoder.jp/contests/abc154/tasks/abc154_b
S = input()
l = len(S)
print('x' * l)

Submission status: Accepted

Solution code:
S = input()


length = len(S)


print('x'*length)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# N, M = map(int, input().split())
# nums = list(map(int, input().split()))
# nums_2d = [list(map(int, input().split())) for _ in range(N)]


def main():
    S = input()

    print("x" * len(S))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:


S = input()

L = len(S)

ans = ""

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input()


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

Submission status: Accepted

Solution code:

#ライブラリインポート
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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#from fractions import gcd
#mod = 10 ** 9 + 7
#N = int(input())
#a = list(map(int,input().split()))
#a,b,c = map(int,input().split())
#ans = [0] * N
#math.ceilで切り上げ
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)

Submission status: Accepted

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

Submission status: Accepted

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

"""

"""

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

    

main()

Submission status: Accepted

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

print('x'*n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

S = list(input())

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

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

Submission status: Accepted

Solution code:
s=list(input())

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

print("".join(s))

Submission status: Accepted

Solution code:

def main():
    from sys import stdin, setrecursionlimit
    #from sys import stdin, setrecursionlimit
    #setrecursionlimit(10**9)
    #n = int(stdin.readline()[:-1])   
    #r = stdin.readline()[:-1]
    #r = [stdin.readline() for i in range(n)]
    #t = [int(stdin.readline()) for i in range(n)]
    #n = int(r)
    #a = r.split()
    #a,b,c = r.split()
    #a = list(map(int, r.split()))
    #a,b,c,d = map(int, r.split())
    #a = list(map(int, r.split()))
    #a = [int(s[i]) for i in range(1, n+1)]
    #a = [list(map(int, r.split())) for i in range(1,n+1)]
    #a = [list(map(int, input().split())) for i in range(1,n+1)]
    #res = 0

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math

import itertools

#import bisect

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

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]



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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s=str(input())


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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
S = raw_input()

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

print ans

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env 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)

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = str(input())

print('x'*len(S))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!python3

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

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

    print("x" * len(s))

if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

s = input().rstrip()

l = len(s)

print("x" * l)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

print('x'*L)

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()

print('x'* len(S))

Submission status: Accepted

Solution code:
N = len(input())

print("x" * N)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# coding: utf-8
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
#import numpy as np
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
#main
s=input()
print("x"*len(s))