import Control.Monad
import Control.Applicative
import Data.List
import qualified Data.Map as Map
import Data.Array
import qualified Data.ByteString.Char8 as BC
import Data.Maybe
import qualified Data.Set as Set
import qualified Data.Sequence as Sq
import qualified Data.IntMap as IMap
import qualified Data.Vector as V
import Data.Sequence (ViewL(..),ViewR(..),(><),(<|),(|>),Seq)

bsreadInt :: BC.ByteString -> Int
bsreadInt = fst . fromJust . BC.readInt

sqleft :: Seq a -> a
sqleft q = sqleft_(Sq.viewl q)
sqleft_ :: ViewL a -> a
sqleft_ (x :< xs) = x
sqright :: Seq a -> a
sqright q = sqright_(Sq.viewr q)
sqright_ :: ViewR a -> a
sqright_ (xs :> x) = x
-------------------------------------------------------------
chk :: String -> String -> [Int] -> Bool
chk s t ms = foldr (&&) True [((s!!m == t!!(m-mini)) || (s!!m == '?') )| m <- ms]
             where mini = minimum ms

swap :: String -> String -> Int -> String
swap s t n = (take n s) ++ t ++ (drop (n+tl) s)
               where tl = length t

swapa1 :: Char -> Char
swapa1 s = if (s == '?') then 'a' else s
swapa :: String -> String
swapa sn = map swapa1 sn

main = do
    s <- getLine
    t <- getLine
    let sl = length s
    let tl = length t
    let inter = [[i..(i+tl-1)] | i <-  [0..(sl-tl)]]
    let subable = findIndices (==True) [chk s t ms | ms <- inter]
    let swaping = [swap s t i | i <- subable]
    if (null swaping == True)
    then putStrLn "UNRESTORABLE"
    else putStrLn $ head $ sort $ map swapa swaping
    
    
    