Problem:
 Score : 200 points    Problem Statement For a string S consisting of the uppercase English letters P and D , let the doctoral and postdoctoral quotient of S be the total number of occurrences of D and PD in S as contiguous substrings. For example, if S =  PPDDP , it contains two occurrences of D and one occurrence of PD as contiguous substrings, so the doctoral and postdoctoral quotient of S is 3 .  We have a string T consisting of P , D , and ? .  Among the strings that can be obtained by replacing each ? in T with P or D , find one with the maximum possible doctoral and postdoctoral quotient.      Constraints  1 \leq |T| \leq 2 \times 10^5  T consists of P , D , and ? .         Input Input is given from Standard Input in the following format:  T       Output Print one string with the maximum possible doctoral and postdoctoral quotient among the strings that can be obtained by replacing each ? in T with P or D .
If there are multiple such strings, you may print any of them.        Sample Input 1 PD?D??P      Sample Output 1 PDPDPDP  This string contains three occurrences of D and three occurrences of PD as contiguous substrings, so its doctoral and postdoctoral quotient is 6 , which is the maximum doctoral and postdoctoral quotient of a string obtained by replacing each ? in T with P or D .       Sample Input 2 P?P?      Sample Output 2 PDPD

Solution (Python):
T=input()
T=T.replace("?", "D")
print(T)

Solution (Python):
T = input()
T = T.replace('?','D')

print(T)

Solution (Python):
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()

    T = SI()
    print(T.replace('?','D'))

if __name__ == '__main__':
    main()

Solution (Python):
import math

t = input()

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

Solution (Python):
t = input()

answer = ""

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

Solution (Python):
T = input()
ans = ""
for i in T:
    if i=="?":
        ans += "D"
    else:
        ans += i
print(ans)

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

Solution (Python):
T = input()

print(T.replace('?', 'D'))

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

Solution (Python):
t = input()
ans = ''
for ti in t:
    if(ti=='?'):
        ans = ans + 'D'
    else:
        ans = ans + ti

print(ans)

Solution (Python):
t = input()
ret = t.replace('?', 'D')
print(ret)

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


if __name__ == '__main__':
    main()

Solution (Python):
S = input()
S2 = S.replace('?', 'D')
print(S2)

Solution (Python):

t = input()

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

Solution (Python):
T = input()
print(T.replace('?', 'D'))

Solution (Python):
import unittest


def solve(t):
    t = t.replace('?', 'D')

    return t


def main():
    t = input()
    result = solve(t)
    print(result)


class Test(unittest.TestCase):
    def test_solve(self):
        self.assertEqual(1, 1)


if __name__ == "__main__":
    main()

Solution (Python):


import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))

def resolve():
    T=(input())
    S=list()
    for t in T:
        if t=="?":
            S.append("D")
        else:S.append(t)

    print("".join(S))

resolve()

Solution (Python):
S = str(input())


follow = ''
ans = ''
for s in S:
  if s == '?':
    ans += 'D'
  else:
    ans += s
print(ans)

Solution (Python):
def main():
    T = input()
    ans = ""
    for c in T:

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

    print(ans)
main()

Solution (Python):
t = input()
n = len(t)
ans = ''
for i in range(n):
    if t[i] == '?':
        ans += 'D'
    else:
        ans += t[i]
print(ans)

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

Solution (Python):
t = input()

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

Solution (Python):
def main():

    T = input()

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

    
    
    
    
    
    
    

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

Solution (Python):
t = input()
a = t.replace('?','D')
print(a)

Solution (Python):
T = input()
print(T.replace("?", "D"))

Solution (Python):
T = input()

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

Solution (Python):
T = list(input())

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

Solution (Python):
s=input()
l=[i for i in s]
for i in range(len(s)):
    S=s[i]
    if S=="?":
        l[i]="D"
s=''.join(l)
print(s)

Solution (Python):
t = input()
ans = []
for i in t:
  if i != '?':
    ans.append(i)
  else:
    ans.append('D')
print(''.join(ans))

Solution (Python):
t = input()
ans = ""
for c in t:
    if c == '?':
        ans += "D"
    else:
        ans += c

print(ans)

Solution (Python):
def main():
    t = list(input())

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

    print(*t,sep='') 

if __name__ == "__main__":
    main()

Solution (Python):
t = input()
ans = t.replace('?', 'D')
print(ans)

Solution (Python):
T=input()
print(T.replace("?","D"))

Solution (Python):
T = str(input())

ans = T.count('P?') + T.count('D') +T.count('?')

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

Solution (Python):
S = list(input())
s = len(S)
for i in range(s):
    if S[i] == "?":
        S[i] = "D"
print(''.join(S))

Solution (Python):
T = input()

print(T.replace('?', 'D'))

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

Solution (Python):
T=input()
ans=''

for i in range(len(T)):
    if T[i]=='P':
        ans+='P'
    elif T[i]=='D':
        ans+='D'
    else:
        ans+='D'
        
print(ans)

Solution (Python):
S = input()

print(S.replace('?', 'D'))

Solution (Python):

ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda :int(input())
ip = lambda :[int(w) for w in input().split()]

s = input()
s = s.replace("P?",'PD')
s = s.replace("?",'D')
print(s)

Solution (Python):
t = input()

s = []

for i in range(len(t)):
  if t[i] != '?':
    s.append(t[i])
  else:
    s.append('D')
      
print(''.join(s))

Solution (Python):
T=list(input())

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

print("".join(T))

Solution (Python):
import sys
def S(): return sys.stdin.readline().rstrip()
print(S().replace('?','D'))

Solution (Python):
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())
def LN(n):return [N() for i in range(n)]
def LL(n):return [L() for i in range(n)]
def Yes(x):print("Yes")if x==True else print("No")
t=[i for i in input()]
n=len(t)
for i in range(n):
    if t[i]=="?":
        t[i]="D"
print("".join(t))

Solution (Python):
t = input()
t = t.replace("P?", "PD")
t = t.replace("?", "D")
print(t)

Solution (Python):
s = list(input())
for i in range(len(s)):
    if s[i] == '?': s[i] = 'D'
print(*s, sep = '')

Solution (Python):



T = input()

print(T.replace('?','D'))

Solution (Python):
T = list(input())
N =len(T)
out = []
for i in range(N):
    if T[i]=="?":
        out.append("D")
    else:
        out.append(T[i])
print("".join(out))

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline

T = input().rstrip()
ans = ''
for t in T:
    if t=='?':
        ans += 'D'
    else:
        ans += t

print(ans)

Solution (Python):
s = input()

s = s.replace('?', 'D')
print(s)

Solution (Python):
T = input()

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

Solution (Python):
T = list(input())


for i in range(len(T)):
    if T[i] == "?":
        T[i] = "D"
print("".join(T))

Solution (Python):

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

Solution (Python):

s = input()

print(s.replace('?', 'D'))

Solution (Python):
s = input()

ans = ''
for i in s:
    if i == 'P':
        ans += i
    else:
        ans += 'D'

print(ans)

Solution (Python):
T = input()

print(T.replace('?', 'D'))

Solution (Python):
t=list(input())

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

str_changed = "".join(t)

print(str_changed)

Solution (Python):
T = input()
n = len(T)
for i in range(n):
  if T[i] == '?':
    print("D", end = '')
  else:
    print(T[i], end = '')
print()

Solution (Python):
T = list(input().strip())
for i in range(len(T)):
    if T[i]=="?":
        T[i]="D"
print("".join(T))

Solution (Python):
s = input()

print(s.replace('?', 'D'))

Solution (Python):
i=input()
for c in i:
  if c=='?':
    print("D",end="")
  else:
    print(c,end="")

Solution (Python):
s = str(input())

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

Solution (Python):
t=input()

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

Solution (Python):
t = input()
print(t.replace("?", "D"))

Solution (Python):

from sys import stdin
input = stdin.readline
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

t = ins()
s = t.replace('?','D')
print(s)

Solution (Python):



T = input()


def main():
    ans = T.replace("?", "D")
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
t = list(input())

for i in range(len(t)):
    if t[i] == "?":
        t[i] = "D"
print(*t,sep="")

Solution (Python):
import sys, random, math
from bisect import bisect_left, bisect_right
input = sys.stdin.readline

def main():
    inf = 10 ** 20



    t = 1
    
    for _ in range(1, t+1):
    
        
        t = input().strip()
        for x in t:
            if(x == '?'):
                print("D", end = '')
            else:
                print(x, end = '')
        
        
main()

Solution (Python):
li_t = list(input())
ans = ''
for i in li_t:
    if i=='?':
        ans += 'D'
    else:
        ans += i
print(ans)

Solution (Python):
T = list(input())
for i, t in enumerate(T):
    if t == "?":
        T[i] = "D"
print("".join(T))

Solution (Python):
A=input()
print(A.replace("?","D"))

Solution (Python):
import sys
input = sys.stdin.readline


def readstr():
    return input().strip()


def readint():
    return int(input())


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


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


def main():
    T = readstr()
    T = T.translate(str.maketrans({'?': 'D'}))
    print(T)


if __name__ == "__main__":
    main()

Solution (Python):
T = list(input())
ans = 0
i = 0
while i < len(T):
  if T[i] == "?":
    T[i] = "D"
  i += 1
print("".join(T))

Solution (Python):
T = list(input())
for t in T:
    if t == '?':
        print('D', end='')
    else:
        print(t, end='')
print()

Solution (Python):
s = str(input())
if s[0] == "?":
    ans = "D"
else:
    ans = s[0]
for i in range(len(s)-1):
    if s[i+1] != "?":
        ans += s[i+1]
    else:
        ans += "D"
print(ans)

Solution (Python):
t = str(input())
ans = t.replace("?", "D")
print(ans)

Solution (Python):
s = input()
print(s.replace("?","D"))

Solution (Python):
t=input()
s=list(t)
l=[]
for i in range(len(s)):
  if s[i]=='?':
    l.append('D')
  else:
    l.append(s[i])
print(''.join(l))

Solution (Python):
S = input()
ans = ""
for elt in S:
    if elt == "P":
        ans += "P"
    else:
        ans += "D"
print(ans)

Solution (Python):
t = input()
t2 = ""
for i in range(len(t)):
    if t[i] == "P":
        t2 += "P"
    else:
        t2 += "D"
print(t2)

Solution (Python):
t = input()
ans = 0
for x in t:
    print('P' if x == 'P' else 'D', end = '')
print('')

Solution (Python):
print(input().replace("?","D"))

Solution (Python):
print(input().replace('?', 'D'))

Solution (Python):
t=input()
for i in t:
  print('P' if i=='P' else 'D',end='')

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
	return list(map(int,input().split()))
def m(): 
	return map(int,input().split())
def onem(): 
	return int(input())
def s(x): 
	a = []
	if len(x) == 0:
		return []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa != x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): 
	return "".join(map(str,x))
def max2(x): 
	return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
	ll = 0
	rr = r
	while True:
		mid = (ll+rr)//2

	if rr == mid:
		return ll
	if (ここに評価入れる):
		rr = mid
	else:
		ll = mid+1
"""

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

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

Solution (Python):
print(input().replace("?","D"))

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

s = readline().rstrip().decode('utf-8')

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

Solution (Python):
T=input()
T=list(T)
for i in T:
    if i=="?":
        print("D", end="")
    else:
        print(i, end="")

Solution (Python):
t = list(input())
n = len(t)
for i in range(n):
  if t[i]=="?":
    t[i] = "D"
print(*t,sep="")

Solution (Python):


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

Solution (Python):
T = input()

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

Solution (Python):


import sys
input = sys.stdin.readline
import math
s = input()
print(s.replace('?', 'D'))

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

Solution (Python):
t = list(input())
for i, x in enumerate(t):
    if x == "?": t[i] = "D"
print("".join(t))

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

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

Solution (Python):
t=input()
t = t.replace("?", "D", len(t))

print(t)

Solution (Python):
T = input()
ans = []
for i in T:
    if i == "?":
        ans.append("D")
    else:
        ans.append(i)
print("".join(ans))

Solution (Python):

T=list(input())

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

print("".join(T))

Solution (Python):
t = list(input())

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

print("".join(t))

Solution (Python):
t=input()
s=''
for i in t:
    if i == '?':
        s += 'D'
    else:
        s += i
print(s)

Solution (Python):
T = input()
print(T.replace("?", "D"))

Solution (Python):
T=input()
a=[]
for c in T:
    if c=='?':
        x='D'
    else:
        x=c
    a.append(x)
print(''.join(a))

Solution (Python):
s = input()
ans = []
for x in s:
    if x != '?':
        ans.append(x)
    else:
        ans.append('D')
print("".join(ans))

Solution (Python):
import sys
sys.setrecursionlimit(10**6) 
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque 


from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush




def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N=len(v)
    size=len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def main():
    mod = 10**9+7
    

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





if __name__ == "__main__":
    main()

Solution (Python):
T = list(input())

for t in T:
    if t == 'P':
        print ('P', end = '')
    else:
        print ('D', end = '')

print ()

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


def main():
    T = input()
    
    
    S = []
    for c in T:
        if c == "?":
            S.append("D")
        else:
            S.append(c)
    print("".join(S))
    return


if __name__ == '__main__':
    main()

Solution (Python):
T = input()
T = T.replace('?','D')

print(T)

Solution (Python):
T=list(input())

for i in range(len(T)):
    if T[i]=="?":
        T[i]="D"
for t in T:
    print(t,end="")

Solution (Python):
t = input()
for i in t:
    if i=='?':
        print('D', end='')
    else:
        print(i, end='')
print()

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]





t=list(ss())

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

Solution (Python):
print(input().replace('?','D'))

Solution (Python):
A= str(input())

V = []

for i in range(0, len(A)):
	if A[i] == '?':
		V.append('D')
	else:
		V.append(A[i])

K=''

for i in range (0, len(V)):
	K=K+V[i]

print(K)

Solution (Python):
T=input()

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

Solution (Python):
T = input()
print(T.replace('?', 'D'))

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    t = input()
    res = t.replace("?", "D")
    print(res)


if __name__ == '__main__':
    resolve()

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


def input():
    return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

Solution (Python):
T = input()
N = len(T)
res = []
for t in T:
    if t == "P":
        res.append("P")
    else:
        res.append("D")
print("".join(map(str, res)))

Solution (Python):
print(input().replace('?', 'D'))

Solution (Python):
s = input()
s = s.replace("?", "D")
print(s)

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import lru_cache, reduce
from math import gcd
from operator import add, itemgetter, mul, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


T = sys.stdin.buffer.readline().decode().rstrip()
print(T.replace('?', 'D'))

Solution (Python):
t = list(input())
for i in range(len(t)):
    if t[i] == "?":
        t[i] = "D"
print(*t, sep="")

Solution (Python):
t=input()
ans=""
for i in range(len(t)):
    if t[i]=="?": print("D",end="")
    else: print(t[i],end="")

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

t = stdin.readline().rstrip()

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

print(t)

Solution (Python):
T=input()
print(T.replace('?', 'D'))

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

Solution (Python):
import math

import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)

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

Solution (Python):
import sys, math,os
from io import BytesIO, IOBase
from bisect import bisect_left as bl, bisect_right as br, insort

from collections import defaultdict as dd, deque, Counter

def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
sys.setrecursionlimit(100000)
from fractions import Fraction
INF = float('inf')
mod = 998244353


def main():

    s=data()
    s1=''
    for i in s:
        if i=='?':
            s1+='D'
        else:
            s1+=i
    out(s1)

if __name__ == '__main__':
    main()

Solution (Python):
T=input().replace("?","D")
print(T)

Solution (Python):
T = input().replace('?', 'D')
print(T)

Solution (Python):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


mod=1000000007
def combinations_count_mod(n, r):
    r = min(r, n - r)
    numer = reduce(lambda x,y: x*y%mod, range(n, n - r, -1), 1)
    denom = pow( reduce(lambda x,y: x*y%mod, range(1, r + 1), 1) , mod-2, mod)
    return numer * denom % mod


def main():
    S = input().strip()
    print( S.replace("?","D"))


if __name__ == '__main__':
    main()

Solution (Python):
s=list(input())
for i in range(len(s)):
    if s[i]=='?':
        s[i]='D'
print(*s,sep='')

Solution (Python):
T = input()

[print(i if i != '?' else 'D', end='') for i in T] 
print()

Solution (Python):
s = input()
for i in range(len(s)):
	if s[i] == '?':
		print('D', end='')
	else:
		print(s[i], end='')

Solution (Python):

def s0():return input()
def s1():return input().split()
def s2(n):return [input() for x in range(n)]
def s3(n):return [input().split() for _ in range(n)]
def s4(n):return [[x for x in s] for s in s2(n)]
def n0():return int(input())
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(input()) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
def t3(n):return [tuple(int(x) for x in input().split()) for _ in range(n)]
def p0(b,yes="Yes",no="No"): print(yes if b else no)








s=s0()

s2=["P" if x=="P" else "D" for x in s]
ans="".join(s2)
print(ans)

Solution (Python):
t = list(input())
for i in range(len(t)):
    if t[i] == "?":
        t[i] = "D"
t = "".join(t)
print(t)

Solution (Python):
def mp(): return map(int, input().split())
def lmp(): return list(map(int, input().split()))

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

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





s = input()
ans = s.replace("?", "D")
print(ans)

Solution (Python):
T = str(input())
N = len(T)
ans = [0] * N
for i in range(len(T)):
  if T[i] == "?":
    ans[i] = "D"
  else:
    ans[i] = T[i]

for i in range(N):
  print(ans[i], end = "")

Solution (Python):
t = [i for i in input()]
ans = ""
for i in t:
    if i == "?":
        ans+="D"
    else:
        ans+=i
print(ans)

Solution (Python):
print( input().replace('?','D'))

Solution (Python):

T = str(input())

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

Solution (Python):
T = input()
for t in T:
    if t == "?":
        print("D",end="")
    else:
        print(t,end="")
print()

Solution (Python):
t=input()
t=t.replace("?","D")
print(t)

Solution (Python):
T = input()
ans = ''
for i in range(len(T)):
    if T[i] != '?':
        ans += T[i]
    else:
        ans += 'D'
print(ans)

Solution (Python):
def main():
    S = input()
    print(S.replace('?','D'))

if __name__ == '__main__':
    main()

Solution (Python):
t = input()

for c in t:
  if c == '?':
    c = 'D'
  print(c,end= '')
print()

Solution (Python):
a = input()

a = a.replace("?", "D")
print(a)

Solution (Python):
t = input()
ans = [0] * len(t)
for i in range(len(t)):
    if t[i] == '?':
        ans[i] = 'D'
    else:
        ans[i] = t[i]
for i in ans:
    print(i, end='')
print()

Solution (Python):
T = input()
Ans = []
for t in T:
    if t != '?':
        Ans.append(t)
    else:
        Ans.append('D')

print(''.join(Ans))

Solution (Python):
T = input()
T = T.replace('?', 'D')
print(T)

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    T = input().rstrip()

    ans = T.replace("?", "D", len(T))

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    T = input()
    p = False
    ans = []
    for t in T:
        if t == "?":
            ans.append("D")
        else:
            ans.append(t)
    print("".join(ans))
if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
T = (stdin.readline().rstrip())
T = T.replace("?","D")
print(T)

Solution (Python):
inf = 10 ** 15
mod = 10 ** 9 + 7
t = input()
s = []
for c in t:
    if c == '?':
        s.append('D')
    else:
        s.append(c)
print(*s, sep='')

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7



T = input()
for x in T:
	if x == "?":
		print("D", end = "")
	else:
		print(x, end = "")
print()

Solution (Python):
S = list(input())

ans = 0

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

print("".join(S))

Solution (Python):
t = input()

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

Solution (Python):
t = input()
n = len(t)

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

Solution (Python):
T = input()
T = T.replace("?","D")

print(T)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

t = ns()
a = ''
for i in t:
    if i == '?':
        a+='D'
    else:
        a+=i

print(a)

Solution (Python):
import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7

T = input()

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

Solution (Python):
print(''.join([x if x != '?' else 'D' for x in input()]))

Solution (Python):
t = input()
ans = ""
for i in range(len(t)):
    if t[i] != "?": ans += t[i]
    else: ans += "D"
print(ans)

Solution (Python):
s = input().strip()
ans=""
for char in s:
    if char=="?":
        ans+="D"
    else:
        ans+=char
print(ans)

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")











T = list(input())[:-1]
n = len(T)
for i in range(n):
    if T[i] == "?":
        T[i] = "D"
print("".join(T))

Solution (Python):
t=input().replace("?","D")
print(t)

Solution (Python):
s=list(input())
for i in range(len(s)):
  if s[i]!="?":
    print(s[i],end="")
  else:
    print("D",end="")