Problem:
Score : 300 points

Problem 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.

Constraints

1 \leq |S'|, |T| \leq 50

S' consists of lowercase English letters and ?.

T consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

S
T'

Output

Print the string S.

If such a string does not exist, print UNRESTORABLE instead.

Sample Input 1

?tc????
coder

Sample Output 1

atcoder

There are 26 strings that satisfy Condition 1: atcoder, btcoder, ctcoder,..., ztcoder.
Among them, the lexicographically smallest is atcoder, so we can say S = atcoder.

Sample Input 2

??p??d??
abc

Sample Output 2

UNRESTORABLE

There is no string that satisfies Condition 1, so the string S does not exist.

Solution in C (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

#define MAX_LENGTH 50


void solve(char bigger[], char smaller[]);


int main()
{
    int n;
    char s_dash[MAX_LENGTH + 1];
    char t[MAX_LENGTH + 1];
    int ans;
    
    scanf("%s", s_dash);
    scanf("%s", t);

    solve(s_dash, t);

    return 0;
} 


void solve(char bigger[], char smaller[])
{
    size_t bigger_length;
    size_t smaller_length;
    bool isSubstring;
    char temp[MAX_LENGTH + 1];
    char smallest[MAX_LENGTH + 1];

    bigger_length = strlen(bigger);
    smaller_length = strlen(smaller);

    smallest[0] = '\0';
    for (int i = 0; i < (int)bigger_length; i++)
    {
	isSubstring = true;
	for (int j = 0; j < (int)smaller_length; j++)
	{
	    if (bigger[i + j] != '?' && bigger[i + j] != smaller[j])
	    {
		isSubstring = false;
		break;
	    }
	}
	
	if (isSubstring)
	{
	    for (int k = 0; k < (int)bigger_length; k++)
	    {
		if (k < i)
		{
		    if (bigger[k] == '?')
		    {
			temp[k] = 'a';
		    }
		    else
		    {
			temp[k] = bigger[k];
		    }
		}
		else if (k == i)
		{
		    for (int l = 0; l < (int)smaller_length; l++)
		    {
			temp[k + l] = smaller[l];
		    }
		}
		else if ((i + (int)smaller_length) < k)
		{
		    if (bigger[k] == '?')
		    {
			temp[k] = 'a';
		    }
		    else
		    {
			temp[k] = bigger[k];
		    }
		}
	    }
	    temp[(int)bigger_length] = '\0';
            
	    if (strcmp(smallest, "") == 0)
	    {
		strcpy(smallest, temp);
	    }
	    else if (strcmp(smallest, temp) < 0)
	    {
		strcpy(smallest, temp);
	    }
	}
    }

    if (strcmp(smallest, "") == 0)
    {
	printf("UNRESTORABLE\n");
    }
    else
    {
	printf("%s\n", smallest);
    }
}