using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;

static class MainClass
{
    public static void Main()
    {
        var str = Console.ReadLine().ToList();
        var strt = Console.ReadLine();
        var len = str.Count;
        var tlen = strt.Length;
        var kouho = new List<string>();
        var newkouho = new List<string>();
        for (int i = 0; i <= len - tlen; i++)
        {
            var tistr = str.DeepClone();

            if (str[i] == '?' || str[i] == strt[0])
            {
                var isOk = true;
                for (int j = 0; j < tlen; j++)
                {
                    if (str[i + j] != strt[j] && str[i + j] != '?')
                    {
                        isOk = false;
                        break;

                    }
                    else
                    {
                        tistr[i+j] = strt[j];
                    }

                }
                if (isOk)
                {
                    var sb = new StringBuilder();
                    tistr.ForEach(x =>
                    {
                        sb.Append(x);
                    });
                    kouho.Add(sb.ToString());
                }
            }
        }
        if (kouho.Count == 0)
        {
            Console.WriteLine("UNRESTORABLE");
        }
        else
        {
            foreach (var item in kouho)
            {
                for (int i = 0; i < len; i++)
                {
                    if (item[i] == '?')
                    {
                        newkouho.Add(item.Replace('?', 'a'));
                    }
                    else
                    {
                        if (!newkouho.Contains(item) && !item.Contains('?'))
                            newkouho.Add(item);
                    }
                }
            }
            newkouho.Sort();
            Console.WriteLine(newkouho.First());
            Console.ReadLine();
        }

    }
    #region 二分探索
    public static int LowerBound<T>(T[] arr, int start, int end, T value, IComparer<T> comparer)
    {
        int low = start;
        int high = end;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >> 1) + low;
            if (comparer.Compare(arr[mid], value) < 0)
                low = mid + 1;
            else
                high = mid;
        }
        return low;
    }

    public static int LowerBound<T>(T[] arr, T value) where T : IComparable
    {
        return LowerBound(arr, 0, arr.Length, value, Comparer<T>.Default);
    }

    public static int UpperBound<T>(T[] arr, int start, int end, T value, IComparer<T> comparer)
    {
        int low = start;
        int high = end;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >> 1) + low;
            if (comparer.Compare(arr[mid], value) <= 0)
                low = mid + 1;
            else
                high = mid;
        }
        return low;
    }

    public static int UpperBound<T>(T[] arr, T value)
    {
        return UpperBound(arr, 0, arr.Length, value, Comparer<T>.Default);
    }
    #endregion
    #region　bit全探索
    /// <summary>
    /// Bit全探索用のライブラリ
    /// </summary>
    /// <param name="len">作る配列の長さ(lenが0以下だと（ｒｙ)</param>
    /// <returns>できた配列</returns>
    public static List<List<bool>> CreateBits(int len)
    {
        return CreateBitsPri(new List<List<bool>>(), len, 0);
    }

    private static List<List<bool>> CreateBitsPri(List<List<bool>> bits, int len, int count)
    {
        if (count == 0)
        {
            var lss = new List<bool>();
            lss.Add(true);
            bits.Add(lss);
            var lx = new List<bool>();
            lx.Add(false);
            bits.Add(lx);
            count++;
            return CreateBitsPri(bits, len, count);
        }
        if (len - count == 0)
            return bits;
        count++;
        var ls = new List<List<bool>>();
        foreach (var item in bits)
        {
            var x = item.ToList();
            x.Add(true);
            item.Add(false);
            ls.Add(item);
            ls.Add(x);
        }
        return CreateBitsPri(ls, len, count);
    }
    #endregion
    #region 文字列処理

    public static int ToInt32(this string str)
    {
        return int.Parse(str);
    }
    public static List<string> SplittedStringToList(this string str)
    {
        return str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
            .ToList();
    }
    public static List<int> SplittedStringToInt32List(this string str)
    {
        return str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToList();
    }
    #endregion
    #region エラトステネスの篩
    public static List<int> GeneratePrimes(int max)
    {

        var range = Enumerable.Range(2, max - 1).ToList();
        var count = range.Count();
        var ls = new List<int>();
        while (true)
        {
            int num = 0;
            try
            {
                num = range.First();
                ls.Add(num);
            }
            catch
            {
                break;
            }
            for (int i = 1; i * num <= max; i++)
            {
                range.Remove(i * num);
            }
            if (range.Count <= 0)
            {
                break;
            }
        }
        return ls;
    }
    #endregion
    #region DeepClone
    public static T DeepClone<T>(this T src)
    {
        using (var memoryStream = new MemoryStream())
        {
            var binaryFormatter
              = new BinaryFormatter();
            binaryFormatter.Serialize(memoryStream, src);
            memoryStream.Seek(0, SeekOrigin.Begin);
            return (T)binaryFormatter.Deserialize(memoryStream);
        }
    }
    #endregion

}

Measured memory_bytes: 14172