Twilight Sparkle once got a crystal from the Crystal Mine. A crystal of size n (n is odd; n > 1) is an n × n matrix with a diamond inscribed into it.

You are given an odd integer n. You need to draw a crystal of size n. The diamond cells of the matrix should be represented by character "D". All other cells of the matrix should be represented by character "*". Look at the examples to understand what you need to draw.


-----Input-----

The only line contains an integer n (3 ≤ n ≤ 101; n is odd). 


-----Output-----

Output a crystal of size n.


-----Examples-----
Input
3

Output
*D*
DDD
*D*

Input
5

Output
**D**
*DDD*
DDDDD
*DDD*
**D**

Input
7

Output
***D***
**DDD**
*DDDDD*
DDDDDDD
*DDDDD*
**DDD**
***D***

Difficulty: EASY

Solutions:
x = int(input())
for i in range(x // 2 + 1):
	print('*' * (x // 2 - i), 'D' * (i * 2 + 1), '*' * (x // 2 - i), sep='')
for i in range(x // 2 - 1, -1, -1):
	print('*' * (x // 2 - i), 'D' * (i * 2 + 1), '*' * (x // 2 - i), sep='')


N = int(input())
d = 'D'
s = '*'
matrix = []
j = N // 2
k = 1
for i in range(N // 2 + 1):
	matrix.append([f'{s * j}{d * k}{s * j}'])
	j -= 1
	k += 2
s = N // 2 - 1
for j in range(N):
	if j > N // 2:
		print(*matrix[s])
		s -= 1
	else:
		print(*matrix[j])


n = int(input())
for i in range(n):
	for j in range(n):
		if abs(i - n // 2) + abs(j - n // 2) > n // 2:
			print('*', end='')
		else:
			print('D', end='')
	print('')


import sys
input = sys.stdin.readline
n = int(input())
for i in range(n):
	for j in range(n):
		if min(i, n - 1 - i) + min(j, n - 1 - j) < n // 2:
			print('*', end='')
		else:
			print('D', end='')
	print()


n = int(input())
row = ['*'] * n
center = n // 2
for i in range(n):
	new_char = 'D' if i <= center else '*'
	index_to_change = center - min(i, n - i)
	row[index_to_change] = new_char
	index_to_change = center + min(i, n - i)
	row[index_to_change] = new_char
	print(''.join(row))


n = int(input())
for i in range(0, (n - 1) // 2):
	j = 2 * i + 1
	k = (n - j) // 2
	print('*' * k + 'D' * j + '*' * k)
print('D' * n)
for i in range(0, (n - 1) // 2):
	ii = (n - 1) // 2 - i - 1
	j = 2 * ii + 1
	k = (n - j) // 2
	print('*' * k + 'D' * j + '*' * k)


n = int(input())
for i in range(n):
	s = abs(n // 2 - i)
	print(s * '*' + ((n // 2 - s) * 2 + 1) * 'D' + s * '*')


n = int(input())
k = n // 2

def f(d):
	global k
	for i in range(n // 2):
		print('*' * k, end='')
		print('D' * (n - k * 2), end='')
		print('*' * k, end='')
		k += d
		print()
f(-1)
print('D' * n)
k += 1
f(1)


def printstar(n):
	for i in range(n):
		print('*', end='')

def printD(n):
	for i in range(n):
		print('D', end='')

def solve(n):
	half = int((n + 1) / 2)
	for i in range(half):
		printstar(half - i - 1)
		printD(2 * i + 1)
		printstar(half - i - 1)
		print('')
	for i in range(half, n):
		printstar(i - half + 1)
		printD(2 * (n - i) - 1)
		printstar(i - half + 1)
		print('')
n = int(input())
solve(n)


n = int(input())
b = n // 2
for i in range(n):
	val = abs(i - b)
	print('*' * val + 'D' * (n - 2 * val) + '*' * val)


n = int(input())
a = [['*'] * n for i in range(n)]
ind1 = n // 2
ind2 = n // 2 + 1
index = 0
index2 = n - 1
for i in range(1, n + 1, 2):
	a[index][ind1:ind2] = i * 'D'
	a[index2][ind1:ind2] = i * 'D'
	ind1 -= 1
	ind2 += 1
	index += 1
	index2 -= 1
for i in range(n):
	print(*a[i], sep='')


n = int(input())
num_d = 1
for line in range(n):
	num_empty = (n - num_d) // 2
	print('*' * num_empty + 'D' * num_d + '*' * num_empty)
	if line < n // 2:
		num_d += 2
	else:
		num_d -= 2


n = int(input())
for i in range(n // 2 + 1):
	x = 2 * i + 1
	print('*' * (n // 2 - i), end='')
	print('D' * x, end='')
	print('*' * (n // 2 - i))
for i in range(n // 2 - 1, -1, -1):
	x = 2 * i + 1
	print('*' * (n // 2 - i), end='')
	print('D' * x, end='')
	print('*' * (n // 2 - i))


import sys
n = int(input())
num_d = 1
for line in range(n):
	num_empty = int((n - num_d) / 2)
	for i in range(num_empty):
		sys.stdout.write('*')
	for i in range(num_d):
		sys.stdout.write('D')
	for i in range(num_empty):
		sys.stdout.write('*')
	sys.stdout.write('\n')
	if line < int(n / 2):
		num_d += 2
	else:
		num_d -= 2


n = int(input())
for i in range(n):
	for j in range(n):
		if min(i, n - 1 - i) + min(j, n - 1 - j) < n // 2:
			print('*', end='')
		else:
			print('D', end='')
	print()


s = ''
ss = ''
a = []
n = int(input())
for i in range(n):
	s += '*'
	ss += 'D'
l = int(n / 2)
r = int(n / 2)
for i in range(int((n + 1) / 2)):
	z = s[:l] + ss[l:r + 1] + s[r + 1:]
	a.append(z)
	l -= 1
	r += 1
for i in range(1, int(n / 2) + 1):
	a.append(a[int(n / 2) - i])
for i in range(n):
	print(a[i])


n = int(input())
stars = n // 2
d = 1
k = 1
for i in range(n):
	print('*' * stars + 'D' * d + '*' * stars)
	if i == n // 2:
		k = -1
	stars -= 1 * k
	d += 2 * k


n = int(input())
A = []
for i in range(n):
	A += ['*']
B = A
for j in range((n + 1) // 2):
	A[(n - 1 - 2 * j) // 2] = 'D'
	A[(n - 1 + 2 * j) // 2] = 'D'
	for k in range(n):
		print(A[k], end='')
	print()
for j in range((n - 1) // 2, 0, -1):
	A[(n - 1 - 2 * j) // 2] = '*'
	A[(n - 1 + 2 * j) // 2] = '*'
	for k in range(n):
		print(A[k], end='')
	print()


import random

def qsort(l: list):
	if len(l) < 2:
		return l
	rand_num = random.choice(l)
	smaller = [i for i in l if i < rand_num]
	equal = [i for i in l if i == rand_num]
	bigger = [i for i in l if i > rand_num]
	return qsort(smaller) + equal + qsort(bigger)
n = int(input())
k = 1
res = []
for i in range(n):
	s = '*' * int(abs(n - k) / 2) + 'D' * (n - abs(n - k)) + '*' * int(abs(n - k) / 2)
	print(s)
	res += s
	k += 2


n = int(input())
x = int(n / 2)
for i in range(1, n + 1):
	print('*' * x + 'D' * (n - 2 * x) + '*' * x)
	if i <= int(n / 2):
		x -= 1
	else:
		x += 1


n = int(input())
for i in range(n):
	temp = min(i, n - i - 1)
	for j in range(n // 2 - temp):
		print('*', end='')
	for j in range(temp * 2 + 1):
		print('D', end='')
	for j in range(n // 2 - temp):
		print('*', end='')
	print()


n = int(input())
for i in range(1, 2 * n + 1, 2):
	if i < n:
		m = n - i
		p = i
	else:
		m = i - n
		p = i - 2 * m
	if i == n + 1:
		print(n * 'D')
	m = m // 2
	print(m * '*' + p * 'D' + m * '*')


n = list(map(int, input().split()))[0]
for i in range(n):
	if n // 2 > i:
		t = n // 2 - i
	else:
		t = n // 2 - (n - i - 1)
	for j in range(t):
		print('*', end='')
	for j in range(t, n - t):
		(print('D', end=''),)
	for j in range(n - t, n):
		(print('*', end=''),)
	print()


n = int(input())
for i in range(n // 2):
	lr = (n - (i * 2 + 1)) // 2
	print('*' * lr + 'D' * (i * 2 + 1) + '*' * lr)
print('D' * n)
for i in range(n // 2 - 1, -1, -1):
	lr = (n - (i * 2 + 1)) // 2
	print('*' * lr + 'D' * (i * 2 + 1) + '*' * lr)


T_ON = 0
DEBUG_ON = 1
MOD = 998244353

def solve():
	n = read_int()
	A = []
	for i in range(n // 2 + 1):
		a = 2 * i + 1
		b = (n - a) // 2
		A.append('*' * b + 'D' * a + '*' * b)
	A.extend(A[:-1][::-1])
	for x in A:
		print(x)

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def debug(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import math
import os
import sys
from io import BytesIO, IOBase
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')

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

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

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def First():
	print('First')

def Second():
	print('Second')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def fib_to_n(n):
	f = []
	(a, b) = (0, 1)
	while a <= n:
		f.append(a)
		(a, b) = (b, a + b)
	return f

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

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

def is_even(x):
	return x % 2 == 0

def is_odd(x):
	return x % 2 == 1

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i:
			return False
	return True

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P
main()


n = int(input())
for i in range(n):
	d = i
	if i > n // 2:
		d = n - i - 1
	for j in range(n):
		if j >= n // 2 - d and j <= n // 2 + d:
			print('D', end='')
		else:
			print('*', end='')
	print('')


a = int(input())
i = 1
while i <= a:
	print('*' * int((a - i) / 2) + 'D' * i + '*' * int((a - i) / 2))
	i += 2
i = a - 2
while i > 0:
	print('*' * int((a - i) / 2) + 'D' * i + '*' * int((a - i) / 2))
	i -= 2


n = int(input())
result = []
for i in range(n - 2, 0, -2):
	star = '*' * ((n - i) // 2)
	result.append(star + 'D' * i + star)
l = len(result)
for i in range(l):
	print(result[l - i - 1])
print('D' * n)
for i in range(l):
	print(result[i])


from __future__ import print_function
y = input()
x = int(y)
count = 1
side = True
for i in range(x):
	for j in range(int((x - count) / 2)):
		print('*', end='')
	for j in range(count):
		print('D', end='')
	for j in range(int((x - count) / 2)):
		print('*', end='')
	print('')
	if count >= x:
		side = False
	if side:
		count += 2
	else:
		count -= 2


from math import fabs

def f(a):
	return '*' * a + 'D' * (b - 2 * a) + '*' * a
b = int(input())
for i in range(b):
	print(f(int(fabs(i - b // 2))))


n = int(input())
k = n // 2
ans = [['*'] * n for i in range(n)]
i = 0
while k >= 0:
	for j in range(k, n - k):
		ans[i][j] = 'D'
	k -= 1
	i += 1
k = 1
while k <= n // 2:
	for j in range(k, n - k):
		ans[i][j] = 'D'
	k += 1
	i += 1
for i in range(n):
	for j in range(n):
		print(ans[i][j], end='')
	print('')


__author__ = 'gen'
n = int(input())
for i in range(1, n, 2):
	z = int((n - i) / 2)
	print('*' * z + 'D' * i + '*' * z)
print('D' * n)
for i in range(n - 2, 0, -2):
	z = int((n - i) / 2)
	print('*' * z + 'D' * i + '*' * z)


n = int(input())
for i in range(n):
	s = []
	for j in range(n):
		if abs(i - n // 2) + abs(j - n // 2) <= n // 2:
			s += ['D']
		else:
			s += ['*']
	print(''.join(s))


n = int(input())
for i in range(1, n, 2):
	string = (n - i) // 2 * '*' + i * 'D' + (n - i) // 2 * '*'
	print(string)
for i in range(n, 0, -2):
	string = (n - i) // 2 * '*' + i * 'D' + (n - i) // 2 * '*'
	print(string)


n = int(input())
for i in range(1, n + 1, 2):
	for t in range((n - i) // 2):
		print('*', end='')
	for t in range(i):
		print('D', end='')
	for t in range((n - i) // 2):
		print('*', end='')
	print()
for i in range(n - 2, 0, -2):
	for t in range((n - i) // 2):
		print('*', end='')
	for t in range(i):
		print('D', end='')
	for t in range((n - i) // 2):
		print('*', end='')
	print()


n = int(input())
kiri = n // 2 + 1
kanan = n // 2 + 1
for i in range(1, n // 2 + 1):
	for j in range(1, n + 1):
		if kiri <= j and j <= kanan:
			print('D', end='')
		else:
			print('*', end='')
	kiri -= 1
	kanan += 1
	print()
for i in range(n // 2, n):
	for j in range(1, n + 1):
		if kiri <= j and j <= kanan:
			print('D', end='')
		else:
			print('*', end='')
	kiri += 1
	kanan -= 1
	print()


n = int(input())
for i in range(n):
	a = abs(n // 2 - i)
	c = '*' * a
	b = 'D' * (n - 2 * a)
	print(c + b + c)


x = int(input())
a = ['*'] * x
b = []
yu = []
s = (x - 1) // 2
yonax = (x - 1) // 2
n = 1
ni = 2
for t in range(x):
	for p in range(s, s + n):
		a[p] = 'D'
		if t == yonax:
			ni = 3
	b.append(a)
	a = ['*'] * x
	if ni == 2:
		s = s - 1
		n = n + 2
	if ni == 3:
		s = s + 1
		n = n - 2
mensaje = ''
for mari in range(x):
	for m in range(x):
		mensaje = mensaje + b[mari][m]
	yu.append(mensaje)
	mensaje = ''
for rosa in range(x):
	print(yu[rosa])


n = int(input())
a = [['*' for i in range(n)] for i in range(n)]
k = n // 2
m = n // 2 + 1
for i in range(n):
	a[int(n / 2)][i] = 'D'
for i in range(n):
	a[i][int(n / 2)] = 'D'
for i in range(0, n // 2, 1):
	for j in range(k, m, 1):
		a[i][j] = 'D'
	k -= 1
	m += 1
k = n - 2
m = 0
for i in range(n // 2 + 1, n, 1):
	for j in range(k, m, -1):
		a[i][j] = 'D'
	k -= 1
	m += 1
for i in range(len(a)):
	for j in range(len(a)):
		print(a[i][j], end='')
	print()


n = int(input())
lista = []
for i in range(n // 2):
	lista.append('*' * (n // 2 - i) + 'D' * (i * 2 + 1) + '*' * (n // 2 - i))
for i in lista:
	print(i)
print('D' * n)
for i in list(reversed(lista)):
	print(i)


n = int(input())
a = []
b = []
x = n // 2
y = n // 2
for i in range(n):
	a.append('*')
	b.append('D')
a[n // 2] = 'D'
for i in range(n // 2):
	print(''.join(a))
	x -= 1
	y += 1
	a[x] = 'D'
	a[y] = 'D'
print(''.join(b))
x = -1
y = n
for i in range(n // 2):
	x += 1
	y -= 1
	b[x] = '*'
	b[y] = '*'
	print(''.join(b))


n = int(input())
(star, D) = (n - 1, 1)
answer = []
for i in range(int(n / 2)):
	s = '*' * (star // 2) + 'D' * D + '*' * (star // 2)
	print(s)
	answer.append(s)
	star -= 2
	D += 2
print('D' * n)
answer = answer[::-1]
for i in answer:
	print(i)


n = int(input())
stars = n // 2
line = n * 'D'
mines = []
for i in range(1, len(line) // 2 + 1):
	mines.insert(0, i * '*' + line[i:len(line) - i] + i * '*')
for i in range(len(mines)):
	print(mines[i])
print(line)
for i in range(len(mines) - 1, -1, -1):
	print(mines[i])


n = int(input())
l = []
str = ''
for i in range(n // 2 + 1):
	for j in range(1, n // 2 + 1 - i):
		print('*', end='')
		str += '*'
	for k in range(2 * (i + 1) - 1):
		print('D', end='')
		str += 'D'
	for j in range(1, n // 2 + 1 - i):
		print('*', end='')
		str += '*'
	l.append(str)
	str = ''
	print()
l = l[::-1]
for i in range(1, n // 2 + 1):
	print(l[i])


n = int(input())
j = 1
i = n // 2
k = 0
while k < n:
	if k < n // 2:
		print('*' * i + 'D' * j + '*' * i)
		j += 2
		i -= 1
		if j > n:
			j -= 2
			i += 1
	else:
		print('*' * i + 'D' * j + '*' * i)
		j -= 2
		i += 1
	k += 1


n = int(input())
a = n // 2
b = 1
(ac, bc) = (-1, 2)
for i in range(n):
	r = '*' * a + 'D' * b + '*' * a
	print(r)
	a += ac
	b += bc
	if a == 0:
		ac *= -1
		bc *= -1


f = lambda : map(int, input().split())
n = int(input())
(s, h) = (n // 2, (n + 1) // 2)
for i in range(h):
	print('*' * s, end='')
	print('D' * (2 * (i + 1) - 1), end='')
	print('*' * s)
	s -= 1
s = n - 2
for i in range(h - 1):
	print('*' * (i + 1), end='')
	print('D' * s, end='')
	print('*' * (i + 1))
	s -= 2


n = int(input())
half = n // 2
for i in range(0, half + 1):
	print('*' * (half - i) + 'D' * (2 * i + 1) + '*' * (half - i))
end = half + 1
for j in range(1, end):
	print('*' * j + 'D' * (end + half - 2 * j) + '*' * j)


n = int(input())
for i in range(n // 2):
	print('*' * (n // 2 - i), 'D' * (2 * i + 1), '*' * (n // 2 - i), sep='')
print('D' * n)
for i in reversed(range(n // 2)):
	print('*' * (n // 2 - i), 'D' * (2 * i + 1), '*' * (n // 2 - i), sep='')


a = int(input())
mat = []
sat = []
fat = []
rat = []
for i in range(a // 2 + 1):
	for j in range(a):
		if i + j >= a // 2 and i + j <= a // 2 + 2 * i:
			sat.append('D')
		else:
			sat.append('*')
	mat.append(sat)
	sat = []
for i in mat:
	for j in i:
		print(j, end='')
	print()
for i in range(1, a // 2 + 1):
	for j in range(a):
		print(mat[a // 2 - i][j], end='')
	print()


n = int(input())
s = ''
l = n // 2
m = 1
z = l
for i in range(l):
	s = ''
	for j in range(z):
		s += '*'
	for k in range(m):
		s += 'D'
	for j in range(z):
		s += '*'
	m += 2
	z -= 1
	print(s)
s = ''
m = n - 2
z = 1
for i in range(n):
	s += 'D'
print(s)
for i in range(l):
	s = ''
	for j in range(z):
		s += '*'
	for k in range(m):
		s += 'D'
	for j in range(z):
		s += '*'
	z += 1
	m -= 2
	print(s)


n = int(input())
j = n // 2
k = 1
while j > 0:
	print('*' * j + 'D' * k + '*' * j)
	j -= 1
	k += 2
print('D' * n)
J = n - 2
K = 1
while J > 0:
	print('*' * K + 'D' * J + '*' * K)
	J -= 2
	K += 1


def DPR(start, stop, step):
	for i in range(start, stop, step):
		ans = ''
		Dcount = i * 2 + 1
		ans += '*' * ((n - Dcount) // 2)
		ans += 'D' * Dcount
		ans += '*' * ((n - Dcount) // 2)
		print(ans)
n = int(input())
DPR(0, n // 2, 1)
DPR(n // 2, -1, -1)


n = int(input())
seq = []
x = 1
for i in range(n // 2):
	s = 'D' * x
	star = (n - x) // 2
	s = '*' * star + s + '*' * star
	x += 2
	seq.append(s)
for i in range(0, len(seq)):
	print(seq[i])
print('D' * n)
for i in range(len(seq) - 1, -1, -1):
	print(seq[i])


n = int(input())
for i in range(n - n // 2):
	for j in range(n // 2 - i, 0, -1):
		print('*', end='')
	for k in range(1, 2 * i + 2):
		print('D', end='')
	for l in range(n // 2 - i, 0, -1):
		print('*', end='')
	print('')
for i in range(1, n - n // 2):
	for j in range(1, i + 1):
		print('*', end='')
	for k in range(n - 2 * i):
		print('D', end='')
	for l in range(1, i + 1):
		print('*', end='')
	print('')


a = int(input())
c = (a - 1) // 2
for i in range(a):
	if i < a // 2:
		print(c * '*' + (2 * i + 1) * 'D' + c * '*')
		c -= 1
	elif i == a // 2:
		print(a * 'D')
		c = 1
	else:
		print(c * '*' + (2 * (a - i) - 1) * 'D' + c * '*')
		c += 1


def solve(n):
	for i in range(1, n + 1, 2):
		print('*' * ((n - i) // 2) + 'D' * i + '*' * ((n - i) // 2))
	for i in range(n - 2, 0, -2):
		print('*' * ((n - i) // 2) + 'D' * i + '*' * ((n - i) // 2))

def main():
	n = int(input())
	solve(n)
main()


import math
n = int(input())
for i in range(n // 2):
	print('*' * ((n - (2 * i + 1)) // 2) + 'D' * (2 * i + 1) + '*' * ((n - (2 * i + 1)) // 2))
print('D' * n)
for i in reversed(range(n // 2)):
	print('*' * ((n - (2 * i + 1)) // 2) + 'D' * (2 * i + 1) + '*' * ((n - (2 * i + 1)) // 2))


n = int(input())
l = []
c = 1
for i in range(1, n // 2 + 1):
	s = ''
	for j in range((n - c) // 2):
		s += '*'
	for j in range(c):
		s += 'D'
	for j in range((n - c) // 2):
		s += '*'
	c += 2
	l.append(s)
for i in l:
	print(i)
for i in range(n):
	print('D', end='')
print()
l = l[::-1]
for i in l:
	print(i)


n = int(input())
for k in range(n):
	l = abs(n // 2 - k)
	print(l * '*' + ((n // 2 - l) * 2 + 1) * 'D' + l * '*')


def printDiamond(n):
	k = 0
	reverse = False
	mid = n // 2
	for i in range(n):
		for j in range(n):
			if j >= mid - k and j <= mid + k:
				print('D', end='')
			else:
				print('*', end='')
		print()
		if i == mid:
			reverse = True
		if reverse:
			k -= 1
		else:
			k += 1
n = int(input())
printDiamond(n)


n = int(input())
for i in range(n):
	m = n // 2
	if i > m:
		t = i - m
	else:
		t = m - i
	print(t * '*' + (n - t - t) * 'D' + t * '*')


n = int(input())

def printLine(nbEtoile):
	print('*' * nbEtoile + 'D' * (n - 2 * nbEtoile) + '*' * nbEtoile)
for nbEtoile in range(-n // 2 + 1, n // 2 + 1):
	printLine(abs(nbEtoile))


n = int(input())
for y in range(n):
	dy = abs(y - n // 2)
	for x in range(n):
		dx = abs(x - n // 2)
		print('*' if dx + dy > n // 2 else 'D', end='')
	print()


n = int(input())
for x in range(n // 2, 0, -1):
	print('*' * x + 'D' * (n - 2 * x) + '*' * x)
print('D' * n)
for y in range(1, n // 2 + 1):
	print('*' * y + 'D' * (n - 2 * y) + '*' * y)


n = int(input())
c = n // 2 + 1
l = '*'
d = 'D'
for i in range(c):
	print(l * (c - 1 - i) + d * (n - 2 * (c - 1 - i)) + l * (c - 1 - i))
for i in range(c - 2, -1, -1):
	print(l * (c - 1 - i) + d * (n - 2 * (c - 1 - i)) + l * (c - 1 - i))


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
DIRECTIONS = [[0, 1], [0, -1], [1, 0], [1, -1]]
NEIGHBOURS = [(i, j) for i in range(-1, 2) for j in range(-1, 2) if i != 0 or j != 0]
OrdUnicode_a = ord('a')
OrdUnicode_A = ord('A')
CAPS_ALPHABETS = {chr(i + OrdUnicode_A): i for i in range(26)}
SMOL_ALPHABETS = {chr(i + OrdUnicode_a): i for i in range(26)}
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0) + 1
INFINITY = float('inf')
n = int(input())
N = (n + 1) // 2
for i in range(1, n + 1):
	dif = abs(N - i)
	printxsp('*' * dif)
	printxsp('D' * (n - 2 * dif))
	printxsp('*' * dif)
	print()


N = int(input())
D = 1
inc = 2
for i in range(N):
	if i >= N // 2:
		inc = -2
	print('{}{}{}'.format('*' * (N // 2 - D // 2), 'D' * D, '*' * (N // 2 - D // 2)))
	D += inc


n = int(input())
N = range(n)
for i in N:
	print(''.join(('D*'[min(i, n - 1 - i) + min(j, n - 1 - j) < n // 2] for j in N)))


n = int(input())
k = n // 2 + 1
for x in range(1, n // 2 + 1):
	print('*' * (k - x), end='')
	print('D' * (2 * x - 1), end='')
	print('*' * (k - x))
print('D' * n)
for x in range(n // 2, 0, -1):
	print('*' * (k - x), end='')
	print('D' * (2 * x - 1), end='')
	print('*' * (k - x))


import math
n = int(input())
columns = n
rows = n
for i in range(rows):
	for j in range(abs(rows // 2 - i)):
		print('*', end='')
	if i < n // 2 + 1:
		for j in range(i * 2 + 1):
			print('D', end='')
	else:
		for j in range((n - i - 1) * 2 + 1):
			print('D', end='')
	for j in range(abs(rows // 2 - i)):
		print('*', end='')
	print()


import re

def main():
	n = int(input())
	for x in range(n // 2):
		print('{0}{1}{0}'.format('*' * ((n - x * 2) // 2), 'D' * (x * 2 + 1)))
	for x in range(n // 2 + 1):
		print('{0}{1}{0}'.format('*' * x, 'D' * (n - x * 2)))

def __starting_point():
	main()
__starting_point()


n = int(input())
a = [['D'] * n for x in range(n)]
for i in range(n):
	star = abs(n - ((i + 1) * 2 - 1))
	for j in range(star // 2):
		a[i][j] = '*'
		a[i][-j - 1] = '*'
for x in a:
	print(*x, sep='')


q = int(input())

def print_matrix():
	counter = (q - 1) / 2 - 1
	Dn = 1
	for i in range(q):
		for j in range(q):
			if j > counter and j <= counter + Dn:
				print('D', end='')
			else:
				print('*', end='')
		if i >= (q - 1) / 2:
			Dn -= 2
			counter += 1
		else:
			Dn += 2
			counter -= 1
		print()
print_matrix()


n = int(input())
s = []
for i in range(int(n / 2 + 0.5)):
	a = ''
	for j in range(int(n / 2 + 0.5) - i - 1):
		a += '*'
	for j in range(2 * i + 1):
		a += 'D'
	for j in range(int(n / 2 + 0.5) - i - 1):
		a += '*'
	s.append(a)
	print(a)
for i in range(int(n / 2 + 0.5) - 1):
	print(s[int(n / 2 + 0.5) - 2 - i])


n = int(input())
magic = int((n - 1) / 2)
for t in range(magic, -1, -1):
	print(t * '*' + 'D' * (n - 2 * t) + t * '*')
for u in range(1, magic + 1):
	print(u * '*' + 'D' * (n - 2 * u) + u * '*')


n = int(input())
j = -1
first = True
for i in range(1, 1 + n):
	if first:
		j += 2
	else:
		j -= 2
	x = (n - j) // 2
	ans = ''
	for k in range(x):
		ans += '*'
	for k in range(j):
		ans += 'D'
	for k in range(x):
		ans += '*'
	print(ans)
	if j == n:
		first = False


n = int(input())
for i in range(n // 2):
	print('*' * (n // 2 - i) + 'D' * i + 'D' + 'D' * i + '*' * (n // 2 - i))
print('D' * n)
for j in range(n // 2):
	print('*' + '*' * j + 'D' * (n // 2 - j - 1) + 'D' + 'D' * (n // 2 - j - 1) + '*' * j + '*')


n = int(input())
x = n // 2
for i in range(x):
	print(('D' * i).rjust(x, '*') + 'D' + ('D' * i).ljust(x, '*'))
print('D' * n)
for i in range(x):
	print(('D' * (x - 1 - i)).rjust(x, '*') + 'D' + ('D' * (x - 1 - i)).ljust(x, '*'))


a = int(input())
for i in range(-(a // 2), a // 2 + 1):
	for j in range(-(a // 2), a // 2 + 1):
		if abs(i) + abs(j) <= a // 2:
			print('D', end='')
		else:
			print('*', end='')
	print()


n = int(input())
k = int(n / 2) + 1
a = ['*' * k] * k
for i in range(k):
	a[k - 1] = a[k - 1][1:] + 'D'
	a[i] = a[k - 1] + a[k - 1][k - 2::-1]
print('\n'.join(a))
a = a[k - 2::-1]
print('\n'.join(a))


n = int(input())
out = [''] * n
m = 0
for i in range(n // 2):
	for j in range(n):
		out[i] += '*' if j < n // 2 - m or j > n // 2 + m else 'D'
	out[n - i - 1] = out[i]
	m += 1
out[n // 2] = 'D' * n
for i in range(n):
	print(out[i])


x = int(input())
for i in range(-(x // 2), x // 2 + 1):
	print('*' * abs(i) + 'D' * (x - abs(2 * abs(i))) + '*' * abs(i))


n = int(input())
lis = n * [0]
if n == 1:
	print('D')
else:
	for j in range(n):
		if j <= (n - 1) // 2:
			lis[j] = ['*'] * int((n - 1 - 2 * j + 1) / 2) + ['D'] * (2 * j + 1) + ['*'] * int((n - 1 - 2 * j + 1) / 2)
		else:
			lis[j] = ['*'] * int((n - 1 - 2 * (n - 1 - j) + 1) / 2) + ['D'] * (2 * (n - 1 - j) + 1) + ['*'] * int((n - 1 - 2 * (n - 1 - j) + 1) / 2)
		print(''.join(lis[j]))


N = int(input())
string = ['D' for i in range(N)]
matrix = [['*' for i in range(N)]]
matrix[0][N // 2] = 'D'
matrix += [['*'] * N for i in range(N - 1)]
for i in range(1, N):
	for j in range(1, N - 1):
		if matrix[i - 1][j] == 'D' or matrix[i - 1][j - 1] == 'D' or matrix[i - 1][j + 1] == 'D':
			matrix[i][j] = 'D'
for i in matrix[:N // 2]:
	print(''.join(i))
print(''.join(string))
for i in range(N // 2 - 1, -1, -1):
	print(''.join(matrix[i]))


n = int(input())
cur = 1
while cur <= n:
	dots = (n - cur) // 2
	print('*' * dots + 'D' * cur + '*' * dots)
	cur += 2
cur = n - 2
while cur >= 0:
	dots = (n - cur) // 2
	print('*' * dots + 'D' * cur + '*' * dots)
	cur -= 2


n = int(input())
for row in range(n):
	sym = 0
	if row < n - 1 - row:
		sym = row
	else:
		sym = n - 1 - row
	for k in range(int((n - 1) / 2 - sym)):
		print('*', end='')
	for k in range(2 * sym + 1):
		print('D', end='')
	for k in range(int((n - 1) / 2 - sym)):
		print('*', end='')
	print()


n = int(input())
lines = [None] * (n // 2)
for (i, line) in enumerate(lines):
	stars = '*' * (n // 2 - i)
	lines[i] = stars + 'D' * (2 * i + 1) + stars
sh = '\n'.join(lines) + '\n'
print(sh + 'D' * n + sh[::-1])


n = int(input())
increment = 2
d_cnt = 1
for i in range(1, n + 1):
	s_cnt = (n - d_cnt) // 2
	print('*' * s_cnt, end='')
	print('D' * d_cnt, end='')
	print('*' * s_cnt)
	d_cnt += increment
	if d_cnt == n:
		increment *= -1


def ii():
	return int(input())

def ss():
	return [x for x in input()]

def si():
	return [int(x) for x in input().split()]

def mi():
	return map(int, input().split())
a = ii()
s = [['D' for i in range(a)] for i in range(a)]
for i in range(a // 2):
	for x in range(a // 2 - i):
		s[i][x] = '*'
		s[a - i - 1][x] = '*'
		s[i][a - x - 1] = '*'
		s[a - i - 1][a - x - 1] = '*'
for i in s:
	print(''.join(i))


n = int(input())

def c(x):
	return min(n - x, x + 1) * 2 - 1
for i in range(n):
	m = (n - c(i)) // 2
	print('*' * m, end='')
	print('D' * c(i), end='')
	print('*' * m)


n = int(input())
l = []
for i in range(1, n // 2 + 2):
	s = ''
	for x in range(n // 2 + 1 - i):
		s += '*'
	for y in range(i * 2 - 1):
		s += 'D'
	for z in range(n // 2 + 1 - i):
		s += '*'
	l.append(s)
m = l[:len(l) - 1]
m.reverse()
l += m
for j in l:
	print(j)


import sys
import math
import bisect

def main():
	n = int(input())
	A = []
	for i in range(n):
		A.append(['*'] * n)
	cx = (n - 1) // 2
	cy = (n - 1) // 2
	for i in range(n):
		for j in range(n):
			delta = abs(i - cx) + abs(j - cy)
			if delta <= (n - 1) // 2:
				A[i][j] = 'D'
	for i in range(n):
		print(''.join(A[i]))
main()


a = int(input())
b = [['*'] * a for _ in range(a)]
for i in range(int(a / 2) + 1):
	if i == 0:
		b[i][int(a / 2):int(a / 2 + 1)] = (i * 2 + 1) * 'D'
		b[-(i + 1)][int(a / 2):int(a / 2 + 1)] = (i * 2 + 1) * 'D'
	else:
		b[i][int(a / 2 - i):int(a / 2 + i + 1)] = (i * 2 + 1) * 'D'
		b[-(i + 1)][int(a / 2 - i):int(a / 2 + i + 1)] = (i * 2 + 1) * 'D'
for i in b:
	print(*i, sep='')


n = int(input())
arr = list()
for i in range(n):
	arr.append(['*' for i in range(n)])
mid = n // 2
lo = mid
hi = mid
for i in range(n // 2):
	for j in range(lo, hi + 1):
		arr[j][i] = str('D')
	lo = lo - 1
	hi = hi + 1
lo = mid
hi = mid
for i in range(n - 1, n // 2 - 1, -1):
	for j in range(lo, hi + 1):
		arr[j][i] = 'D'
	lo = lo - 1
	hi = hi + 1
for i in arr:
	print(''.join(i))


a = int(input())
l = ['D' * (i * 2 + 1) for i in range(0, a // 2, 1)] + ['D' * a] + ['D' * (i * 2 + 1) for i in range(0, a // 2, 1)][::-1]
for i in l:
	print('*' * ((a - len(i)) // 2), end='')
	print(i, end='')
	print('*' * ((a - len(i)) // 2))


n = int(input())
k = 0
p = 1
t = 0
for i in range(n):
	for j in range(n // 2 - k):
		print('*', end='')
	for j in range(p):
		print('D', end='')
	for j in range(n // 2 - k):
		print('*', end='')
	print(end='\n')
	if p != n and t == 0:
		k += 1
		p += 2
	else:
		t = 1
		k -= 1
		p -= 2


n = int(input())
for i in range(n // 2):
	d = (1 + 2 * i) * 'D'
	print(d.center(n, '*'))
for i in range(n // 2, -1, -1):
	d = (1 + 2 * i) * 'D'
	print(d.center(n, '*'))


n = int(input())
k = 0
c = 1
b = n
for i in range(1, n + 1):
	if i <= (n + 1) // 2:
		k = (n - c) // 2
		print('*' * k + 'D' * (n - 2 * k) + '*' * k)
		c += 2
	else:
		b -= 2
		print('*' * ((n - b) // 2) + 'D' * b + '*' * ((n - b) // 2))


n = int(input()) // 2
l = ['*' * (n - i) + 'D' * (2 * i + 1) + '*' * (n - i) for i in range(n + 1)]
print('\n'.join(l + l[:-1][::-1]))


hat = int(input())
words = []
for i in range(1, (hat + 1) * 2, 2):
	if i == hat:
		center = 'D' * hat
	elif i < hat:
		words.append('*' * int((hat - i) / 2) + 'D' * i + '*' * int((hat - i) / 2))
for i in words:
	print(i)
print(center)
words.reverse()
for i in words:
	print(i)


import sys
input = sys.stdin.readline
n = int(input())
mid = int((n - 1) / 2)
for i in range(mid):
	print('%s%s%s' % ('*' * (mid - i), 'D' * (n - (mid - i) * 2), '*' * (mid - i)))
print('D' * n)
for i in range(mid, n - 1):
	print('%s%s%s' % ('*' * (i - mid + 1), 'D' * (n - (i - mid + 1) * 2), '*' * (i - mid + 1)))


n = int(input())
for i in range(0, n):
	x = abs(n // 2 - i)
	for j in range(0, n):
		if j >= x and j < n - x:
			print('D', end='')
		else:
			print('*', end='')
	print()


T = int(input())
d = 1
bintang = int((T - 1) / 2)
for i in range(1, int((T + 1) / 2) + 1, 1):
	print('*' * bintang + 'D' * d + '*' * bintang)
	d += 2
	bintang -= 1
d = T
for j in range(1, int((T + 1) / 2), 1):
	d -= 2
	print('*' * j + 'D' * d + '*' * j)


n = int(input())
m = []
for i in range(n // 2):
	k = 2 * i + 1
	s = '*' * ((n - k) // 2) + 'D' * k + '*' * ((n - k) // 2)
	print(s)
	m.append(s)
print('D' * n)
for i in m[::-1]:
	print(i)


row = ['*'] * int(input())
for i in range(len(row)):
	(row[len(row) // 2 - min(i, len(row) - i)], row[len(row) // 2 + min(i, len(row) - i)]) = ('D*'[i // ((len(row) + 1) // 2)], 'D*'[i // ((len(row) + 1) // 2)])
	print(''.join(row))


amount = int(input())
for i in range(amount // 2):
	print('*' * (amount // 2 - i), end='')
	print('D' * (i * 2 + 1), end='')
	print('*' * (amount // 2 - i))
print('D' * amount)
for i in range(amount // 2):
	print('*' * (i + 1), end='')
	print('D' * (amount - 2 - i * 2), end='')
	print('*' * (i + 1))


class CodeforcesTask454ASolution:

	def __init__(self):
		self.result = ''
		self.n = 0

	def read_input(self):
		self.n = int(input())

	def process_task(self):
		g = self.n // 2
		p = -1
		x = 0
		result = []
		while x < self.n:
			result.append('*' * g + 'D' * (self.n - 2 * g) + '*' * g)
			g += p
			if not g:
				p = -p
			x += 1
		self.result = '\n'.join(result)

	def get_result(self):
		return self.result
Solution = CodeforcesTask454ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


n = int(input())
k = 1
for i in range(1, n + 1):
	for j in range(1, (n - k) // 2 + 1):
		print('*', end='')
	for l in range(k):
		print('D', end='')
	for j in range(1, (n - k) // 2 + 1):
		print('*', end='')
	if i < n // 2 + 1:
		k += 2
	else:
		k -= 2
	print()


n = int(input())
arr = []
for i in range(n // 2):
	p = 2 * i + 1
	r = (n - p) // 2
	result = '*' * r + 'D' * p + '*' * r
	arr.append(result)
	print(result)
print('D' * n)
arr = arr[::-1]
for item in arr:
	print(item)


a = int(input())

def nor(n):
	for i in range(1, n, 2):
		f = '*' * int((n - i) / 2)
		d = f + 'D' * i + f
		print(d)

def rev(h):
	for i in range(h, 0, -2):
		q = '*' * int((h - i) / 2)
		w = q + 'D' * i + q
		print(w)
nor(a)
rev(a)


from sys import stdin

def ip():
	return [int(i) for i in stdin.readline().split()]

def sp():
	return [str(i) for i in stdin.readline().split()]

def pp(A):
	for i in A:
		print(i)

def pl(A):
	for i in A:
		print(i, end='')
	print()

def solve():
	n = int(input())
	m = int(n // 2)
	A = ['*'] * n
	A[m] = 'D'
	(l, r) = (m, m)
	pl(A)
	for _ in range(m):
		l -= 1
		r += 1
		A[l] = 'D'
		A[r] = 'D'
		pl(A)
	for _ in range(m):
		A[l] = '*'
		A[r] = '*'
		l += 1
		r -= 1
		pl(A)
	return 0
solve()


n = int(input())
add = -1
a = n // 2
for i in range(n):
	if a == -1:
		a = 1
		add *= -1
	print('*' * a + 'D' * (n - a * 2) + '*' * a)
	a += add


import sys
n = int(sys.stdin.readline())

def printLine(x):
	x = (x - 1) * 2 + 1
	for i in range((n - x) // 2):
		print('*', end='')
	for i in range(x):
		print('D', end='')
	for i in range((n - x) // 2):
		print('*', end='')
	print('')
for i in range(n // 2):
	printLine(i + 1)
printLine(n // 2 + 1)
for i in range(n // 2, 0, -1):
	printLine(i)


n = int(input())
lst = ['*'] * n
mid = n // 2
lstn = []
for i in range(mid + 1):
	lst[mid - i:mid + i + 1] = ['D'] * (2 * i + 1)
	lstn.append(''.join(lst))
for j in lstn:
	print(j)
for i in range(2, mid + 2):
	print(lstn[-i])


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
n = qi()
star = n // 2
d = 1
for i in range(n // 2):
	print('*' * star + 'D' * d + '*' * star)
	star -= 1
	d += 2
print('D' * n)
for i in range(n // 2):
	star += 1
	d -= 2
	print('*' * star + 'D' * d + '*' * star)


i = int(input())
j = i // 2
k = i % 2
(s, m, x) = ([], [], [])
for m in range(i // 2 + 1):
	s.append('*' * j + 'D' * k + '*' * j)
	k = k + 2
	j = j - 1
m = s
s = s[:-1]
x = m + s[::-1]
for i in x:
	print(i)


N = int(input())
for i in range(N // 2, N):
	s = ''
	for j in range(N):
		if abs(N // 2 - j) > abs(N // 2 - i):
			s += '*'
		else:
			s += 'D'
	print(s)
for i in range(1, N // 2 + 1):
	s = ''
	for j in range(N):
		if abs(N // 2 - j) > abs(N // 2 - i):
			s += '*'
		else:
			s += 'D'
	print(s)


from sys import stdin, stdout

def romb(n=3):
	k = 1
	back = False
	for i in range(n):
		s = ''
		for j in range(n):
			if j in range(int((n - k) / 2), int((n + k) / 2)):
				s += 'D'
			else:
				s += '*'
			if k == n:
				back = True
		if k != n and (not back):
			k += 2
		else:
			k -= 2
		stdout.write(s + '\n')
n = stdin.readline()
romb(int(n))


t = int(input())
r = 1
uio = 0
for i in range(t):
	e = (t - r) // 2
	for j in range(e):
		print('*', end='')
	for k in range(r):
		print('D', end='')
	for l in range(e):
		print('*', end='')
	if uio == 0:
		r = r + 2
	if r > t:
		uio = 1
		r = t
	if uio == 1:
		r = r - 2
	print()


import math, os, sys
import string, re
import itertools, functools, operator
from collections import Counter

def inputint():
	return int(input())

def inputarray(func=int):
	return map(func, input().split())
n = inputint()
for i in range(n):
	x = abs(n // 2 - i)
	print('*' * x + 'D' * (n - 2 * x) + '*' * x)


n = int(input())
i = 1
k = 0
t = (n + 1) / 2
while i <= n:
	if i <= t:
		k = k + 1
	else:
		k = k - 1
	j = 1
	while j <= n:
		if j >= t + 1 - k and j <= t - 1 + k:
			print('D', end='')
		else:
			print('*', end='')
		j = j + 1
	print()
	i = i + 1


n = int(input())
k = n
l = 1
d = n - 1
j = n - 2
q = []
for i in range(n):
	if k > 0:
		q.append('*' * int((k - 1) / 2) + 'D' * l + '*' * int((k - 1) / 2))
		print('*' * int((k - 1) / 2) + 'D' * l + '*' * int((k - 1) / 2))
		l = l + 2
		k = k - 2
	if k <= 0 and len(q) >= 0:
		q.pop()
		if len(q) > 0:
			print(q[-1])


n = int(input())
a = [['*'] * n for i in range(n)]
k = n // 2
cnt = n // 2 + 1
for i in range(n // 2 + 1):
	for j in range(k, cnt):
		a[i][j] = 'D'
	k -= 1
	cnt += 1
k += 2
cnt -= 2
for i in range(n // 2 + 1, n):
	for j in range(k, cnt):
		a[i][j] = 'D'
	k += 1
	cnt -= 1
for i in range(n):
	for j in range(n):
		print(a[i][j], end='')
	print()


size = int(input())
star = '*'
diamond = 'D'
n = 1
for i in range(size // 2):
	string = star * ((size - n) // 2)
	string += diamond * n
	string += star * ((size - n) // 2)
	n += 2
	print(string)
print(diamond * size)
n = size
for i in range(size // 2):
	n -= 2
	string = star * ((size - n) // 2)
	string += diamond * n
	string += star * ((size - n) // 2)
	print(string)


n = int(input())
k = []
s = ''
a = n - 1
a = a // 2
b = 1
p = n // 2 + 1
for i in range(p):
	for j in range(a):
		s += '*'
	for j in range(b):
		s += 'D'
	for j in range(a):
		s += '*'
	k.append(s)
	s = ''
	b = b + 2
	a = a - 1
s = ''
a = 1
b = n - 2
for i in range(p - 1):
	for j in range(a):
		s += '*'
	for j in range(b):
		s += 'D'
	for j in range(a):
		s += '*'
	k.append(s)
	s = ''
	b = b - 2
	a = a + 1
for i in k:
	print(i)


def prt(H, x):
	for __ in range(H):
		print('*', end='')
	if x:
		print()
N = int(input())
HALF = N // 2
i = 1
for _ in range(HALF):
	prt(HALF, False)
	for __ in range(i):
		print('D', end='')
	prt(HALF, True)
	HALF -= 1
	i += 2
print('D' * N)
HALF = 1
i = N - 2
for _ in range(N // 2):
	prt(HALF, False)
	for __ in range(i):
		print('D', end='')
	prt(HALF, True)
	HALF += 1
	i -= 2


n = int(input())
for i in range(1, n, 2):
	t = n - i
	u = t // 2 * '*'
	v = i * 'D'
	print(str(u) + str(v) + str(u))
for i in range(n, 1, -2):
	t = n - i
	u = t // 2 * '*'
	v = i * 'D'
	print(str(u) + str(v) + str(u))
print(str((n - 1) // 2 * '*') + str('D') + str((n - 1) // 2 * '*'))


n = int(input())
for i in range(1, n + 1, 2):
	print(('D' * i).center(n).replace(' ', '*'))
for i in range(n - 2, 0, -2):
	print(('D' * i).center(n).replace(' ', '*'))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
N = int(input())
A = [['*' for _ in range(N)] for _ in range(N)]
(s, l) = (N // 2, 1)
for r in range(N // 2 + 1):
	for c in range(s, s + l):
		A[r][c] = 'D'
	s -= 1
	l += 2
for r in range(N // 2, N):
	s += 1
	l -= 2
	for c in range(s, s + l):
		A[r][c] = 'D'
for row in A:
	print(''.join(row))


x = int(input())
p = []
q = []
for n in range(x // 2 + 2):
	s = ''
	d = (n + 1) * 2 - 1
	p.append(d)
	if d <= x:
		e = x - d
		f = e // 2
		q.append(f)
		print('*' * f + 'D' * d + '*' * f)
	else:
		p = p[::-1]
		p = p[2:]
		q = q[::-1]
		q = q[1:]
		for w in range(x // 2):
			f = q[w]
			d = p[w]
			print('*' * f + 'D' * d + '*' * f)


n = int(input())
c = 1
for i in range(n // 2 + 1):
	for j in range(i, n // 2):
		print('*', end='')
	for j in range(c):
		print('D', end='')
	for j in range(i, n // 2):
		print('*', end='')
	c = c + 2
	print()
c = c - 4
x = n - (n // 2 + 1)
for i in range(x):
	for j in range(i + 1):
		print('*', end='')
	for j in range(c):
		print('D', end='')
	for j in range(i + 1):
		print('*', end='')
	c = c - 2
	print()


n = int(input())
(d, s) = (1, n // 2)
flag = 0
for i in range(n):
	arr = ''
	arr += '*' * s
	arr += 'D' * d
	arr += '*' * s
	if flag:
		d -= 2
		s += 1
	else:
		d += 2
		s -= 1
	if d == n:
		flag = 1
	print(arr)


n = int(input())
a = ['{:*^{w}}'.format('D' * i, w=n) for i in range(1, n, 2)]
a += ['D' * n] + a[::-1]
print(*a, sep='\n')


n = int(input())
batas_kiri = n // 2
batas_kanan = n // 2
for i in range(n):
	for j in range(n):
		if j >= batas_kiri and j <= batas_kanan:
			print('D', end='')
		else:
			print('*', end='')
	if i < n // 2:
		batas_kiri -= 1
		batas_kanan += 1
	else:
		batas_kiri += 1
		batas_kanan -= 1
	print()


a = int(input())
for i in range((a - 1) // 2):
	print('*' * ((a - 2 * i - 1) // 2) + 'D' * (2 * i + 1) + '*' * ((a - 2 * i - 1) // 2))
print('D' * a)
for i in range((a - 1) // 2 - 1, -1, -1):
	print('*' * ((a - 2 * i - 1) // 2) + 'D' * (2 * i + 1) + '*' * ((a - 2 * i - 1) // 2))


n = int(input())
string = []
c = int(n / 2)
for i in range(c):
	str = '*' * (c - i) + 'D' * (2 * i + 1) + '*' * (c - i)
	print(str)
	string.append(str)
print('D' * n)
string.reverse()
print('\n'.join(string))


def answer():
	n = int(input())
	stars = int(n / 2)
	sp = 1
	i = 0
	while stars > 0:
		print(stars * '*' + sp * 'D' + stars * '*')
		stars -= 1
		sp += 2
	sp = n
	while stars < int(n / 2) + 1:
		print(stars * '*' + sp * 'D' + stars * '*')
		stars += 1
		sp -= 2
answer()


import math
import sys
import string

def ri():
	return input()

def ii():
	return int(input())

def li():
	return input().split()

def mi():
	return list(map(int, input().split()))
n = ii()
for i in range(1, n, 2):
	print(('D' * i).center(n, '*'))
for i in range(n, 0, -2):
	print(('D' * i).center(n, '*'))


n = int(input())
a = []
mid = n // 2
for i in range(n):
	a.append([])
	x = abs(mid - i)
	for j in range(n):
		if j >= x and j <= n - x - 1:
			a[i].append('D')
		else:
			a[i].append('*')
for i in range(n):
	for j in range(n):
		print(a[i][j], end='')
	print(end='\n')


n = int(input())
point = '*' * (n // 2)
d = 'D'
cristal = '{0}{1}{0}'.format(point, d)
print(cristal)
e = n
for i in range(0, e // 2):
	d += 'D' * 2
	point = point.replace('*', '', 1)
	cristal = '{0}{1}{0}'.format(point, d)
	print(cristal)
for z in range(e // 2 + 1, n):
	d = d.replace('D', '', 2)
	point += '*'
	cristal = '{0}{1}{0}'.format(point, d)
	print(cristal)


n = int(input())
n2 = n // 2
s = ''
for i in range(n):
	for j in range(n):
		if abs(n2 - i) <= j <= n - 1 - abs(n2 - i):
			s += 'D'
		else:
			s += '*'
	s += '\n'
print(s)


n = int(input())
a = [f"{'D' * i:*^{n}}" for i in range(1, n, 2)]
print(*a, 'D' * n, *a[::-1], sep='\n')


n = int(input())
d = 0
for i in range(n):
	if i < n // 2:
		print('*' * (n // 2 - i) + 'D' * (2 * i + 1) + '*' * (n // 2 - i))
	elif i == n // 2:
		print('D' * n)
	elif i > n // 2:
		print('*' * (i - n // 2) + 'D' * (n - 2 - 2 * d) + '*' * (n // 2 - (n - i - 1)))
		d += 1


n = int(input())
k = ['*' * (n // 2 - i) + 'D' * (2 * (i + 1) - 1) + '*' * (n // 2 - i) for i in range(0, n // 2 + 1)]
[print(i) for i in k[:len(k)] + k[:len(k) - 1][::-1]]


def main():
	n = int(input())
	lines = []
	for i in range(n // 2 + 1):
		x = 1 + i * 2
		d = (n - x) // 2
		lines.append('*' * d + 'D' * x + '*' * d)
	for i in range(n // 2 + 2, n + 1):
		v = n // 2 - (i - n // 2) + 1
		x = 1 + v * 2
		d = (n - x) // 2
		lines.append('*' * d + 'D' * x + '*' * d)
	for l in lines:
		print(l)
main()


n = int(input())
s = n // 2
b = 0
lst = []
for i in range(1, n + 1):
	if i % 2 != 0:
		v = '*' * (s - b) + 'D' * i + '*' * (s - b)
		b = b + 1
		lst.append(v)
for j in lst:
	print(j)
lst.reverse()
for k in range(1, len(lst)):
	print(lst[k])


num = int(input())
for i in range(1, num // 2 + 1):
	print('*' * (num // 2 + 1 - i) + 'D' * (i * 2 - 1) + '*' * (num // 2 + 1 - i))
print('D' * num)
for j in range(1, num // 2 + 1):
	print('*' * j + 'D' * (num - 2 * j) + '*' * j)


import sys
from math import *

def solve():
	n = int(input())
	k = 1
	for i in range(n // 2):
		m = (n - k) // 2
		print('*' * m + 'D' * k + '*' * m)
		k += 2
	print('D' * n)
	k = n - 2
	for i in range(n // 2):
		m = (n - k) // 2
		print('*' * m + 'D' * k + '*' * m)
		k -= 2
solve()


n = int(input())
temp = 1
flag = 0
for i in range(1, n + 1):
	star = '*' * ((n - temp) // 2)
	diamond = 'D' * temp
	if temp == n:
		flag = 1
	if not flag:
		temp += 2
	else:
		temp -= 2
	print(star + diamond + star)


n = int(input())
s = (n - 1) // 2
L = ['*' * (s - k) + 'D' * (2 * k + 1) + '*' * (s - k) for k in range(s)]
print('\n'.join(L))
print('D' * n)
print('\n'.join(L[::-1]))


import sys
n = int(input())
for i in range(n):
	for j in range(n):
		if i <= n / 2:
			if j < n / 2 - i - 1:
				print('*', end='')
			elif j > n / 2 + i:
				print('*', end='')
			else:
				print('D', end='')
		elif j < i - n / 2:
			print('*', end='')
		elif j > n - (i - n / 2) - 1:
			print('*', end='')
		else:
			print('D', end='')
	print()


n = int(input())
d = 1
j = n // 2
for i in range(1, n + 1):
	print('*' * j, 'D' * d, '*' * j, sep='')
	if i >= n // 2 + 1:
		d -= 2
		j += 1
	else:
		d += 2
		j -= 1


n = int(input())
ls = []
for i in range(n // 2, 0, -1):
	ls.append('*' * i + 'D' * (n - i * 2) + '*' * i)
for x in ls:
	print(x)
print('D' * n)
for x in ls[::-1]:
	print(x)


els = []
i = 0
n = int(input())
for _ in range(n // 2 + 1):
	a = (n - 2 * i - 1) // 2
	el = '*' * a + 'D' * (2 * i + 1) + '*' * a
	i += 1
	els.append(el)
	print(el)
for i in range(len(els) - 2, -1, -1):
	print(els[i])


n = int(input())
pole = [['*' for x in range(n)] for y in range(n)]
sred = n // 2
for i in range(n):
	if i <= sred:
		for j in range(sred - i, sred + 1 + i):
			pole[i][j] = 'D'
	else:
		for j in range(i - sred, n - (i - sred)):
			pole[i][j] = 'D'
for elem in pole:
	print(''.join(elem))


n = int(input())
s = n // 2
d = 1
for i in range(n // 2):
	print(s * '*' + d * 'D' + s * '*')
	s = s - 1
	d = d + 2
print(n * 'D')
s = 1
d = n - 2
for i in range(n // 2, 0, -1):
	print(s * '*' + d * 'D' + s * '*')
	s = s + 1
	d = d - 2


num = int(input())
dCount = 1
asteric = '*'
for i in range(num):
	strCount = num - dCount
	print(int(strCount / 2) * asteric + dCount * 'D' + int(strCount / 2) * asteric)
	if i < int(num / 2):
		dCount += 2
		continue
	dCount -= 2


n = int(input())
d = 1
plus = 2
for i in range(n):
	sides = (n - d) // 2
	print(sides * '*' + d * 'D' + sides * '*')
	d += plus
	if d == n:
		plus = -2


n = int(input())
a = [['*'] * n for _ in range(n)]
for i in range(n):
	for j in range(n):
		if abs(i - n // 2) + abs(j - n // 2) <= n // 2:
			a[i][j] = 'D'
for i in range(n):
	print(''.join(a[i]))


n = int(input())
matrix = []
for i in range(0, n):
	row = []
	if i != int(n / 2):
		for j in range(0, n):
			row.append('*')
	else:
		for j in range(0, n):
			row.append('D')
	matrix.append(row)
for i in range(0, int(n / 2)):
	j = i
	matrix[i][int(n / 2)] = 'D'
	while j != 0:
		matrix[i][int(n / 2) + j] = 'D'
		matrix[i][int(n / 2) - j] = 'D'
		j -= 1
for i in range(0, int(n / 2)):
	matrix[n - 1 - i] = matrix[i]
for row in matrix:
	for x in row:
		print(x, end='')
	print()


n = int(input())
(st, D) = (n - 1, 1)
ans = []
for i in range(int(n / 2)):
	s = '*' * (st // 2) + 'D' * D + '*' * (st // 2)
	print(s)
	ans.append(s)
	st -= 2
	D += 2
print('D' * n)
ans = ans[::-1]
for i in ans:
	print(i)


n = int(input())
for i in range(n):
	p = abs(n // 2 - i)
	print('*' * p, end='')
	print('D' * (n - 2 * p), end='')
	print('*' * p, end='')
	print()


N = int(input())
for i in range(1, N + 1):
	for j in range(abs(int((N + 1) / 2) - i)):
		print('*', end='')
	for k in range(N - 2 * abs(int((N + 1) / 2) - i)):
		print('D', end='')
	for j in range(abs(int((N + 1) / 2) - i)):
		print('*', end='')
	print()


n = int(input())
for i in range(n):
	z = n // 2 - min(i, n - i - 1)
	d = n // 2 - z
	k = '*' * z + 'D' * d
	print(k + 'D' + k[::-1])


def printD(n):
	s = ''
	for i in range(n):
		s += 'D'
	return s

def printStar(n):
	s = ''
	for i in range(n):
		s += '*'
	return s
k = int(input())
for j in range(k // 2 + 1):
	s1 = printStar((k - (j * 2 + 1)) // 2)
	s2 = printD(j * 2 + 1)
	print(s1 + s2 + s1)
for j in range(k // 2 + 1, k):
	p = k - j - 1
	s1 = printStar((k - (p * 2 + 1)) // 2)
	s2 = printD(p * 2 + 1)
	print(s1 + s2 + s1)


n = int(input().strip())
l = ''
k = 1
for i in range(n):
	l = l + '*' * ((n - k) // 2) + 'D' * k + '*' * ((n - k) // 2) + '\n'
	if i < n // 2:
		k += 2
	else:
		k -= 2
print(l)


n = int(input())
for i in range(n // 2):
	a = 2 * i + 1
	out = '*' * ((n - a) // 2) + 'D' * a + '*' * ((n - a) // 2)
	print(out)
print('D' * n)
for i in range(n // 2 - 1, -1, -1):
	a = 2 * i + 1
	out = '*' * ((n - a) // 2) + 'D' * a + '*' * ((n - a) // 2)
	print(out)


def sol():
	n = int(input())
	for i in range(int(n / 2)):
		for j in range(int(n / 2) - int(i), 0, -1):
			print('*', end='')
		for j in range(0, i * 2 + 1):
			print('D', end='')
		for j in range(int(n / 2) - i, 0, -1):
			print('*', end='')
		print()
	for i in range(n):
		print('D', end='')
	print()
	for i in range(int(n / 2)):
		for j in range(i + 1):
			print('*', end='')
		for j in range(0, n - 2 * i - 2):
			print('D', end='')
		for j in range(i + 1):
			print('*', end='')
		print()
sol()


n = int(input())
for i in range(n):
	b = abs(n // 2 - i)
	for j in range(b):
		print('*', end='')
	for j in range(n - b * 2):
		print('D', end='')
	for j in range(b):
		print('*', end='')
	print()


n = int(input())
for x in range(1, n + 2, 2):
	a = 'D' * x
	b = '*' * ((n - x) // 2)
	print(b + a + b)
for x in range(n - 2, -1, -2):
	a = 'D' * x
	b = '*' * ((n - x) // 2)
	print(b + a + b)


a = int(input())
x = y = g = gg = int(1)
ss = q = int(0)
b = w = str('')
while x <= a:
	b = b + '*'
	w = w + 'D'
	x = x + 1
s = t = int((a - 1) / 2)
r = a - 2 * t
while y <= a:
	c = str('')
	c = b[0:s]
	g = g + 1
	if g <= t + 1:
		s = s - 1
	else:
		s = s + 1
	o = w[0:r]
	print(c + o + c)
	gg = gg + 1
	if gg <= int((a + 1) / 2):
		r = r + 2
	else:
		r = r - 2
	y = y + 1


x = int(input())
y = x // 2
z = 1
a = 2
b = 1
c = 0
for i in range(x):
	if y > 0:
		print('*' * y + 'D' * z + '*' * y)
		z += 2
		y -= 1
	elif y == 0 and c == 0:
		print('D' * x)
		c = 1
	else:
		print('*' * (y + b) + 'D' * (z - a) + '*' * (y + b))
		a += 2
		b += 1


def up(n, d):
	for i in range(n):
		print('*', end='')
	for i in range(d):
		print('D', end='')
	for i in range(n):
		print('*', end='')
	print('')
n = int(input())
temp = 1
for i in range(n, 0, -2):
	up(i // 2, temp)
	temp += 2
temp -= 4
for i in range(2, n, 2):
	up(i // 2, temp)
	temp -= 2


def solve(n):
	s = 'D'
	flag = True
	for i in range(n):
		print(s.center(n, '*'))
		if len(s) == n:
			flag = False
		if flag == True:
			s = s + 'DD'
		elif flag == False:
			s = s[1:-1]
n = int(input())
solve(n)


n = int(input())
(i, lst) = (1, [])
while n - i >= 0:
	s = (n - i) // 2
	patt = '*' * s + 'D' * i + '*' * s
	if n != i:
		lst.append(patt)
	print(patt)
	i += 2
lst = lst[::-1]
for i in lst:
	print(i)


n = int(input())
a = []
s = ''
temp = 1
for i in range(n - 1):
	if temp <= n:
		print((n - temp) // 2 * '*' + 'D' * temp + (n - temp) // 2 * '*')
		temp += 2
temp -= 4
for i in range(n - 1):
	if temp > 0:
		print((n - temp) // 2 * '*' + 'D' * temp + (n - temp) // 2 * '*')
		temp -= 2


n = int(input())
(a, b, d) = ((n - 1) // 2, 1, 1)
for i in range(n):
	if a == 0:
		b = -1
	print('*' * a + 'D' * d + '*' * a)
	a -= b
	d += b * 2


n = int(input())
for i in range(n):
	if i <= n // 2:
		a = '*' * abs(n // 2 - i)
		print(a + 'D' * (2 * i + 1) + a)
	else:
		i = n - 1 - i
		a = '*' * abs(n // 2 - i)
		print(a + 'D' * (2 * i + 1) + a)


a = int(input())
for j in range(1, a + 1, 2):
	b = 'D' * j
	print(b.center(a, '*'))
for k in range(a - 2, 0, -2):
	b = 'D' * k
	print(b.center(a, '*'))


n = int(input())
string = ''
x = (n - 1) / 2
x = int(x)
diamond = ''
count = 0
count2 = 0
row = 0
string2 = ''
array = []
while row <= x:
	while count < x:
		string += '*'
		count += 1
	while count2 < 2 * row + 1:
		string2 += 'D'
		count2 += 1
	string = string + string2 + string
	row += 1
	count = row
	count2 = 0
	array.append(string)
	string = ''
	string2 = ''
for i in range(1, x + 1):
	array.append(array[x - i])
for i in range(0, n - 1):
	array[i] = array[i] + '\n'
for item in array:
	diamond += item
print(diamond)


def main():
	n = int(input())
	results = [''] * n
	n_diamonds = 1
	for i in range(n // 2 + 1):
		n_stars = (n - n_diamonds) // 2
		stars = '*' * n_stars
		diamonds = 'D' * n_diamonds
		line = stars + diamonds + stars
		results[i] = results[n - 1 - i] = line
		n_diamonds += 2
	print('\n'.join(results))
main()


from math import ceil as c
n = int(input())
for i in range(1, n + 1):
	if i <= c(n / 2):
		print('*' * abs(c(n / 2) - i) + 'D' * (2 * i - 1) + '*' * abs(c(n / 2) - i))
	else:
		print('*' * abs(c(n / 2) - i) + 'D' * (2 * (n - i) + 1) + '*' * abs(c(n / 2) - i))


n = int(input())
for i in range(n):
	print('*' * abs(n // 2 - i) + 'D' * (n - 2 * abs(n // 2 - i)) + '*' * abs(n // 2 - i))


inp = int(input())
c = 0
Mat = ['' for q in range(inp)]
for i in range(1, inp + 1):
	if i < inp / 2:
		Mat[i - 1] = '*' * int((inp - (2 * i - 1)) / 2) + 'D' * (2 * i - 1) + '*' * int((inp - (2 * i - 1)) / 2)
	elif i == int((inp + 1) / 2):
		Mat[i - 1] = 'D' * inp
	else:
		Mat[i - 1] = Mat[inp - i]
print(*Mat, sep='\n')


n = int(input())
x = 1
w = -1
while x <= n:
	q = int((n + 1) / 2)
	if x <= q:
		w = w + 2
		print('*' * (q - x), 'D' * w, '*' * (q - x), sep='')
	else:
		w = w - 2
		print('*' * (x - q), 'D' * w, '*' * (x - q), sep='')
	x = x + 1


x = int(input())
for i in range(0, x):
	s = abs(x // 2 - i)
	print('*' * s + 'D' * (x - 2 * s) + '*' * s)


n = int(input())
lim = n // 2 + 1
lignes = []
for i in range(1, lim):
	lig = '*' * i + 'D' * (n - 2 * i) + '*' * i
	lignes.append(lig)
for el in lignes[::-1]:
	print(el)
print('D' * n)
for el in lignes:
	print(el)


from math import *
n = int(input())
for i in range(ceil(n / 2)):
	print('*' * (n // 2 - i), end='')
	print('D' * (2 * i + 1), end='')
	print('*' * (n // 2 - i))
for i in range(n // 2 - 1, -1, -1):
	print('*' * (n // 2 - i), end='')
	print('D' * (2 * i + 1), end='')
	print('*' * (n // 2 - i))


def draw(n):
	diamond = []
	for i in range(n // 2 + 1):
		diamond.append('{0:*^{1}}'.format((2 * i + 1) * 'D', n))
	diamond += diamond[n // 2 - 1::-1]
	for i in diamond:
		print(i)

def main():
	n = int(input())
	draw(n)
main()


n = int(input())
for i in range(n):
	num_D = 2 * i + 1
	num_x = (n - num_D) / 2
	if num_D < n:
		print('*' * int(num_x) + 'D' * int(num_D) + '*' * int(num_x))
	elif num_D == n:
		print('D' * int(num_D))
	else:
		nnum_D = 2 * (n - i - 1) + 1
		nnum_x = -num_x
		print('*' * int(nnum_x) + 'D' * int(nnum_D) + '*' * int(nnum_x))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_strList_from_str = lambda : list(sys.stdin.readline().strip())
get_int = lambda : int(sys.stdin.readline().strip())
pt = lambda x: sys.stdout.write(str(x))
n = get_int()
matrix = []
for i in range(n // 2):
	str = '*' * (n // 2 - i) + 'D' * (2 * i + 1) + '*' * (n // 2 - i)
	matrix.append(str)
matrix.append('D' * n)
for j in range(n // 2, -1, -1):
	str = '*' * (n // 2 - j + 1) + 'D' * (2 * j - 1) + '*' * (n // 2 - j + 1)
	matrix.append(str)
for _ in range(n):
	print(matrix[_])


n = int(input())
space = int((n - 1) / 2)
diamond = 1
for j in range(1, n + 1):
	print('*' * space, end='')
	print('D' * diamond, end='')
	print('*' * space, end='')
	print()
	if j <= (n - 1) / 2:
		space -= 1
		diamond += 2
	else:
		space += 1
		diamond -= 2


n = int(input())
t = n // 2
f = n // 2 + 1
s = []
for i in range(1, f + 1):
	s.append('*' * t + (2 * i - 1) * 'D' + '*' * t)
	t -= 1
u = s[::-1]
s += u[1:]
for w in s:
	print(w)


n = int(input())
m = n // 2
l1 = []
for i in range(n):
	l = []
	for j in range(n):
		if j <= m + i and j >= m - i:
			l.append('D')
		else:
			l.append('*')
	l1.append(l)
for i in range(len(l1)):
	if i <= m:
		print(*l1[i], sep='')
	else:
		print(*l1[-i - 1], sep='')


n = int(input())
for i in range(n):
	stars = '*' * (n // 2 - min(i, n - 1 - i))
	ds = 'D' * min(1 + i + i, n + n - i - i - 1)
	print(stars + ds + stars)


n = int(input())
j = n
b = False
for i in range(1, n + 1, 2):
	print(j // 2 * '*' + i * 'D' + j // 2 * '*')
	j -= 2
j = 2
for i in range(n - 2, 0, -2):
	print(j // 2 * '*' + i * 'D' + j // 2 * '*')
	j += 2


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	r = []
	n2 = n // 2 + 1
	for i in range(1, n2 + 1):
		t = '*' * (n2 - i)
		t += 'D' * (i * 2 - 1)
		t += '*' * (n2 - i)
		r.append(t)
	r = r + r[:-1][::-1]
	return '\n'.join(r)
print(main())


N = int(input())
for i in range(N):
	line = ''
	for j in range(N):
		diff = abs(i - N // 2) + abs(j - N // 2)
		if diff <= N // 2:
			line += 'D'
		else:
			line += '*'
	print(line)


n = int(input())
spacing = n // 2
nd = 1
while nd < n:
	row = '*' * spacing + 'D' * nd + '*' * spacing
	print(row)
	spacing -= 1
	nd += 2
print('D' * n)
nd -= 2
spacing += 1
while nd >= 1:
	row = '*' * spacing + 'D' * nd + '*' * spacing
	print(row)
	spacing += 1
	nd += -2


def Cristal(n):
	aux = ['*'] * n
	c = (n - 1) // 2
	m = (n - 1) // 2
	var = 0
	A = []
	for k in range(c):
		var += 1
		for j in range(m, c + var):
			aux[j] = 'D'
		m -= 1
		A.append(aux)
		aux = ['*'] * n
	aux2 = ['D'] * n
	A.append(aux2)
	aux = ['*'] * n
	for k in range(c):
		var -= 1
		for j in range(m + 1, c + var + 1):
			aux[j] = 'D'
		m += 1
		A.append(aux)
		aux = ['*'] * n
	return A
n = int(input())
A = Cristal(n)
for z in range(n):
	c = ''
	for k in range(0, n):
		c += str(A[z][k])
	print(c)


a = int(input())
b = a
h = ''
while a > 0:
	h = ''
	c = a // 2
	d = c
	o = b - c * 2
	while c != 0:
		c = c - 1
		h = h + '*'
	while o != 0:
		o = o - 1
		h = h + 'D'
	while d != 0:
		d = d - 1
		h = h + '*'
	print(h)
	a = a - 2
a = 1
while a < b:
	a = a + 2
	h = ''
	c = a // 2
	d = c
	o = b - c * 2
	while c != 0:
		c = c - 1
		h = h + '*'
	while o != 0:
		o = o - 1
		h = h + 'D'
	while d != 0:
		d = d - 1
		h = h + '*'
	print(h)


n = int(input())
m = n // 2
k = 1
for i in range(n):
	if k < n:
		print('*' * m + 'D' * k + '*' * m)
		m -= 1
		k += 2
k = n
for i in range(n):
	print('*' * m + 'D' * k + '*' * m)
	m += 1
	k -= 2
	if m > n // 2:
		break


n = int(input())
s = ['D' * n]
for i in range(1, 1 + n // 2):
	x = '*' * i + 'D' * (n - i - i) + '*' * i
	s = [x] + s + [x]
print('\n'.join(s))


n = int(input())
m = n // 2 + 1

def printLine(l):
	line = '*' * (m - l) + 'D' * (2 * l - 1) + '*' * (m - l)
	print(line)
for i in range(1, m):
	printLine(i)
for i in range(m, 0, -1):
	printLine(i)


n = int(input())
s = ['D' for i in range(n)]
a = ''.join(s)
d = []
d.append(a)
for i in range(n // 2):
	s[i] = '*'
	s[-i - 1] = '*'
	b = ''.join(s)
	d.append(b)
s = d.copy()
s.remove(a)
d.reverse()
for i in d:
	print(i)
for i in s:
	print(i)


n = int(input())
counter = 3
line = ['*' for x in range(n)]
h = int(n / 2)
line[h] = 'D'
first_line = ''.join(line)
print(first_line)
lim = False
for x in range(n - 2):
	line[h] = 'D'
	c = 1
	for y in range(h):
		y += 1
		if counter > c:
			line[h - y] = line[h + y] = 'D'
			c += 2
		else:
			line[h - y] = line[h + y] = '*'
	if lim:
		counter -= 2
	else:
		counter += 2
	if counter == n:
		lim = True
	print(''.join(line))
print(first_line)


n = int(input())
c = '*' * n
x = 1
mid = False
for i in range(n):
	if i == (n - 1) / 2:
		mid = True
	a = c[:int((n - x) / 2)]
	b = 'D' * x
	print(a + b + a)
	if mid == True:
		x -= 2
	else:
		x += 2


import sys

def outit(x, y):
	t = '*' * x
	d = 'D' * y
	return t + d + t
n = int(sys.stdin.readline())
v = []
i = 1
p = 1
while i <= int(n / 2):
	sd = outit(int((n - p) / 2), p)
	v.append(sd)
	print(sd)
	i += 1
	p += 2
print(outit(0, n))
for i in range(int(n / 2) - 1, -1, -1):
	print(v[i])


n = int(input())
for i in range(-(n // 2), 1 + n // 2):
	i = abs(i)
	(s1, s2) = ('*' * i, 'D' * (n - 2 * i))
	print(s1 + s2 + s1)


n = int(input())
s = ''
for i in range(1, n, 2):
	char = 'D' * i
	s = char.center(n, '*') + '\n' + s
	print(char.center(n, '*'))
print('D' * n)
print(s)


s = 1
n = int(input())
while s <= n:
	print((n - s) // 2 * '*' + s * 'D' + (n - s) // 2 * '*')
	s += 2
s = n - 2
while s > 0:
	print((n - s) // 2 * '*' + s * 'D' + (n - s) // 2 * '*')
	s -= 2


c = int(input())
f = 1
for i in range(1, c + 1, 2):
	for k in range(0, (c + 1) // 2 - f):
		print('*', end='')
	for j in range(i):
		print('D', end='')
	for k in range(0, (c + 1) // 2 - f):
		print('*', end='')
	print()
	f = f + 1
f = 1
for i in range(c - 2, 0, -2):
	for k in range(f):
		print('*', end='')
	for j in range(i):
		print('D', end='')
	for k in range(f):
		print('*', end='')
	print()
	f = f + 1


n = int(input())
a = ''
d = 1
z = n // 2
f = 1
h = n - 2
for i in range(n):
	if i <= n // 2:
		print('*' * z, 'D' * d, '*' * z, sep='')
		d += 2
		z -= 1
	else:
		print('*' * f, 'D' * h, '*' * f, sep='')
		f += 1
		h -= 2


n = int(input())
stars = (n - 1) // 2
diamonds = 1
for i in range(n):
	print('*' * stars + 'D' * diamonds + '*' * stars)
	if i < n // 2:
		stars -= 1
		diamonds += 2
	else:
		stars += 1
		diamonds -= 2


n = int(input())
for i in range(n // 2 + 1):
	if i == n // 2:
		print('D' * n)
	else:
		print('*' * (n // 2 - i), 'D' * (2 * i + 1), '*' * (n // 2 - i), sep='')
for i in range(n // 2, -1, -1):
	if i == n // 2:
		continue
	else:
		print('*' * (n // 2 - i), 'D' * (2 * i + 1), '*' * (n // 2 - i), sep='')


n = int(input())
i = (n + 1) // 2
store = ['D' * n]
for k in range(1, i):
	cur = k * '*' + (n - 2 * k) * 'D' + k * '*'
	store = [cur] + store + [cur]
for i in store:
	print(i)


n = int(input())
for i in range(n // 2):
	kr = 2 * i + 1
	star = (n - kr) // 2
	print('*' * star + 'D' * kr + '*' * star)
print('D' * n)
for i in range(n // 2):
	i += 1
	print('*' * i + 'D' * (n - 2 * i) + '*' * i)


n = int(input())
(firstPart, secondPart) = ('', '')
for i in range(1, n, 2):
	stars = (n - i) // 2 * '*'
	firstPart += stars + i * 'D' + stars + '\n'
	secondPart = stars + i * 'D' + stars + '\n' + secondPart
print(firstPart + 'D' * n + '\n' + secondPart)


n = int(input())
k = 1
flag = True
for i in range(n):
	if k == n:
		print('D' * k)
		flag = False
		k -= 2
		continue
	if flag is False:
		print(('D' * k).center(n, '*'))
		k -= 2
		continue
	print(('D' * k).center(n, '*'))
	k += 2


n = int(input())
for i in range(0, n):
	a = abs(n // 2 - i)
	print('*' * a + 'D' * (n - 2 * a) + '*' * a)


n = int(input())
a = n
aux = n // 2
n = n // 2
D = 1
for i in range(0, n):
	print(aux * '*', D * 'D', aux * '*', sep='')
	D = D + 2
	aux = aux - 1
print(a * 'D')
D = a - 2
aux = 1
for i in range(0, n):
	print(aux * '*', D * 'D', aux * '*', sep='')
	D = D - 2
	aux = aux + 1


n = int(input())
res = []
for i in range(n):
	res.append(['*'] * n)
middle = n // 2
for i in range(n):
	if i <= middle:
		for j in range(middle - i, middle + i + 1):
			res[i][j] = 'D'
	else:
		for j in range(i - middle, n - (i - middle)):
			res[i][j] = 'D'
for i in range(n):
	print(*res[i], sep='')


pr = int(input(''))
sideprint = (pr - 1) / 2
middleprint = 1
for i in range(int(pr / 2)):
	print('*' * int(sideprint) + 'D' * int(middleprint) + '*' * int(sideprint))
	sideprint = sideprint - 1
	middleprint = middleprint + 2
for i in range(int(pr / 2)):
	print('*' * int(sideprint) + 'D' * int(middleprint) + '*' * int(sideprint))
	sideprint = sideprint + 1
	middleprint = middleprint - 2
print('*' * int(sideprint) + 'D' * int(middleprint) + '*' * int(sideprint))


n = int(input())
r = ['*'] * n
a = n // 2
for i in range(a + 1):
	r[a + i] = 'D'
	r[a - i] = 'D'
	print(''.join(map(str, r)))
for i in range(a, 0, -1):
	r[a + i] = '*'
	r[a - i] = '*'
	print(''.join(map(str, r)))


n = int(input())
a = int(n / 2)
b = 1
for i in range(int(n / 2)):
	for j in range(a):
		print('*', end='')
	for j in range(b):
		print('D', end='')
	b = b + 2
	for j in range(a):
		print('*', end='')
	a = a - 1
	print()
for i in range(b):
	print('D', end='')
print()
a = a + 1
b = b - 2
for i in range(int(n / 2)):
	for j in range(a):
		print('*', end='')
	for j in range(b):
		print('D', end='')
	b = b - 2
	for j in range(a):
		print('*', end='')
	a = a + 1
	print()


n = int(input())
t = (n + 1) / 2
for i in range(1, n + 1):
	if i <= t:
		s = int((n - (2 * i - 1)) / 2)
		print('*' * s, end='')
		print('D' * (2 * i - 1), end='')
		print('*' * s)
	else:
		r = int(i - t)
		d = int(n - 2 * r)
		print('*' * r, end='')
		print('D' * d, end='')
		print('*' * r)


n = int(input())
s = []
for i in range(n // 2, -1, -1):
	s.append('*' * i + (n - i * 2) * 'D' + '*' * i)
s += reversed(s[:-1])
for i in s:
	print(i)


import re
from sys import stderr
from typing import Union, Generator, List, Tuple
import string

def main():
	n = int(input())
	print(*('{0:}{1:}{0:}'.format((n - n_d) // 2 * '*', n_d * 'D') for n_d in range(1, n + 1, 2)), sep='\n')
	print(*('{0:}{1:}{0:}'.format((n - n_d) // 2 * '*', n_d * 'D') for n_d in range(n - 2, -1, -2)), sep='\n')
main()


n = int(input())
a = (n - 1) // 2
b = 1
line = ''
for x in range(n):
	for y in range(a):
		line = line + '*'
	for y in range(b):
		line = line + 'D'
	for y in range(a):
		line = line + '*'
	if x < (n - 1) // 2:
		a = a - 1
		b = b + 2
	else:
		a = a + 1
		b = b - 2
	print(line)
	line = ''


n = int(input())
m = []
l = n * ['*']
l[n // 2] = 'D'
p = ''.join(map(str, l))
print(p)
for i in range(1, n // 2 + 1):
	l[n // 2 - i] = 'D'
	l[n // 2 + i] = 'D'
	x = ''.join(map(str, l))
	print(x)
	m.append(x)
m = m[::-1]
for i in range(1, n // 2):
	print(m[i])
print(p)


a = int(input())
k = 0
for i in range(a // 2):
	k += 1
	print('*' * (a // 2 - i), end='')
	print('D' * (k + i), end='')
	print('*' * (a // 2 - i))
print('D' * a)
k = a - 2
r = 0
for i in range(a // 2):
	print('*' * (i + 1), end='')
	print('D' * (k - r), end='')
	print('*' * (i + 1))
	r += 2


n = int(input())
string = 'D'
x = 1
while x < n:
	print(string.center(n, '*'))
	string = string + 'DD'
	x = x + 2
print(string)
while x > 1:
	string = string[:-2]
	print(string.center(n, '*'))
	x = x - 2


n = int(input())
diamond = 1
star = int(n / 2)
limit = int(n / 2) + 1
for i in range(limit):
	diamonds = 'D' * diamond
	starts = '*' * star
	star -= 1
	diamond += 2
	string = starts + diamonds + starts
	print(string)
limit -= 1
diamond = n - 2
star = 1
for i in range(limit):
	diamonds = 'D' * diamond
	starts = '*' * star
	string = starts + diamonds + starts
	print(string)
	star += 1
	diamond -= 2


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
from types import CodeType, new_class
n = int(input())
for x in range((n + 1) // 2):
	print('*' * ((n - x * 2 - 1) // 2) + 'D' * (x * 2 + 1) + '*' * ((n - x * 2 - 1) // 2))
for x in range((n + 1) // 2 - 2, -1, -1):
	print('*' * ((n - x * 2 - 1) // 2) + 'D' * (x * 2 + 1) + '*' * ((n - x * 2 - 1) // 2))


from itertools import chain

def main():
	n = int(input())
	for i in chain(range(1, n, 2), range(n, 0, -2)):
		print('{0:*^{1}}'.format('D' * i, n))
main()


n = int(input())
s = '*' * ((n - 1) // 2)
a = []
for i in range((n + 1) // 2):
	a.append(s + 'D' + s[::-1])
	s = s[1:] + 'D'
print(*a, sep='\n')
print(*a[::-1][1:], sep='\n')


c = int(input())
a = 1
b = c // 2
lst = []
for t in range(c):
	z = '*' * b + 'D' * a + '*' * b
	lst.append(z)
	print(z)
	if a == c:
		break
	b -= 1
	a += 2
y = -2
for a in range(len(lst)):
	print(lst[y])
	if lst[y] == lst[0]:
		break
	y -= 1


from sys import stdin, stdout
input = stdin.readline
n = int(input())
star = n // 2
d = 1
for i in range(n):
	starline = star * '*'
	stdout.write(starline + 'D' * d + starline)
	stdout.write('\n')
	if i < n // 2:
		star -= 1
		d += 2
	else:
		star += 1
		d -= 2


n = int(input())
k = 1
for i in range(n // 2 + 1):
	m = n - k
	for j in range(m // 2):
		print('*', end='')
	for j in range(k):
		print('D', end='')
	for j in range(m // 2):
		print('*', end='')
	print()
	k += 2
k -= 2
for i in range(n // 2):
	k -= 2
	m = n - k
	for j in range(m // 2):
		print('*', end='')
	for j in range(k):
		print('D', end='')
	for j in range(m // 2):
		print('*', end='')
	print()


a = int(input())
b = a // 2
for i in range(1, a + 1):
	if i <= b:
		print('*' * (b - i + 1), end='')
		print('D' * (2 * i - 1), end='')
		print('*' * (b - i + 1))
	elif i == b + 1:
		print('D' * a)
	else:
		print('*' * (i - b - 1), end='')
		print('D' * (a - 2 - 2 * (i - b - 2)), end='')
		print('*' * (i - b - 1))


from itertools import chain
n = int(input())
p = lambda i: '*' * ((n - i + 1) // 2) + 'D' * i + '*' * ((n - i + 1) // 2)
print('\n'.join((p(i) for i in chain(range(1, n + 1, 2), range(n - 2, 0, -2)))))


n = int(input())
s1 = n // 2
d1 = 1
s2 = 1
d2 = n - 2
for i in range(1, n + 1):
	if i < n // 2 + 1:
		print('*' * s1 + 'D' * d1 + '*' * s1)
		s1 = s1 - 1
		d1 = d1 + 2
	elif i == n // 2 + 1:
		print('D' * n)
	elif i > n // 2 + 1:
		print('*' * s2 + 'D' * d2 + '*' * s2)
		s2 = s2 + 1
		d2 = d2 - 2


n = int(input())
a = [['*' for i in range(n)] for i in range(n)]
k = 1
for i in range(0, n // 2 + 1):
	for j in range(n // 2, n // 2 + k):
		a[i][j] = 'D'
	a[i][0:n // 2] = reversed(a[i][n // 2 + 1:n])
	k += 1
k -= 2
for i in range(n // 2 + 1, n):
	for j in range(n // 2, n // 2 + k):
		a[i][j] = 'D'
	a[i][0:n // 2] = reversed(a[i][n // 2 + 1:n])
	k -= 1
for i in a:
	print(''.join(i))


n = int(input())
half = []
d = 1
s = n - 1
while d != n:
	half.append(f"{'*' * (s // 2)}{'D' * d}{'*' * (s // 2)}")
	d += 2
	s -= 2
print(*half, sep='\n')
print('D' * n)
print(*reversed(half), sep='\n')


n = int(input())
t = n // 2
for i in range(n):
	for j in range(n):
		if i + j < t or n - i + j - 1 < t or n - j + i - 1 < t or (2 * n - i - j - 2 < t):
			print('*', end='')
		else:
			print('D', end='')
	print()


a = int(input())
k = 1
for i in range(a // 2):
	print('*' * ((a - k) // 2), 'D' * k, '*' * ((a - k) // 2), sep='')
	k += 2
print('D' * a)
k = a - 2
for i in range(a // 2):
	print('*' * ((a - k) // 2), 'D' * k, '*' * ((a - k) // 2), sep='')
	k -= 2


n = int(input())
for i in range(n):
	if i < n // 2:
		w = (i + 1) * 2 - 1
	else:
		w = (n - i) * 2 - 1
	print('{:*^{width}}'.format('D' * w, width=n))


n = int(input())
d = []
for i in range(1, n + 1, 2):
	l = []
	for j in range(i):
		l.append('D')
	for j in range((n - i) // 2):
		l.insert(0, '*')
		l.append('*')
	r = ''.join(l)
	print(r)
	d.append(r)
for i in range(n // 2 - 1, -1, -1):
	print(d[i])


n = int(input())
mi = n // 2
for i in range(n):
	for j in range(n):
		if i < mi + 1:
			ii = i
		else:
			ii = (n - i - 1) % (mi + 1)
		if mi - ii <= j and mi + ii >= j:
			print('D', end='')
		else:
			print('*', end='')
	print()


n = int(input())
row = 1
flag = False
for i in range(n):
	tmp = (n - row) // 2
	print('*' * tmp + 'D' * row + '*' * tmp)
	if not flag:
		row += 2
	else:
		row -= 2
	if row > n:
		row -= 4
		flag = True


n = int(input())
star = n // 2
while star != 0:
	print('*' * star + 'D' * (n - 2 * star) + '*' * star)
	star -= 1
print('D' * n)
star = 1
while star != n // 2 + 1:
	print('*' * star + 'D' * (n - 2 * star) + '*' * star)
	star += 1


n = int(input())
all = 'D'
for i in range(1, n + 1, 2):
	print((all * i).center(n, '*'))
for i in range(n - 1, 0, -1):
	if i % 2:
		print((all * i).center(n, '*'))


def main():
	n = int(input())
	ans = []
	for i in range(1, n, 2):
		s = (n - i) // 2
		temp = '*' * s + 'D' * i + '*' * s
		ans.append(temp)
	ans.append('D' * n)
	for i in reversed(ans[:-1]):
		ans.append(i)
	for i in ans:
		print(i)
main()


from sys import stdin

def main():
	n = (int(stdin.readline().strip()) + 1) // 2
	for i in range(1, n + 1):
		l = ['*'] * (n - i)
		for j in range(i):
			l.append('D')
		print(''.join(l + l[n - 2::-1]))
	for i in range(n - 1, 0, -1):
		l = ['*'] * (n - i)
		for j in range(i):
			l.append('D')
		print(''.join(l + l[n - 2::-1]))
main()


side = int(input())
halfd = int((side - 1) / 2)
for i in range(halfd):
	printstr = ''
	for j in range(halfd - i):
		printstr = printstr + '*'
	for j in range(i * 2 + 1):
		printstr = printstr + 'D'
	for j in range(halfd - i):
		printstr = printstr + '*'
	print(printstr)
for i in range(halfd + 1):
	printstr = ''
	for j in range(i):
		printstr = printstr + '*'
	for j in range((halfd - i) * 2 + 1):
		printstr = printstr + 'D'
	for j in range(i):
		printstr = printstr + '*'
	print(printstr)


n = int(input())
a = n // 2
for x in range(n):
	l = '*' * n
	m = list(l)
	if x <= a:
		for y in range(x + 1):
			m[a + y] = 'D'
			m[a - y] = 'D'
		print(''.join(m))
	else:
		for y in range(n - x):
			m[a + y] = 'D'
			m[a - y] = 'D'
		print(''.join(m))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	l = [['D'] * n for _ in range(-(-n // 2))]
	a = b = n // 2
	for i in range(-(-n // 2) - 1):
		for j in range(a):
			l[i][j] = '*'
		a -= 1
	for i in range(-(-n // 2) - 1):
		for j in range(b):
			l[i][-(j + 1)] = '*'
		b -= 1
	for x in l:
		print(''.join(x))
	l.reverse()
	for x in l[1:]:
		print(''.join(x))
main()


a = int(input())
l = []
for x in range(1, a + 1, 2):
	s = 'D' * x
	t = (a - x) / 2
	z = '*' * int(t)
	s = z + s + z
	l.append(str(s))
	pass
z = l[0:len(z) - 1]
for x in z:
	print(x)
	pass
print('D' * a)
for x in reversed(z):
	print(x)
	pass


i = int(input())
l = (i + 1) // 2
j = 0
k = i // 2
while j < l:
	print(k * '*' + (2 * j + 1) * 'D' + k * '*')
	k = k - 1
	j = j + 1
k = k + 2
j = j - 2
while j >= 0:
	print(k * '*' + (2 * j + 1) * 'D' + k * '*')
	k = k + 1
	j = j - 1


x = int(input())
m = ['*'] * x
z = 0
while z <= int(x / 2):
	mi = int(x / 2) - z
	n = 0
	while n < z * 2 + 1:
		m[mi] = 'D'
		mi += 1
		n += 1
	f = 0
	while f < len(m):
		print(m[f], end='')
		f += 1
	print('')
	z += 1
h = z
z = x - 2
mi = 1
while h < x:
	m = ['*'] * x
	n = mi
	q = 0
	while q < z:
		m[n] = 'D'
		q += 1
		n += 1
	f = 0
	while f < x:
		print(m[f], end='')
		f += 1
	print('')
	mi += 1
	z -= 2
	h += 1


n = int(input())
k = 1
m = 1
for i in range(n // 2 + 1):
	s = ''
	for j in range((n - k) // 2):
		s += '*'
	for j in range(k):
		s += 'D'
	for j in range((n - k) // 2):
		s += '*'
	k += 2
	print(s)
k -= 4
for i in range(n // 2):
	s = ''
	for j in range((n - k) // 2):
		s += '*'
	for j in range(k):
		s += 'D'
	for j in range((n - k) // 2):
		s += '*'
	k -= 2
	print(s)


def solve(n):
	k = (n + 1) // 2
	xs = [2 * i + 1 for i in range(k)]
	ys = ['D' * n for n in xs + xs[::-1][1:]]
	return [s.center(n, '*') for s in ys]

def main():
	n = int(input())
	result = solve(n)
	for line in result:
		print(line)
main()


N = int(input())
M = N
k = 1
while True:
	for i in range((N - 1) // 2):
		d = (N - 1) // 2
		print('*' * d + 'D' * k + '*' * d)
		N -= 2
		k += 2
		d -= 2
	d += 2
	k -= 2
	print('D' * M)
	for i in range((M - 1) // 2):
		print('*' * d + 'D' * k + '*' * d)
		M += 2
		k -= 2
		d += 1
	break


def solve():
	n = int(input())
	score = n // 2
	lst = []
	for i in range(score, -1, -1):
		string = '*' * i + 'D' * (n - 2 * i) + '*' * i
		lst.append(string)
	for j in lst:
		print(j)
	for (index, k) in enumerate(lst[::-1]):
		if index == 0:
			continue
		print(k)
solve()


a = int(input())
for i in range(a // 2 + 1):
	p = ''
	for j in range(a // 2 - i):
		p = p + '*'
	for k in range(2 * i + 1):
		p = p + 'D'
	for l in range(a // 2 - i):
		p = p + '*'
	print(p)
for i in range(a // 2 - 1, -1, -1):
	p = ''
	for l in range(a // 2 - i):
		p = p + '*'
	for k in range(2 * i + 1):
		p = p + 'D'
	for j in range(a // 2 - i):
		p = p + '*'
	print(p)


z = int(input())
s = 'D'
for i in range((z + 1) // 2):
	print('*' * (z // 2 - i) + s + '*' * (z // 2 - i))
	s = s + 'DD'
s = s.join(s.split())[:-2]
for i in reversed(range((z + 1) // 2 - 1)):
	s = s.join(s.split())[:-2]
	print('*' * (z // 2 - i) + s + '*' * (z // 2 - i))


height = int(input())
diamonds_on_line = 1
while diamonds_on_line != height:
	print((height - diamonds_on_line) // 2 * '*' + diamonds_on_line * 'D' + (height - diamonds_on_line) // 2 * '*')
	diamonds_on_line += 2
print(diamonds_on_line * 'D')
while diamonds_on_line != 1:
	diamonds_on_line -= 2
	print((height - diamonds_on_line) // 2 * '*' + diamonds_on_line * 'D' + (height - diamonds_on_line) // 2 * '*')


n = int(input())
cristal = []
for i in range(n // 2):
	cristal.append(['*'] * n)
	for j in range(n // 2 - i, n - (n // 2 - i)):
		cristal[i][j] = 'D'
cristal.append(['D'] * n)
for i in range(n // 2 - 1, -1, -1):
	cristal.append(cristal[i])
for i in range(n):
	print(*cristal[i], sep='')


n = int(input())
nn = n // 2
for i in range(n):
	if i <= nn:
		m = (i + 1) * 2 - 1
		lr = (n - m) // 2
	else:
		m = (n - i) * 2 - 1
		lr = (n - m) // 2
	print(lr * '*' + m * 'D' + lr * '*')


n = int(input())
for i in range(n):
	l = ['*'] * n
	for j in range(abs(n // 2 - i), n - abs(n // 2 - i)):
		l[j] = 'D'
	print(*l, sep='')


n = int(input())
S = []
kr = 1
l = 0
for i in range(n // 2):
	S = ['*' for i in range(n // 2 - l)]
	S1 = ['D' for i in range(kr)]
	l = l + 1
	kr = kr + 2
	print(''.join(S) + ''.join(S1) + ''.join(S))
S = ['D' for i in range(n)]
print(''.join(S))
l = l - 1
kr = kr - 2
for i in range(n // 2):
	S = ['*' for i in range(n // 2 - l)]
	S1 = ['D' for i in range(kr)]
	l = l - 1
	kr = kr - 2
	print(''.join(S) + ''.join(S1) + ''.join(S))


from math import ceil
n = int(input())
rows = []
for i in range(ceil(n / 2)):
	row = '{b}{c}{b}'.format(b='*' * (ceil(n / 2) - i - 1), c='D' * (1 + 2 * i))
	rows.append(row)
for row in rows:
	print(row)
for row in rows[::-1][1:]:
	print(row)


def romb(n):
	final_list = []
	m_l = []
	for i in range(n):
		m_l.append('*')
	mid = len(m_l) // 2
	reached_first = False
	k = 0
	for i in range(n):
		if len(m_l) - 1 >= i + mid and (not reached_first):
			m_l[i + mid] = 'D'
			m_l[mid - i] = 'D'
			final_list.append(''.join(m_l))
		if len(m_l) - 1 < i + mid:
			reached_first = True
		if reached_first:
			m_l[-1 - k] = '*'
			m_l[0 + k] = '*'
			k += 1
			final_list.append(''.join(m_l))
	return '\n'.join(final_list)

def main_function():
	n = int(input())
	return romb(n)
print(main_function())


n = int(input())
for i in range(1 + n // 2):
	num_D = 1 + i * 2
	num_ast = (n - num_D) // 2
	str_d = ''.join(['*'] * num_ast + ['D'] * num_D + ['*'] * num_ast)
	print(str_d)
for i in range(n // 2):
	num_D = n - (i + 1) * 2
	num_ast = (n - num_D) // 2
	str_d = ''.join(['*'] * num_ast + ['D'] * num_D + ['*'] * num_ast)
	print(str_d)


m = int(input())
list = []
for i in range(0, m // 2):
	res = 'D' * (1 + 2 * i)
	res = res.center(m, '*')
	list.append(res)
list.append('D' * m)
for i in list:
	print(i)
for i in range(len(list) - 2, -1, -1):
	print(list[i])


n = int(input())
a = []
for i in range(n // 2 + 1):
	v = []
	for j in range(n // 2 - i):
		v.append('*')
	for j in range(i):
		v.append('D')
	v.append('D')
	for j in range(i):
		v.append('D')
	for j in range(n // 2 - i):
		v.append('*')
	a.append(v)
b = a.copy()
b.reverse()
for i in range(1, len(a)):
	a.append(b[i])
for i in a:
	print(''.join(i))


import math
n = int(input())
for i in range(1, math.ceil(n / 2) + 1):
	for j in range(abs(math.ceil(n / 2) - i)):
		print('*', end='')
	for j in range(1, 2 * i):
		print('D', end='')
	for j in range(abs(math.ceil(n / 2) - i)):
		print('*', end='')
	print()
for i in range(1, math.ceil(n / 2)):
	for j in range(1, i + 1):
		print('*', end='')
	for j in range(1, 2 * (math.ceil(n / 2) - i)):
		print('D', end='')
	for j in range(1, i + 1):
		print('*', end='')
	print()


i = int(input())
line = 1
diamonds = 1
stars = (i - diamonds) // 2
while line <= i:
	if line <= i // 2:
		print('*' * stars + 'D' * diamonds + '*' * stars)
		line += 1
		diamonds += 2
		stars -= 1
	if line == i // 2 + 1:
		print('D' * i)
		line += 1
		diamonds -= 2
		stars += 1
	if line >= i // 2 + 2:
		print('*' * stars + 'D' * diamonds + '*' * stars)
		line += 1
		diamonds -= 2
		stars += 1


x = int(input())
add = int(x / 2)
for i in range(x):
	for j in range(x):
		a1 = i - add
		b2 = j - add
		if abs(a1) + abs(b2) <= add:
			print('D', end='')
		else:
			print('*', end='')
	print()


n = int(input())
for shard in range(-n + 1, n, 2):
	print('{0:*^{1}}'.format('D' * (n - abs(shard)), n))


def main():
	n = int(input())
	for i in range(int(n / 2)):
		print('*' * int((n - (2 * i + 1)) / 2) + 'D' * int(2 * i + 1) + '*' * int((n - (2 * i + 1)) / 2))
	print('D' * n)
	for i in list(reversed(range(int(n / 2)))):
		print('*' * int((n - (2 * i + 1)) / 2) + 'D' * int(2 * i + 1) + '*' * int((n - (2 * i + 1)) / 2))
main()


n = int(input())
for i in range(n):
	buf = abs((n - 1) // 2 - i)
	other = n - 2 * buf
	print('*' * buf + 'D' * other + '*' * buf)


n = int(input())
x = n // 2
y = n // 2
s = ''
for i in range(n):
	for j in range(n):
		if x <= j <= y:
			s = s + 'D'
		else:
			s = s + '*'
	s = s + '\n'
	if i < n // 2:
		x -= 1
		y += 1
	else:
		x += 1
		y -= 1
print(s)


n = int(input())
for i in range(n):
	c = n // 2
	k = c - abs(i - c)
	l = c - k
	r = c + k
	for j in range(n):
		if j >= l and j <= r:
			print('D', end='')
		else:
			print('*', end='')
	print('')


n = int(input())
for i in range(n):
	for ii in range(n):
		if min(ii, n - ii - 1) >= abs(n // 2 - i):
			print('D', end='')
		else:
			print('*', end='')
	print()


import sys

def createEmpty(n):
	return [['*' for i in range(n)] for x in range(n)]

def printDiamond(diamond):
	print('\n'.join([''.join(row) for row in diamond]))

def createDiamond(diamond):
	n = len(diamond)
	center = int(n / 2)
	for x in range(n):
		for y in range(n):
			xdist = abs(x - center)
			ydist = abs(y - center)
			if xdist <= center - ydist:
				diamond[x][y] = 'D'
n = int(sys.stdin.readline())
diamond = createEmpty(n)
createDiamond(diamond)
printDiamond(diamond)


n = int(input())
if n > 1 and n % 2 == 1:
	for low in range(n // 2 + 1):
		print('*' * ((n - low * 2) // 2) + 'D' * (2 * low + 1) + '*' * ((n - low * 2) // 2))
	for low in range(n // 2):
		print('*' * (low + 1) + 'D' * (n - low * 2 - 2) + '*' * (low + 1))
else:
	pass


n = int(input())
a = n // 2
c = 0
for i in range(n // 2 + 1):
	for j in range(0, a):
		print('*', end='')
	for k in range(0, c + 1):
		print('D', end='')
	c = c + 2
	for j in range(0, a):
		print('*', end='')
	print()
	a = a - 1
c = n - 2
b = 1
for i in range(n // 2):
	for j in range(0, b):
		print('*', end='')
	for k in range(0, c):
		print('D', end='')
	c = c - 2
	for j in range(0, b):
		print('*', end='')
	print()
	b = b + 1


n = int(input())
a = ['{0}{1}{0}'.format('*' * ((n - i) // 2), 'D' * i) for i in range(1, n, 2)]
[print(i) for i in a]
print('D' * len(a[0]))
[print(i) for i in reversed(a)]


n = int(input())
print('\n'.join(('*' * abs(i) + 'D' * (n - 2 * abs(i)) + '*' * abs(i) for i in range(-(n // 2), n // 2 + 1))))
exit()
s = input()
if len(s) > 2:
	s = s[-2:]
n = int(s)
print((1 + 2 ** n + 3 ** n + 4 ** n) % 5)
exit()
n = int(input())
for i in range(n):
	(x, y) = map(int, input().split())
	if x != y:
		print('Happy Alex')
		exit()
print('Poor Alex')


num = int(input())
s = num // 2
for i in range(num):
	if i > num // 2:
		if s < 0:
			s = 0
		s += 1
		print('*' * s + 'D' * (num - 2 * s) + '*' * s)
	else:
		print('*' * s + 'D' * (num - 2 * s) + '*' * s)
		s -= 1


n = int(input())
cnt = 1
for i in range(n):
	stars = (n - cnt) // 2
	answ = '*' * stars + 'D' * cnt + '*' * stars
	print(answ)
	if i >= n // 2:
		cnt -= 2
	else:
		cnt += 2


size = int(input())
star = '*'
D = 'D'
num = 1
for i in range(size // 2):
	string = star * ((size - num) // 2)
	string += D * num
	string += star * ((size - num) // 2)
	num += 2
	print(string)
print(D * size)
num = size
for i in range(size // 2):
	num -= 2
	string = star * ((size - num) // 2)
	string += D * num
	string += star * ((size - num) // 2)
	print(string)


n = int(input())
j = 1
mid = False
for i in range(n):
	if i == (n - 1) // 2:
		mid = True
	a = '*' * ((n - j) // 2)
	d = 'D' * j
	print(a, d, a, sep='')
	if mid:
		j -= 2
	else:
		j += 2


def main():
	n = int(input())
	start = n // 2
	rows = []
	while start >= 0:
		row = '*' * start
		row += 'D' * (n - 2 * start)
		row += '*' * start
		start -= 1
		rows.append(row)
	for e in rows:
		print(e)
	for e in reversed(rows[:-1]):
		print(e)
main()