The semester is already ending, so Danil made an effort and decided to visit a lesson on harmony analysis to know how does the professor look like, at least. Danil was very bored on this lesson until the teacher gave the group a simple task: find 4 vectors in 4-dimensional space, such that every coordinate of every vector is 1 or  - 1 and any two vectors are orthogonal. Just as a reminder, two vectors in n-dimensional space are considered to be orthogonal if and only if their scalar product is equal to zero, that is: $\sum_{i = 1}^{n} a_{i} \cdot b_{i} = 0$.

Danil quickly managed to come up with the solution for this problem and the teacher noticed that the problem can be solved in a more general case for 2^{k} vectors in 2^{k}-dimensinoal space. When Danil came home, he quickly came up with the solution for this problem. Can you cope with it?


-----Input-----

The only line of the input contains a single integer k (0 ≤ k ≤ 9).


-----Output-----

Print 2^{k} lines consisting of 2^{k} characters each. The j-th character of the i-th line must be equal to ' * ' if the j-th coordinate of the i-th vector is equal to  - 1, and must be equal to ' + ' if it's equal to  + 1. It's guaranteed that the answer always exists.

If there are many correct answers, print any.


-----Examples-----
Input
2

Output
++**
+*+*
++++
+**+


-----Note-----

Consider all scalar products in example:  Vectors 1 and 2: ( + 1)·( + 1) + ( + 1)·( - 1) + ( - 1)·( + 1) + ( - 1)·( - 1) = 0  Vectors 1 and 3: ( + 1)·( + 1) + ( + 1)·( + 1) + ( - 1)·( + 1) + ( - 1)·( + 1) = 0  Vectors 1 and 4: ( + 1)·( + 1) + ( + 1)·( - 1) + ( - 1)·( - 1) + ( - 1)·( + 1) = 0  Vectors 2 and 3: ( + 1)·( + 1) + ( - 1)·( + 1) + ( + 1)·( + 1) + ( - 1)·( + 1) = 0  Vectors 2 and 4: ( + 1)·( + 1) + ( - 1)·( - 1) + ( + 1)·( - 1) + ( - 1)·( + 1) = 0  Vectors 3 and 4: ( + 1)·( + 1) + ( + 1)·( - 1) + ( + 1)·( - 1) + ( + 1)·( + 1) = 0

Difficulty: MEDIUM_HARD
Tags: Constructive algorithms

Starter code:

Solutions:
a = [1, -1]
b = [1, 1]
X = [a, b]
cur = 1
k = int(input())

def pr(X):
	for v in X:
		print(''.join(['*' if x == -1 else '+' for x in v]))

def get_xor(v):
	return [-1 * x for x in v]

def build(X):
	ans = []
	n = len(X)
	for i in range(0, n, 2):
		ans.extend([X[i] + X[i + 1], X[i + 1] + X[i], get_xor(X[i]) + X[i + 1], X[i + 1] + get_xor(X[i])])
	return ans
if k == 0:
	print('+')
else:
	while cur < k:
		X = build(X)
		cur += 1
	pr(X)


__author__ = 'Utena'

def t(x):
	a = ''
	for l in x:
		if l == '+':
			a += '*'
		elif l == '*':
			a += '+'
	return a
k = int(input())
if k == 0:
	print('+')
	return
m = ['++', '+*']
s = 1
for i in range(k - 1):
	m = m + m
	s *= 2
	for j in range(s):
		m[j] += m[j]
		m[s + j] += t(m[s + j])
for y in m:
	print(y)


def solve():
	K = int(input())
	e = [['++', '**'], ['+*', '*+']]
	vs = ['+']
	for i in range(K):
		nv = []
		for j in range(2):
			for v in vs:
				x = []
				for c in v:
					x.append(e[j][0] if c == '+' else e[j][1])
				nv.append(''.join(x))
		vs = nv
	for v in vs:
		print(v)

def __starting_point():
	solve()
__starting_point()


from __future__ import nested_scopes, generators, division, absolute_import, with_statement, print_function, unicode_literals
import sys, os, time

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

def rl(n):
	return [list(map(int, input().split())) for _ in range(n)]
if os.path.exists('test.txt'):
	sys.stdin = open('test.txt')

def get(k):
	if k == 0:
		return [[1]]
	smaller = get(k - 1)
	newdim = len(smaller) * 2
	res = [[0] * newdim for _ in range(newdim)]
	for row in range(newdim):
		for col in range(newdim):
			res[row][col] = smaller[row % len(smaller)][col % len(smaller)]
			if row >= len(smaller) and col >= len(smaller):
				res[row][col] *= -1
	return res

def solve():
	(k,) = rv()
	res = get(k)
	for row in res:
		for char in row:
			print('+' if char == 1 else '*', end='')
		print()
solve()


def vec(x):
	if x == 0:
		return [[1]]
	x -= 1
	s = vec(x)
	y = vec(x)
	for i in range(2 ** x):
		for j in range(2 ** x):
			y[i][j] = -y[i][j]
	a = [s[i] + y[i] for i in range(2 ** x)]
	b = [s[i] + s[i] for i in range(2 ** x)]
	return a + b
x = int(input())
s = vec(x)
for i in range(2 ** x):
	res = ''
	for j in range(2 ** x):
		res += '+' if s[i][j] == 1 else '*'
	print(res)


k = int(input())

def solve(k):
	if k == 0:
		return [[1]]
	r = solve(k - 1)
	res = []
	for v in r:
		res.append(v + v)
		res.append(v + [x * -1 for x in v])
	return res
res = solve(k)
for v in res:
	s = ''
	for x in v:
		if x == 1:
			s += '+'
		else:
			s += '*'
	print(s)


import itertools
import math

def minusv(L):
	return [-x for x in L]

def adamar(M):
	return [L * 2 for L in M] + [L + minusv(L) for L in M]
k = int(input())
a = [[1]]
for i in range(k):
	a = adamar(a)
for L in a:
	print(''.join(['+' if c == 1 else '*' for c in L]))


n = int(input())
h = [1]
for i in range(n):
	if i == 0:
		h = [[1, 1], [1, -1]]
	else:
		x = []
		for row in h:
			p = row.copy()
			p.extend(p)
			x.append(p)
		for row in h:
			p = row.copy()
			p.extend([-x for x in p])
			x.append(p)
		h = x.copy()
if n == 0:
	print('+')
else:
	for row in h:
		for i in row:
			c = '+' if i == 1 else '*'
			print(c, end='')
		print('')


def op(k):
	r = []
	for i in k:
		if i == '*':
			r.append('+')
		else:
			r.append('*')
	return r
x = int(input())
if x == 0:
	print('*')
	quit()
elif x == 1:
	print('**')
	print('*+')
	quit()
k = ['++**', '+*+*', '+**+', '++++']

def f(x):
	bb = []
	if x == 2:
		return k
	for i in f(x - 1):
		bb.append(2 * list(i))
		bb.append(list(i) + op(list(i)))
	return bb
k = f(x)
for i in k:
	print(''.join(i))


def invert(a):
	for i in range(len(a)):
		for j in range(len(a[i])):
			if a[i][j] == 1:
				a[i][j] = 0
			else:
				a[i][j] = 1
	return a
k = int(input())
a = [[1]]
if k == 0:
	print('+')
	exit()
for i in range(1, k + 1):
	ans = [None] * 2 ** i
	ares = []
	for j in a:
		ares1 = []
		for u in j:
			if u == 1:
				ares1.append(1)
			else:
				ares1.append(0)
		ares.append(ares1)
	invert(ares)
	for j in range(2 ** i // 2):
		ans[j] = a[j] + a[j]
	for j in range(2 ** i // 2, 2 ** i):
		ans[j] = a[j - 2 ** i // 2] + ares[j - 2 ** i // 2]
	a = ans
for i in a:
	for j in i:
		if j == 1:
			print('+', end='')
		else:
			print('*', end='')
	print()


import sys

def flatten(iter_lst):
	return list((item for iter_ in iter_lst for item in iter_))

def repeatPattern(a, b, totalLength):
	totalLength = len(a) * len(b)
	ret = [None] * totalLength
	x = 0
	for i in a:
		for j in b:
			ret[x] = i * j
			x += 1
	return tuple(ret)

def vectors(k):
	if k == 0:
		return set([(1,)])
	if k == 1:
		return set(((1, 1), (1, -1)))
	else:
		vk = vectors(k - 1)
		ret = set()
		for a in vectors(1):
			for b in vk:
				ret.add(repeatPattern(a, b, None))
		return ret

def string(v):
	return ''.join(('+' if i == 1 else '*' for i in v))

def strings(k):
	return map(string, vectors(k))
N = int(input())
for s in strings(N):
	print(s)


Not = lambda x: '+' if x == '*' else '*'
k = int(input())
n = 2 ** k
a = [['+'] * n for i in range(n)]
for p in range(k):
	n = 2 ** p
	for i in range(n):
		for j in range(n):
			a[i][j + n] = a[i][j]
			a[i + n][j] = a[i][j]
			a[i + n][j + n] = Not(a[i][j])
[print(''.join(map(str, i))) for i in a]


def flip(s):
	temp = []
	for c in s:
		if c == '+':
			temp.append('*')
		else:
			temp.append('+')
	return ''.join(temp)

def main():
	k = int(input())
	prev = ['+']
	for i in range(1, k + 1):
		p1 = [x for x in prev]
		p2 = [flip(x) for x in prev]
		temp = []
		for j in range(len(prev)):
			temp.append(p1[j] + prev[j])
			temp.append(p2[j] + prev[j])
		prev = temp
	for p in prev:
		print(p)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


p = [[0]]
for i in range(int(input())):
	p = [t + t for t in p] + [[1 - q for q in t] + t for t in p]
for t in p:
	print(''.join(('+*'[q] for q in t)))


def flip(str):
	ret = ''
	for k in str:
		if k == '+':
			ret += '*'
		else:
			ret += '+'
	return ret
k = int(input())
a2 = ['++', '+*']
a1 = []
if k == 0:
	print('+')
	exit(0)
while k > 1:
	a3 = []
	flag = True
	for p in range(2):
		for i in range(len(a2)):
			if flag:
				temp = a2[i] + a2[i]
				a3.append(temp)
			else:
				temp = a2[i] + flip(a2[i])
				a3.append(temp)
		flag = False
	a2 = a3
	k -= 1
for i in a2:
	print(i)


def anti(s):
	return ''.join(['+' if s[i] == '*' else '*' for i in range(len(s))])
k = int(input())
result = [[] for i in range(k + 2)]
result[0] = ['+']
for i in range(1, k + 1):
	for e in result[i - 1]:
		result[i] += [e + e]
		result[i] += [e + anti(e)]
print('\n'.join(result[k]))


from functools import reduce
from operator import *
from math import *
from sys import *
from string import *
from collections import *
setrecursionlimit(10 ** 7)
dX = [-1, 1, 0, 0, -1, 1, -1, 1]
dY = [0, 0, -1, 1, 1, -1, -1, 1]
RI = lambda : list(map(int, input().split()))
RS = lambda : input().rstrip().split()

def inv(x):
	s = ''
	for i in x:
		s += '+*'[i == '+']
	return s
x = ['+']
n = RI()[0]
for i in range(n):
	t = []
	for j in range(len(x)):
		t.append(x[j] + x[j])
		t.append(x[j] + inv(x[j]))
	x = t
print(*x, sep='\n')


k = int(input())
a = [['' for _ in range(2 ** k)] for _ in range(2 ** k)]
a[0][0] = '+'
for m in range(1, k + 1):
	p = 2 ** (m - 1)
	for i in range(p):
		for j in range(p):
			a[p + i][j] = a[i][j]
			if i % 2 == 0:
				a[i][p + j] = '*' if a[i][j] == '+' else '+'
				a[p + i][p + j] = a[i][j]
			else:
				a[i][p + j] = a[i][j]
				a[p + i][p + j] = '*' if a[i][j] == '+' else '+'
print('\n'.join((''.join(x) for x in a)))


import sys

def check(arr):
	n = len(arr)
	for i in range(n):
		for j in range(i + 1, n):
			diff = 0
			for k in range(n):
				if arr[i][k] == arr[j][k]:
					diff += 1
				else:
					diff -= 1
			if diff:
				return (arr[i], arr[j])
	return False

def inv(arr):
	return [not x for x in arr]

def gen(n):
	if n == 1:
		return [[True]]
	curr = gen(n // 2)
	ans = []
	ans.extend((x + x for x in curr))
	ans.extend((x + inv(x) for x in curr))
	return ans
k = int(input())
ans = gen(2 ** k)
for x in ans:
	sys.stdout.write(''.join(['+' if el else '*' for el in x]))
	sys.stdout.write('\n')


k = int(input())

def reflect(matrix):
	temp = list(matrix)
	for i in range(len(matrix)):
		matrix[i] = list(matrix[i])
	temp.reverse()
	return temp

def invert(matrix):
	temp = list(matrix)
	for i in range(len(temp)):
		temp[i] = list(temp[i])
	for i in range(len(temp)):
		for j in range(len(temp[i])):
			temp[i][j] = not temp[i][j]
	return temp
seed = [[True]]
while k > 0:
	refl = reflect(seed)
	inve = invert(refl)
	seedlen = len(seed)
	invelen = len(inve)
	for i in range(seedlen):
		seed[i].extend(seed[i])
	for i in range(invelen):
		inve[i].extend(refl[i])
	seed.extend(inve)
	k -= 1
line = ''
for i in range(len(seed)):
	for j in range(len(seed[i])):
		if seed[i][j] == True:
			line += '+'
		else:
			line += '*'
	print(line)
	line = ''


k = int(input())
if k == 0:
	print('+')
	return
answer = [['+', '+'], ['+', '*']]
length = 2
for i in range(k - 1):
	new = []
	for i in answer:
		temp = []
		for j in range(length):
			if i[j] == '+':
				temp += ['+', '+']
			else:
				temp += ['*', '*']
		new.append(temp)
	for i in answer:
		temp = []
		for j in range(length):
			if i[j] == '+':
				temp += ['+', '*']
			else:
				temp += ['*', '+']
		new.append(temp)
	answer = new
	length *= 2
print('\n'.join([''.join(i) for i in answer]))


import sys
if False:
	inp = open('C.txt', 'r')
else:
	inp = sys.stdin

def inverse(string):
	ans = ''
	for char in string:
		if char == '*':
			ans += '+'
		else:
			ans += '*'
	return ans

def recursion(k):
	if k == 0:
		return ['+']
	ans = recursion(k - 1)
	ans = ans + ans
	for i in range(2 ** (k - 1)):
		ans[i] = 2 * ans[i]
		ans[i + 2 ** (k - 1)] += inverse(ans[i + 2 ** (k - 1)])
	return ans
k = int(inp.readline())
for string in recursion(k):
	print(string)


n = int(input())
ans = [[1]]
k = 0
while k < n:
	k += 1
	for i in range(len(ans)):
		ans[i].extend(ans[i])
	for i in range(len(ans)):
		ans.append(ans[i][:])
	for i in range(int(len(ans) / 2), len(ans)):
		for j in range(int(len(ans[i]) / 2), len(ans[i])):
			ans[i][j] *= -1
for i in ans:
	for j in i:
		if j == -1:
			print('*', end='')
		else:
			print('+', end='')
	print()


def f(k):
	if k == '+':
		return '*'
	else:
		return '+'

def g(k):
	s = []
	for c in k:
		s.append(f(c))
	return ''.join(s)

def solve(k):
	if k == 0:
		return ['+']
	else:
		h = solve(k - 1)
		n = 1 << k
		q = n >> 1
		for i in range(q):
			h.append(h[i] + g(h[i]))
			h[i] += h[i]
		return h
k = int(input())
h = solve(k)
for a in h:
	print(a)


import os, sys
from io import BytesIO, IOBase
from array import array

def main():
	k = int(input())
	if not k:
		print('+')
		exit()
	an = [array('i', [1, -1]), array('i', [1, 1])]
	for _ in range(k - 1):
		for j in range(len(an)):
			an[j] += an[j]
		for j in range(len(an)):
			an.append(an[j][:])
			for l in range(len(an[-1]) // 2):
				an[-1][l] *= -1
	for i in an:
		print(''.join(map(lambda xx: '+' if xx == 1 else '*', i)))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


def gen(k):
	if k == 0:
		return ['+']
	pattern = gen(k - 1)
	new = [''.join((c + c for c in st)) for st in pattern]
	new.extend((''.join((('+' if c == '*' else '*') + c for c in st)) for st in pattern))
	return new
n = int(input())
for line in gen(n):
	print(line)


import os
import sys
from io import BytesIO, IOBase
from collections import Counter
from bisect import *
from math import gcd
from itertools import permutations, combinations

def main():
	k = int(input())
	x = 1 << k
	a = [[] for _ in range(x)]
	a[0].append('+')
	z = 1
	while z < x:
		y = len(a[0])
		for l in range(z):
			for j in range(y):
				a[l].append(a[l][j])
				a[l + z].append('+' if a[l][j] == '*' else '*')
			for j in range(y):
				a[l + z].append(a[l][j])
		z = z * 2
	for i in a:
		print(''.join(i))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


def vec(x):
	if x == 0:
		return [[1]]
	s = vec(x - 1)
	y = vec(x - 1)
	for i in range(2 ** (x - 1)):
		for j in range(2 ** (x - 1)):
			y[i][j] = -y[i][j]
	out = [s[i] + y[i] for i in range(2 ** (x - 1))]
	out2 = [s[i] + s[i] for i in range(2 ** (x - 1))]
	return out + out2
x = int(input())
s = vec(x)
for i in range(2 ** x):
	ret = ''
	for j in range(2 ** x):
		if s[i][j] == 1:
			ret += '+'
		else:
			ret += '*'
	print(ret)


import sys
input = sys.stdin.readline

def neg(a):
	b = ''
	for i in range(len(a)):
		if a[i] == '+':
			b += '*'
		else:
			b += '+'
	return b
n = int(input())
a = '+'
e = [a]
for i in range(n):
	for j in range(2 ** i):
		b = e[j]
		e[j] += b
		e.append(b + neg(b))
for i in range(len(e)):
	print(e[i])


def rev(i):
	t = ''
	for x in i:
		if x == '+':
			t += '*'
		else:
			t += '+'
	return t

def f(n):
	if n == 1:
		return ['++', '+*']
	x = f(n - 1)
	p = list((i + i for i in x))
	p = p + list((i + rev(i) for i in x))
	return p
N = int(input())
if N == 0:
	print('+')
else:
	t = f(N)
	for i in t:
		print(i)


def vectors(k):
	vs = [1]
	m = 1
	for i in range(k):
		s = 1 << i
		vs_ = []
		for v in vs:
			u = v << s
			vs_.append(u | v)
			vs_.append(u | ~v & m)
		vs = vs_
		m = m << s | m
	return vs

def print_vector(k, v):
	b = bin(v)[2:].zfill(2 ** k)
	print(b.translate(str.maketrans('10', '+*')))
k = int(input())
for v in vectors(k):
	print_vector(k, v)


a = int(input())

def anti(s):
	s1 = ''
	for i in s:
		if i == '+':
			s1 += '*'
		else:
			s1 += '+'
	return s1

def f(k):
	if k == 0:
		return ['*']
	l = f(k - 1)
	l2 = []
	for m in l:
		l2.append(m + m)
		l2.append(m + anti(m))
	return l2
for k in f(a):
	print(k)


def neg(a):
	if a == '+':
		return '*'
	else:
		return '+'

def gen(s, e, k, l, a):
	if s + 1 < e:
		mid = int((s + e) / 2)
		a[mid] = []
		for i in range(0, pow(2, l)):
			a[mid].append(a[s][i])
		for i in range(pow(2, l), pow(2, l + 1)):
			a[mid].append(neg(a[s][i]))
		for i in range(pow(2, l + 1), k):
			a[mid].append(a[mid][int(i % pow(2, l + 1))])
		gen(s, mid, k, l + 1, a)
		gen(mid, e, k, l + 1, a)
	return

def print_l(a, n):
	b = ''
	for i in range(0, n):
		b += str(a[i])
	print(b)
	return
n = int(input())
a = [None] * pow(2, n)
a[0] = ['+'] * pow(2, n)
gen(0, pow(2, n), pow(2, n), 0, a)
for i in range(0, pow(2, n)):
	print_l(a[i], pow(2, n))


inv = lambda t: ''.join(('*' if u == '+' else '+' for u in t))
n = int(input())
r = ['+']
for _ in range(n):
	r = [r[i] * 2 for i in range(len(r))] + [r[i] + inv(r[i]) for i in range(len(r))]
print(*r, sep='\n')


def f(n):
	if n == 0:
		return ['+']
	else:
		pat = f(n - 1)
		new = [c + c for c in pat]
		new.extend([''.join(['+' if d == '*' else '*' for d in c]) + c for c in pat])
	return new
n = int(input())
for i in f(n):
	print(i)