In this problem you will write a simple code generator for a 2D programming language derived from [Brainfuck](https://en.wikipedia.org/wiki/Brainfuck).

The code in this language is a rectangular grid of characters '.' and 'X'. The code is converted to a Brainfuck program as follows: the characters are read in the usual order (top to bottom, left to right), and each 'X' character is converted a Brainfuck instruction to be executed. The instruction is defined by the left, top and right neighbors of the 'X' character using the following conversion table:

<image>

You are given a string. Output a program in the described language which prints this string.

You can download the language interpreter used for judging here: <https://assets.codeforces.com/rounds/952/puzzling-interpreter.cpp> (use C++11 to compile the code). Note several implementation details:

  * The first step of the language interpretation is conversion to a Brainfuck program, which is then executed.
  * The code must be rectangular, with all lines of the same length. It can have at most 10,000 lines and 10,000 columns, and can have at most 500,000 'X' characters.
  * The code has toroidal topology, i.e. the 'X' on the first line will have top neighbor in the last line.
  * Brainfuck interpreter has 30000 memory cells which store integers from 0 to 255 with increment/decrement done modulo 256.
  * Console input (, command) is allowed in Brainfuck code but has no effect when executed.

Input

The input consists of a single string of characters with ASCII codes between 33 ('!') and 122 ('z'), inclusive. The length of the string is between 1 and 10 characters, inclusive.

Output

Output a program in the described language which, when executed, will print the given message.

Example

Input

$$$

Output

.......X.......
......XXX......
.....XXXXX.....
....XXXXXXX....
...XXXXXXXXX...
..XXXXXXXXXXX..
.XXXXXXXXXXXXX.
...............
X.............X
X..............
X..............
X..............

Note

The example corresponds to the following Brainfuck program:
    
    
           -  
          >+<  
         >+++<  
        >+++++<  
       >+++++++<  
      >+++++++++<  
     >+++++++++++<  
      
    <             >  
    .  
    .  
    .  
    

The triangular block decrements the first memory cell and sets the value of the second memory cell to 36 - the ASCII code of '$' character. The next line after the triangular block moves the memory pointer to the second memory cell, and the next three lines print the '$' character three times.

Source: codeforces | Difficulty: HARD
Tags: Constructive algorithms


Solutions:
WIDTH = 300
assert WIDTH >= 256

def add(n):
	if n == 1:
		add(2)
		add(255)
	elif n:
		print('.' * WIDTH)
		print('X' * (n - 1) + '.' * (WIDTH - n) + 'X')
		print('X' * WIDTH)

def print_mem2():
	print('.' * WIDTH)
	print('XX' + '.' * (WIDTH - 2))
	print('.X' + '.' * (WIDTH - 2))
mem2 = 0
for symbol in map(ord, input()):
	add((symbol - mem2) % 256)
	mem2 = symbol
	print_mem2()


s = input()
for c in s:
	x = ord(c) + 1
	for i in range(200):
		print('.', end='')
	print()
	for i in range(200):
		print('X', end='')
	print()
	for i in range(200):
		print('X', end='')
	print()
	for i in range(200):
		print('.', end='')
	print()
	curr = 200
	while curr > x:
		for i in range(100):
			if curr == x:
				print('..', end='')
			else:
				print('X.', end='')
				curr -= 1
		print()
		for i in range(200):
			print('.', end='')
		print()
	for i in range(199):
		print('.', end='')
	print('X')
	for i in range(199):
		print('.', end='')
	print('X')
	while curr > 1:
		for i in range(100):
			if curr == 1:
				print('..', end='')
			else:
				print('X.', end='')
				curr -= 1
		print()
		for i in range(200):
			print('.', end='')
		print()


s = [ord(x) for x in input()]
val = 0
add2 = '...\n.XX\nXXX'
sub1 = '...\n.X.'
for ch in s:
	delta = ch - val + 1
	if delta > 0:
		if delta % 3 == 1:
			print(add2)
			print(sub1)
			delta -= 1
		elif delta % 3 == 2:
			print(add2)
			delta -= 2
		if delta >= 3:
			tmp = '...' + '\nXXX' * (delta // 3 + 1)
			print(tmp)
	elif delta < 0:
		tmp = '...' + ('\n' + sub1) * -delta
		print(tmp)
	print('...')
	print('.X.')
	print('.X.')
	print('...')
	val = ch


target = input()
codes = [ord(x) for x in target]

def letter(code: int):
	line1 = '.' + 'X' * code + '.'
	line2 = 'X' * (code + 2)
	return [line1, line2]

def printer(code: int):
	lines = ['.X.X']
	line2 = 'XX.' + 'X.' * (code - 1)
	line3 = '.' * (code * 2 - 1) + 'XX'
	return lines + [line2, line3]

def one(code):
	r = []
	r.extend(letter(code))
	r.append('.')
	r.extend(printer(code + 2))
	r.append('.')
	r.append('.')
	return r

def all(codes):
	r = []
	for code in codes:
		r.extend(one(code))
	maxlen = max((len(x) for x in r)) + 3
	for line in r:
		print(line + '.' * (maxlen - len(line)))
all(codes)


import math
WIDTH = 170

def add(n):
	if n == 1:
		add(2)
		add(255)
	else:
		while n:
			k = min(n, WIDTH - 1)
			n -= k
			print('.' * WIDTH)
			print('X' * (k - 1) + '.' * (WIDTH - k) + 'X')
			print('X' * WIDTH)

def print_mem2():
	print('.' * WIDTH)
	print('X' + '.' * (WIDTH - 2) + 'X')
	print('X' + '.' * (WIDTH - 1))
mem2 = 0
for symbol in map(ord, input()):
	add((symbol - mem2) % 256)
	print_mem2()
	mem2 = symbol


s = [ord(x) for x in input().strip()]
pv = 0
at = 0
wid = 600
for x in s:
	dt = (x - pv) % 256
	dt = -dt % 256
	if dt == 0:
		dt = 256
	print('X.' * dt + '.' * (wid - dt * 2))
	print('X' + '.' * (wid - 1))
	print('.' * wid)
	pv = x


import sys
s = input()
f = sys.stdout
n = 0
d = '\x00'
for c in s:
	n = ord(c) - ord(d)
	if n < 0:
		for i in range(-n):
			if i % 2 == 0:
				print('X....', file=f)
			else:
				print('.X...', file=f)
	elif n > 0:
		for i in range(n):
			print('..X..', file=f)
			print('.XXX.', file=f)
			print('XXXXX', file=f)
			print('.....', file=f)
			print('X....', file=f)
	print('.....', file=f)
	print('X...X', file=f)
	print('X....', file=f)
	print('.....', file=f)
	d = c
f.close()


a = input()
for i in a:
	for j in range(256 - ord(i)):
		print('...\n.X.')
	print('.X.')
	for j in range(ord(i)):
		print('...\n.X.')


width = 600
curr = 0
x = input().strip()
for c in x:
	d = ord(c)
	v = (curr - d + 256) % 256
	if v == 0:
		v = 256
	curr = d
	print('.' * width)
	print('.X' * v + '.' * (width - 2 * v))
	print('.X' + '.' * (width - 2))


s = input()
for c in s:
	for i in range(256 - ord(c)):
		print('...\n.X.')
	print('.X.')
	for i in range(ord(c)):
		print('...\n.X.')


print(*['\n'.join([*['...\n.X.' for i in range(256 - x)], '.X.', *['...\n.X.' for i in range(x)]]) for x in map(ord, input())], sep='\n')


for i in map(ord, input()):
	print('..\n.X\n' * (256 - i) + '.X\n' + '..\n.X\n' * i, end='')


n = input()
s = ''
t = ''
for c in n:
	i = ord(c)
	s += '.X.' + '.X..' * i + '.X.X.' + '..' * i + 'X..'
	t += '...' + 'XXX.' * i + 'XX.X.' + 'X.' * i + 'XX.'
print(s)
print(t)
print(len(s) * '.')


data = input()
lens = [256 - ord(data[0])]
for i in range(len(data) - 1):
	lens.append((512 - (ord(data[i + 1]) - ord(data[i]))) % 256)
line0 = '.' * 512
line1 = '.X' + '.' * 510
for i in range(len(data)):
	if lens[i] == 0:
		print(line1)
	else:
		print(line0)
		print('.X' * lens[i] + '..' * (256 - lens[i]))
		print(line1)


import sys
LEN = 500

def read_line():
	return sys.stdin.readline().rstrip('\r\n')
s = read_line()
st = 0
for c in s:
	c = ord(c) - 1 - st
	print(LEN * '.')
	print('..' + c * 'X' + (LEN - 2 - c) * '.')
	print('.' + (c + 2) * 'X' + (LEN - 1 - (c + 2)) * '.')
	print(LEN * '.')
	d = c + 1 + st
	st = 1
	print('..XX' + '.X.' + d * '...' + '.' + 'XX..' + (LEN - 12 - 3 * d) * '.')
	print('.XXX' + '.X.' + d * '.X.' + '.' + 'XXX.' + (LEN - 12 - 3 * d) * '.')
	print(LEN * '.')


s = input()
state = 0
for c in s:
	diff = ord(c) - state
	state = ord(c)
	if diff < -1:
		diff += 256
	for _ in range((diff + 1) // 2):
		print('....\n.XX.\nXXXX')
	if diff % 2 == 1:
		print('....\nX...\nX...')
	else:
		print('X...')


l = []
cur = 0
for c in input():
	x = ord(c)
	while x >= cur:
		x -= 256
	while x < cur:
		print('...')
		print('.X.')
		cur -= 1
	print('.X.')


y = '..\nX.\n..\n'
print(''.join((y * (255 - ord(x)) + 'X.\n' * 2 + y * ord(x) for x in input())))


debug = "\nimport sys\n\n\ndef pr_nt(x):\n\tprint(x)\n\tprint(len(x), file=sys.std err)\n\tglobal xs\n\txs += x.count('X')\n# "
s = input()
res = 'Xx'
counter = 0
for c in s:
	new = ord(c)
	if new > counter:
		counter += 256
	res += '.x' * (counter - new)
	counter = new
	res += '.X'
xs = 0
print(res.replace('x', '.'))
print(res.replace('x', 'X')[:-1] + '.')
print('X'.ljust(len(res), '.'))


def initialize_solution():
	pass

def main():
	s = input()
	for c in s:
		c = ord(c)
		print('.' * 513)
		print('.' * (511 - 2 * c) + 'X' + '.' * (2 * c + 1))
		print('.X' * 256 + '.')
READ_FROM_FILE = None
OUTPUT_PREFIX = None
INTERACTIVE = False
import sys

def read(callback=int, split=True):
	if READ_FROM_FILE:
		ipt = sfile.readline().strip()
	else:
		ipt = input().strip()
	if INTERACTIVE and ipt == 'WRONG_ANSWER':
		sys.exit()
	if split:
		return list(map(callback, ipt.split()))
	else:
		return callback(ipt)

def write(value, end='\n'):
	if value is None:
		return
	try:
		if not isinstance(value, str):
			value = ' '.join(map(str, value))
	except:
		pass
	if READ_FROM_FILE:
		tfile.write(str(value, end=end))
	else:
		print(value, end=end)
	if INTERACTIVE:
		sys.stdout.flush()
sfile = None
tfile = None
if READ_FROM_FILE:
	sfile = open(READ_FROM_FILE + '.in', 'r')
	sfile.seek(0)
	tfile = open(READ_FROM_FILE + '.out', 'w')
if OUTPUT_PREFIX is None:
	result = main()
	if result is not None:
		write(result)
else:
	initialize_solution()
	(TOTAL_CASES,) = read()
	for CASE_NUMBER in range(1, TOTAL_CASES + 1):
		write(OUTPUT_PREFIX.replace('%d', str(CASE_NUMBER)), end='')
		result = main()
		if result is not None:
			write(result)
if sfile is not None:
	sfile.close()
if tfile is not None:
	tfile.close()


def dec():
	print('...')
	print('.X.')

def out():
	print('...')
	print('XX.')
	print('X..')
s = input()
t = 0
for c in s:
	x = ord(c)
	while t != x:
		dec()
		t = (t - 1) % 256
	out()


print(''.join(('..\n.X\n' * (256 - x) + '.X\n' + '..\n.X\n' * x for x in map(ord, input()))))