peterverebics/CodeNet_Python_118 huggingface dataset:
t = list(input())
for i in range(len(t)):
    if t[i] == "?":
        t[i] = "D"

print("".join(t))
t = str(input())
a = []
cnt = 0
show = 0
for i in range(len(t)):
    if t[i] == '?':
        a.append('D')
    else:
        a.append(t[i])
print("".join(a))
p=list(input())
ans=''
for i in p:
    if i=='P':
        ans+='P'
    else:
        ans+='D'
print(ans)
s=input()
l=[i for i in s]
for i in range(len(s)):
	if(s[i]=='?'):
		l[i]='D'
for i in l:
	print(i,end="")
print()
S = list(input())
i=0
while i<len(S):
    if S[i]=="?":
        S[i]="D"
    i+=1
print("".join(S))
t=input()
qn=t.count("?")
print(t.replace("?", "D"))
s = input()
s = s.replace('?', 'D')
print(s)
l = list(input())
n = len(l)

ans = 0
for i in reversed(range(n)):
    if l[i] == '?':
        if not i==0:
            if l[i-1]=="P":
                l[i] = "D"
                continue
        if not i==n-1:
            if l[i+1] == "D":
                l[i] = "P"
                continue
        l[i] = "D"
        
print("".join(l))
# -*- coding: utf-8 -*-

t = input()
print(t.replace('?', 'D'))
t = input()

s = t.replace("?", "D")

print(s, end="")
s = list(input())
for i in range(len(s)):
    if s[i] == "?":
        s[i] = "D"
print("".join(s))
t=input()
ans=""
for i in range(len(t)):
    if t[i]=="?":
        ans+="D"
    else:
        ans+=t[i]
print(ans)
T = input()

for i, v in enumerate(T):
    if v == '?':
        print('D', end='')
    else:
        print(v, end='')
print('\n')
S = list(input())
for i in range(len(S)):
    if S[i] == "?":
        S[i] = "D"
print("".join(S))
str_list = list(input())

for i in range(len(str_list)):
	if(str_list[i] == "?"):
		str_list[i] = "D"
o_str = "".join(str_list)
print(o_str)
import math

char = str(input())

char = char.replace('?','D')
  

print(char)
N = list(input())
for i,a in enumerate(N):
    if a == "?":
        N[i] = "D"
print(''.join(N[0:len(N)]))
T = input()

ans = T.replace('?', 'D')

print(ans)
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  #空白あり
def LS2(): return list(sys.stdin.readline().rstrip())  #空白なし

T = LS2()

for i in range(len(T)):
    if T[i] == '?':
        T[i] = 'D'

ans = ''
for i in range(len(T)):
    ans += T[i]

print(ans)
T = list(input()) 
ans = []
for i in T:
    if i == "?":
        ans.append("D")
    else:
        ans.append(i)
print("".join(ans))
t = input()
n = len(t)

print(t.replace('?', 'D'))
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    T = rl().rstrip()
    
    ans = []
    for ti in T:
        if ti == '?':
            ans.append('D')
        else:
            ans.append(ti)
    print(''.join(ans))


if __name__ == '__main__':
    solve()
T = input()
T = T.replace('?', 'D')

print(T)
a = ['D' if i == '?' else i for i in input()]
print("".join(a))
T = list(input())
for i in range(len(T)):
  if T[i] == '?':
    T[i] = 'D'
print(''.join(T))
S=str(input())
S=S.replace('?', 'D')
print(S)
from collections import deque

def main():
    T = input()
    d = deque(T)
    ans = deque()
    nxt = ""
    cnt = 0

    while d:
        now = d.pop()
        if now == "?":
            now = "D"
        ans.appendleft(now)

    print("".join(ans))
    

if __name__ == "__main__":
    main()
import math
import sys
input = sys.stdin.readline

s = input().strip()
ans = []
for i in s:
	if i == '?':
		ans.append('D')
	else:
		ans.append(i)
print(''.join(ans))
import sys,collections

t = sys.stdin.readline().rstrip()
print(t.replace('?','D'))
T=input()
u=T.translate(str.maketrans({'?': 'D'}))
print(u)
s = input()
n = len(s)

s = s.replace('?','D')
print(s)
T = str(input())

T = T.replace('P?','PD')
T = T.replace('?','D')

print(T)
s = list(str(input()))
c = ""
for i in range(len(s)):
    if s[i] == "?":
        s[i] = "D"
for i in range(len(s)):
    c += s[i]
print(c)
import sys
input = sys.stdin.readline

t=input()


ans=[]
for i in range(len(t)):
    if t[i]== "?":
        ans.append("D")
    else:
        ans.append(t[i])

for i in range(len(ans)):
    print(ans[i], end="")
base_txt = input()
base_txt_to_P = base_txt.replace("?","P")
base_txt_to_D = base_txt.replace("?","D")
index_count_base_txt_to_P = base_txt_to_P.count("D") + base_txt_to_P.count("PD")
index_count_base_txt_to_D = base_txt_to_D.count("D") + base_txt_to_D.count("PD")
if index_count_base_txt_to_P >index_count_base_txt_to_D:
    print(base_txt_to_P)
else:
    print(base_txt_to_D)
s = list(str(input()))
for i in range(len(s)):
    if s[i] == '?':
        s[i] = 'D'
print(''.join(s))
T = list(input())

if len(T) == 1:
    print('D')
    exit()

if T[0] == '?':
    if T[1] == 'P':
        T[0] = 'D'
    else:
        T[0] = 'P'


for i in range(1, len(T)-1):
    if T[i] == '?':
        if T[i - 1] == 'D' and (T[i + 1] == 'D' or T[i + 1] == '?'):
            T[i] = 'P'
        else:
            T[i] = 'D'

if T[-1] == '?':
    T[-1] = 'D'

print(''.join(T))
S = str(input())
v_list = list()

#print(S)

SS = S.replace("?", "D")
print(SS)
t=input()
t=t.replace("?", "D")
print(t)
t = input()
s = t.replace('?', 'D')
print(s)
t = str(input())

ans = t.replace('?', 'D')

print(ans)
t = input()

t = t.replace('?','D')

c = t.count('D')
c += t.count('PD')

print(t)
s = list(input())
k = len(s)
for i in range(k):
  if s[i] == '?':
    s[i] = 'D'
A = "".join(s)
print(A)
s=list(input())

for i in range(len(s)):
    if s[i]=='?':
        s[i]='D'

L=[str(a) for a in s]
L="".join(L)
print(L)
def main():
    T = input()
    
    T = T.replace('?', 'D')

    # cnt = 0

    # cnt_pd = t.count('PD')
    # cnt_d = t.count('D')
            
    # cnt = cnt_d + cnt_pd
    print(T)
main()
T=input()

res = ""
for i in range(len(T)) :
    if (T[i] != "?") :
        res += T[i]
        continue
    res += "D"

    # if (i != 0) :
    #     if (T[i-1] == "P") :
    #         res += "D"
    #     else :
    #         res += "D"

print(res)
s = input()

for i in range(len(s)):
    if s[i] == "?":
        print("D",end="")
    else:
        print(s[i],end="")
def solve():
  T = input()
  ans = T.replace('?','D')
  return ans
print(solve())
t = input().strip()

ans = t.replace('?', 'D')
print(ans)
import sys
def S(): return sys.stdin.readline().rstrip()
print(S().replace('?','D'))
t = input()
ans = t.replace('?', 'D')
print(ans)
t = input()
ts = t.replace('?', 'D')
print(ts)
N = input()
LISTSTR = list(N)

ans = ''
for i in range(len(LISTSTR)):
    mae = ''
    if i != 0:
        mae = ans[-1]
    str = LISTSTR[i]


    if str != '?':
        ans += str
    elif mae == '?':
        ans += 'D'
    else:
        ans += 'D'


if len(LISTSTR) == 1:
    ans = 'D'



print(ans)
T=list(input())
l=len(T)
S=[]
for i in range(l-1):
  if T[i]=="P" or T[i]=="D":
    S.append(T[i])
  if T[i]=="?":
    S.append("D")
      
if T[l-1]=="P" or T[l-1]=="D":
  S.append(T[l-1])
if T[l-1]=="?":
  S.append("D")

P=''.join(S)
print(P)
T = str(input())
ans = ''
for t in T:
    if t != '?':
        ans += t
    else:
        ans += 'D'
print(ans)
s = input()
n = len(s)
ans = ""
for i in range(n):
  if s[i] == "?":
    ans += "D"
  else:
    ans += s[i]
print(ans)
t = input()
ans = ''

for i in range(len(t)):
    if t[i] == '?':
        ans += 'D'
    else:
        ans += t[i]

print(ans)
t = str(input())
t_bara = list(t)

for i in range(len(t_bara)):
    if t_bara[i] == "?":
        t_bara[i]= t_bara[i].replace("?","D")

print(''.join(t_bara))
# -*- coding: utf-8 -*-

T = list(input())

for i in range(len(T)):
  if T[i]=='?':
    T[i] = 'D'

print(''.join(T))
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt
import math

import bisect
import re
import heapq


from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

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


yes = "Yes"
no = "No"


def main():
    t = list(input())
    n = len(t)
    for i in range(n):
        if t[i] == '?':
            t[i] = 'D'
    print(''.join(t))



main()
import collections
a=input()
b=a.replace('?','D')
print(b)
s = input().strip()
ans=""
for char in s:
    if char=="?":
        ans+="D"
    else:
        ans+=char
print(ans)
t = input()

for c in t:
  if c == '?':
    c = 'D'
  print(c,end= '')
print()
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    T = input()
    res = [c if c != '?' else 'D' for c in T]
    print(''.join(res))
resolve()
import sys
import math
from collections import deque
from collections import defaultdict

def main():
    s = list(input())
    for x in range(len(s)):
        if s[x] == '?':
            s[x] = 'D'
    print(''.join(s))
    return 0

if __name__ == "__main__":
    main()
def main ():
  return input().replace('?', 'D')

print(main())
# Problem B - Postdocs

# input
T = list(input())
T_len = len(T)

# swap
for i in range(T_len):
    if T[i]=='?':
        T[i] = 'D'

# output
print("".join(T))
T=input()
T_rep=T.replace("?","D")
print(T_rep)
paramT = input()
paramReplaced = paramT.replace('?', 'D')
print(paramReplaced)
print(''.join([x if x != '?' else 'D' for x in input()]))
t=input()
t=t.replace("?","D")
cd=t.count("D")
cdp=t.count("PD")
# print(cd+cdp)
print(t)
import math

s = list(input()[::-1])

for i in range(len(s)):
    if s[i] == "?":
        s[i] = "D"

print("".join(s[::-1]))
i=input()
for c in i:
  if c=='?':
    print("D",end="")
  else:
    print(c,end="")
T=input()
t=[]
for i in T:
    t.append(i)
n=len(t)
for i in range(n):
    if t[i]=="?":
        t[i]="D"
for i in t:
    print(i,end="")
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

T = input()
T = T.replace("?", "D")
print(T)
t = input()

ans = ""

for i in range(len(t)):
    if t[i] != '?':
        ans += t[i]
    else:
        ans += 'D'
        
print(ans)
s = input()
s_len = len(s)
li = [0]*s_len
for i in range(s_len):
    if s[i] == "?":
        li[i] = "D"
    else:
        li[i] = s[i]
print("".join(li))
T = input()

t = ""
for i in range(len(T)):
    if (T[i] == "?"):
        t += "D"
    else:
        t += T[i]
    

print(t)
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

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

print(s_in().replace("?","D"))
#print(s.count("D")+s.count("PD"))
#!/usr/bin/env python3

t = list(str(input()))

t_new = []
for i in t:
    if i == "?":
        t_new.append("D")
    else:
        t_new.append(i)

for i in t_new:
    print(i, end="")
# ans = 0
# for i in range(n):
#     if t_new[i] == D:
#         ans += 1

# for i in range(1, n):
#     if t_new[i-1] == P and t_new[i] == D:
#         ans += 1
# print(ans)
text = input()
data = []
for i in text:
  data.append(i)

for d in range(0,len(text)):
  if data[d] == "?":
    data[d] = "D"
ans = ''.join(data)
print(ans)
import sys
import math
import itertools
import collections

def solve(T):
    ans = ""
    for t in T:
        if(t == "?"):
            ans += "D"
        else:
            ans += t
    return ans
def main():
    T = list(input())
    # solve()
    print(solve(T))

if __name__ == "__main__":
    main()
t=input()
t = t.replace("?", "D", len(t))

print(t)
T = input()
print(T.translate(str.maketrans({'?': 'D'})))
s = input()

output = []
for i, letter in enumerate(s):
    if letter != "?":
        output.append(letter)
    else:
        output.append("D")
print("".join(output))
t = list(input())
ln = len(t)
pre = ""
for i in range(ln):
    if(t[i]=='?'):
        t[i] = 'D'
print(''.join(t))
def main():
    T=input()
    ans=""
    for t in T:
        if t=="?":
            ans+="D"
        else:
            ans+=t
    print(ans)
if __name__ == '__main__':
    main()
tlist=list(input())

answer_list=[]
for t in tlist:
  if t=="?":
    answer_list.append("D")
  else:
    answer_list.append(t)
    
print("".join(answer_list))
t = list(input())
l = len(t)
for i in range(l):
    if t[i] == "?":
        t[i] = "D"
for i in t:
    print(i, end="")
t=input()
ans=t.translate(str.maketrans({'?': 'D'}))
print(ans)
t = input()
ans = ""
for i in range(len(t)):
    if t[i] != "?": ans += t[i]
    else: ans += "D"
print(ans)
import sys
input = sys.stdin.readline

T = input()

print(T.replace('?', 'D'))
"""
DDD PDDDDDP 5+1
DDP PDDDDPP 4+0
DPD PDDDPDP 4+2
DPP PDDDPPP 3+1

PDD PDPDDDP 4+2
PDP PDPDDPP 3+2
PPD PDPDPDP 3+3
PPP PDPDPPP 2+2
"""

t = input()
tt = t.replace('?', 'D')
print(tt)
T = list(input())

n = len(T)
T.append("P")
T.insert(0,"D")


ans = []
for i in range(1,n+1):
    if T[i] == "?":
        if T[i-1] == "P":
            T[i] = "D"
        elif T[i-1] == "D":
            T[i] = "D"

   








print("".join(T[1:n+1]))
t = input()
t = t.replace("?", "D")
print(t)
t = input()
size = len(t)
ans = ''

for i in range(size):
    if t[i] == '?':
        ans += 'D'
    else:
        ans += t[i]

print(ans)
t=input()
a=[]
for i in range(len(t)):
  if t[i]=="?":
    a.append("D")
  else:
    a.append(t[i])
ans="".join(a)
print(ans)
li_t = list(input())
ans = ''
for i in li_t:
    if i=='?':
        ans += 'D'
    else:
        ans += i
print(ans)
a=""
for i in input():
    if i=="?":
        a+="D"
    else:
        a+=i
print(a)
T = input()
T2 = list(T)

for i in range(len(T2)):
	if T2[i] == "?":
		T2[i] = "D"

#print("".join(T2).count("PD")+"".join(T2).count("D"))
print("".join(T2))
t = input()
lis = list(t)

for i in range(len(t)):
    if i==0 and lis[i]=="?":
        lis[i]="D"
    if i>=1 and lis[i]=="?" and lis[i-1]=="D":
        lis[i]="D"
    if i>=1 and lis[i]=="?" and lis[i-1]=="P":
        lis[i]="D"
    if i>=1 and lis[i]=="?" and lis[i-1]=="?":
        lis[i]="D"

print(''.join(lis))
T=input()
T=list(T)
for i in range(len(T)):
    if T[i]=="?":
        T[i]="D"
print("".join(T))
import re


def solve(stri):
    point = 0
    # Dの数
    for a in stri:
        if a == "D":
            point += 1
    # PDの数
    searched_pd = re.findall("PD",stri)
    point += len(searched_pd)
    return point

T = input()
T2 = re.sub('\?','D',T)

print(T2)
T  = list(str(input()))
for i in range(len(T)):
    if T[i] == '?':
        T[i] = 'D'

ans = ''.join(T)
print(ans)
T = input()
ans = ''
for i in range(len(T)):
    if T[i] != '?':
        ans += T[i]
        continue
    ans += 'D'
print(ans)
import sys

sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

""" Input
N = int(input())
N, A, B = map(int, input().split())
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""

S = input().rstrip()
print(S.replace('?', 'D'))
import sys
input = sys.stdin.readline
S = input()
print(S.replace('?', 'D'))
# B - Postdocs

T = list(str(input()))
len_T = len(T)

for i in range(len_T):
    if T[i] == '?':
        T[i] = 'D'
        
print(''.join(map(str, T)))
ln = input()
ln1 = ln.replace('?','D')
print(ln1)
from sys import stdin
input = stdin.readline

T = input().rstrip()
ans = []

for i in range(len(T)):
    if T[i] == "?":
        ans.append("D")
    else:
        ans.append(T[i])

print("".join(ans))
def main():
    T = input()
    ans = ""
    for c in T:

        if(c == "?"):
            ans += "D"
        else:
            ans += c

    print(ans)
main()
T = list(input())
for i in range(len(T)):
    if T[i] == "?":
        T[i] = "D"
print(*T, sep="")
s = list(input())
'''
for i in range(len(s)-1):
	if s[i] == "?":
		if s[i+1] == "D":
			s[i] = "P"
		elif s[i+1] == "?":
			s[i] = "P"
			s[i+1] = "D"
			i+=1
		else:
			s[i] = "D"
if s[-1] == "?":
	s[-1] = "D"
	'''
for i in range(len(s)):
	if s[i] == "?":
		s[i] = "D"
print("".join(s))
T = list(input())
for i, t in enumerate(T):
    if t == "?":
        T[i] = "D"
print("".join(T))
t = input()

import re

t = re.sub(r'P\?', 'PD', t)
t = re.sub(r'\?D', 'PD', t)
t = re.sub(r'\?\?', 'PD', t)
t = re.sub(r'\?', 'D', t)

print(t)
t = input()
tt = t.replace("?", "D")
print(tt)
T = input()
T = T.replace('?', 'D')
print(T)
t = input()

t = ["D" if i == "?" else i for i in t]

for i in t:
    print(i,end="")
from sys import stdin, stdout

int_in = lambda: int(stdin.readline())
arr_in = lambda: [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for y in range(rows)]
str_in = lambda: stdin.readline().strip()
out = lambda o: stdout.write("{}\n".format(o))
arr_out = lambda o: out(" ".join(map(str, o)))
bool_out = lambda o: out("YES" if o else "NO")
tests = lambda: range(1, int_in() + 1)
case_out = lambda i, o: out("Case #{}: {}".format(i, o))


def solve(t):
    return t.replace("?", "D")


if __name__ == "__main__":
    out(solve(str_in()))
T = input()
A = ''
for i in T:
    if i == '?':
        A += 'D'
    else:
        A += i
print(A)
def resolve():
    t = input()
    s = ""
    for c in t:
        if c == "?":
            c = "D"

        s += c
    print(s)

resolve()
import sys
input = sys.stdin.readline


def read():
    T = list(input().strip())
    return T,


def solve(T):
    N = len(T)
    ans = 0
    for i in range(N):
        if T[i] == "?":
            T[i] = "D"
        if T[i] == "D":
            ans += 1
    T = "".join(T)
    return T


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    
    T=str(input())
    print(T.replace('?','D'))
    
resolve()
import math

def a():
    h1, m1, h2, m2, k = map(int, input().split())
    t1 = h1 * 60 + m1
    t2 = h2 * 60 + m2

    if t1 < t2:
        print(t2 - t1 - k)
    else:
        print(1440 - (t1 - t2) - k)


def b():
    t = input()
    print(t.replace('?','D'))
            



def c():
    print('')



def d():
    print('')


b()
s = input()
ans = ""
for i in range(len(s)):
    if s[i] == "?":
        ans += "D"
    else:
        ans += s[i]
print(ans)
t = input()
lst = []
for i in range(len(t)):
  if t[i] == "P":
    lst.append("P")
  else:
    lst.append("D")
    
print(''.join(lst))
T=input()
ans=[]
for i in range(len(T)):
    if T[i]=='P':
        ans.append('P')
    elif T[i]=='D':
        ans.append('D')
    else:
        ans.append('D')

print(''.join(ans))
import numpy as np
#n = int(input())
#n, m = map(int, input().split())
#for i in range(n):

T = input()
n = len(T)
S = ''
#PDとDDは同じ
for i in range(n):
    if T[i] == '?':
        S += 'D'
    else:
        S += T[i]
print(S)
T = input()
L = len(T)
ans = ""
for i in range(L):
  if T[i] == "?":
    ans = ans + "D"
  else:
    ans = ans + T[i]
print(ans)
t = list(input())
for i in range(len(t)):
    if t[i] == "?":
        # t[i] = "D"x
        print("D",end = "")
    else:
        print(t[i],end = "")
def judge(T):
    count = 0
    for i in range(len(T)):
        if T[i] == "D":
            count += 1
        if not i == len(T) and T[i:i+2] == "PD":
            count += 1
    return count


if __name__ == '__main__':
    T = input().strip()

    print(T.replace("?", "D"))
T = input()
N = len(T)
after_T = ''

for i in range(N):
    charr=T[i]
    if(charr=='?'):
        after_T+='D'
    else:
        after_T+=charr

print(after_T)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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

#処理内容
def main():
	T = list(input())
	N = len(T)
	for i in range(N):
		if T[i] == "?":
			T[i] = "D"

	print("".join(T))

if __name__ == '__main__':
	main()
S = input()
ans = ""
for s in S:
    if s == "?":
        ans += "D"
    else:
        ans += s
print(ans)
T = input()
new_T = T.replace('?', 'D')

print(new_T)
t = list(input())
"""
flag = [False]*len(t)

for i in range(len(t)):
    if t[i] == 'P':
        flag[i] = True
"""

for i in range(len(t)):
    if t[i] == '?':
        t[i] = "D"

print("".join(t))
t=input()

def score(t):
  count=0
  for i in range(len(t)-1):
    if t[i]=='D':
      count+=1
    if t[i]=='P'and t[i+1]=='D':
      count+=1
  return count

hold=0

t_tr=t.replace('?','D')
#if hold<=score(t_tr):
#  hold=score(t_tr)
#  t_hold=t_tr

print(t_tr)
s=list(input())
for i in range(len(s)):
  if s[i]=="?":
    s[i]="D"
print("".join(s))
t_in = input()
t_out = ""
for t in t_in:
    if t == '?':
        t_out += 'D'
    else:
        t_out += t
print(t_out)
l1 = list(input())
k = l1.count('?')
for i in range(len(l1)):
  if l1[i] == '?':
    l1[i] = 'D'
s = ''.join(l1)
print(s)
T = input()
T1 = T.translate(str.maketrans({'?': 'D'}))
print(T1)
import sys
input = sys.stdin.readline
from collections import *

T = list(input()[:-1])

for i in range(len(T)):
    if T[i]=='?':
        T[i] = 'D'

print(''.join(T))
s=list(input()) 

for i in range(len(s)):

   if s[i] =="?":
      try:
          if s[i+1] =="D" and s[i-1] =="D":
              s[i] ="P" 
          else:
            s[i] ="D" 
      except:
          s[i] ="D" 
print("".join(s))
K=input()
KC=list(K)
for i in range(len(KC)):
    if KC[i]=="?":
        KC[i]="D"
print("".join(KC))
t=list(input())
for i in range(len(t)):
    if t[i]=="?":
        t[i]="D"
    print(t[i],end='')
t=input()
ans=str()
tmp=""
for s in t:
    if s=="P" or s=="D":
        ans+=s
        tmp=s
    else:
        ans+="D"
        tmp="D"

print(ans)
a=input()
i=0
while i<len(a):
    if a[i]=='?':
        print(end='D')

    else:
        print(end=str(a[i]))
    i=i+1
T = input()

l = []
for i in range(len(T)):
    if T[i] == 'P':
        l.append('P')
    else:
        l.append('D')
ans = ''.join(l)
print(ans)
T = input()
S = []
for t in T:
    if t == '?':
        S.append('D')
    else:
        S.append(t)
print(*S, sep='')
t = list(str(input()))
ans = ""
for i in t:
  if i == "?":
    ans += "D"
  else:
    ans += i
print(ans)
def main():
	s = input().strip()
	s = s.replace('?', 'D')
	print(s)

main()
t = str(input())
ans = t.replace('?', 'D')
print(ans)
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

print(input().replace("?", "D"))
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**8)


def geta(fn=lambda s: s.decode()):
    return map(fn, readline().split())


def gete(fn=lambda s: s.decode()):
    return fn(readline().rstrip())


def main():
    t = gete()

    print(t.replace("?", "D"))


if __name__ == "__main__":
    main()
def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]

def main():
    T = input().replace('?', 'D')
    print(T)
    return

if __name__ == '__main__':
    main()
# coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read

#n,*a = map(int, read().split())

s = input()

t = "".join(i if i!="?" else "D" for i in s)

print(t)
#!/usr/bin/env python3

T = input().replace('?', 'D')
print(T)
S=list(input())
for c in S:
    if c!='?':
        print(c, end='')
    else:
        print('D', end='')
print()
T=input()
N=len(T)

data=[T[i] for i in range(N)]
for i in range(N):
    if data[i]=="?":
        data[i]="D"

print("".join(data))
t = list(input())
t = ''.join(t)
t = t.replace('?',  'D')

print(t)
# coding:utf-8
t = input()
print(t.replace('?', 'D'))
t = input()
s = ''
for i in t:
  if i == '?':
    s += 'D'
  else:
    s += i
print(s)
T = list(input())
for i in range(len(T)):
    if T[i] == "?":
        T[i] = "D"

print("".join(T))
t = input()

"""
d = 0
pd = 0
p=0
for s in t:
  if s =="d" or s=="?":
    d+=1
    if p==1:
      pd+=1
  else:
    p=1

print(d+pd)
"""

ans = ""
for s in t:
  if s == "?":
    ans += "D"
  else:
    ans += s
print(ans)
s = input()

n = len(s)
ans = []
for i in range(n):
    if s[i] != '?':
        ans.append(s[i])
    else:
        ans.append('D')
            
print(*ans,sep = '')