output_description: Print the string S.  
  If such a string does not exist, print `UNRESTORABLE` instead.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      S
      T'
attempt: from copy import deepcopy
  from sys import exit, setrecursionlimit
  import math
  from collections import defaultdict, Counter, deque
  from fractions import Fraction as frac
  import fractions
  from functools import reduce
  import bisect
  import sys
  import logging
  import heapq
  
  # logging.basicConfig(level=logging.DEBUG)
  
  input = sys.stdin.readline
  
  setrecursionlimit(1000000)
  
  
  def main():
      s = input()[:-1]
      t = input()[:-1]
      for i in reversed(range(len(s) - len(t) + 1)):
          flag = True
          for j in range(len(t)):
              if s[i + j] != "?" and s[i + j] != t[j]:
                  flag = False
                  break
          if flag:
              ans = []
              for j in s:
                  ans.append(j)
              for j in range(i, i + len(t)):
                  ans[j] = t[j - i]
              a = ""
              for i in ans:
                  a += i
              print(a.replace("?", "a"))
              return
      print("UNRESTORABLE")
  
  
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-(n**0.5) // 1)) + 1):
          if temp % i == 0:
              cnt = 0
              while temp % i == 0:
                  cnt += 1
                  temp //= i
              arr.append([i, cnt])
  
      if temp != 1:
          arr.append([temp, 1])
  
      if arr == []:
          arr.append([n, 1])
  
      return arr
  
  
  def zip(a):
      mae = a[0]
      ziparray = [mae]
      for i in range(1, len(a)):
          if mae != a[i]:
              ziparray.append(a[i])
              mae = a[i]
      return ziparray
  
  
  def is_prime(n):
      if n < 2:
          return False
  
      for k in range(2, int(math.sqrt(n)) + 1):
          if n % k == 0:
              return False
  
      return True
  
  
  def list_replace(n, f, t):
      return [t if i == f else i for i in n]
  
  
  def base_10_to_n(X, n):
      X_dumy = X
      out = ""
      while X_dumy > 0:
          out = str(X_dumy % n) + out
          X_dumy = int(X_dumy / n)
      if out == "":
          return "0"
      return out
  
  
  def lcm(numbers):
      return reduce(lcm_base, numbers, 1)
  
  
  def lcm_base(x, y):
      return (x * y) // fractions.gcd(x, y)
  
  
  class Queue:
      def __init__(self):
          self.q = deque([])
  
      def push(self, i):
          self.q.append(i)
  
      def pop(self):
          return self.q.popleft()
  
      def size(self):
          return len(self.q)
  
      def debug(self):
          return self.q
  
  
  class Stack:
      def __init__(self):
          self.q = []
  
      def push(self, i):
          self.q.append(i)
  
      def pop(self):
          return self.q.pop()
  
      def size(self):
          return len(self.q)
  
      def debug(self):
          return self.q
  
  
  class graph:
      def __init__(self):
          self.graph = defaultdict(list)
  
      def addnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].append(t)
          self.graph[t].append(f)
  
      def rmnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].remove(t)
          self.graph[t].remove(f)
  
      def linked(self, f):
          return self.graph[f]
  
  
  class dgraph:
      def __init__(self):
          self.graph = defaultdict(set)
  
      def addnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].append(t)
  
      def rmnode(self, l):
          f, t = l[0], l[1]
          self.graph[f].remove(t)
  
      def linked(self, f):
          return self.graph[f]
  
  
  class PriorityQueue:
      def __init__(self):
          self.queue = []
  
      def push(self, i):
          heapq.heappush(self.queue, -i)
  
      def pop(self):
          return -1 * heapq.heappop(self.queue)
  
      def sum(self):
          return -sum(self.queue)
  
  
  main()
  
problem_description: Statement
  
  E869120 found a chest which is likely to contain treasure.  
  However, the chest is locked. In order to open it, he needs to enter a string
  S consisting of lowercase English letters.  
  He also found a string S', which turns out to be the string S with some of its
  letters (possibly all or none) replaced with `?`.
  
  One more thing he found is a sheet of paper with the following facts written
  on it:
  
    * Condition 1: The string S contains a string T as a contiguous substring.
    * Condition 2: S is the lexicographically smallest string among the ones that satisfy Condition 1.
  
  Print the string S.  
  If such a string does not exist, print `UNRESTORABLE`.
samples: [{"input": "?tc????\n    coder", "output": "atcoder\n    \n\nThere are 26 strings that satisfy Condition 1: `atcoder`, `btcoder`,\n`ctcoder`,..., `ztcoder`. Among them, the lexicographically smallest is\n`atcoder`, so we can say S = `atcoder`.\n\n* * *"}, {"input": "??p??d??\n    abc", "output": "UNRESTORABLE\n    \n\nThere is no string that satisfies Condition 1, so the string S does not exist."}]