#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet, BinaryHeap};
#[allow(unused_imports)]
use std::iter::FromIterator;

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }

    #[allow(dead_code)]
    pub fn get2<T: FromStr, U: FromStr>() -> (T, U)
    where
        <T as FromStr>::Err: Debug,
        <U as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    }

    #[allow(dead_code)]
    pub fn get3<S: FromStr, T: FromStr, U: FromStr>() -> (S, T, U)
    where
        <S as FromStr>::Err: Debug,
        <T as FromStr>::Err: Debug,
        <U as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    }
}

#[allow(unused_macros)]
macro_rules! debug {
    ($x: expr) => {
        println!("{}: {:?}", stringify!($x), $x)
    }
}

fn main() {
    let s: Vec<char> = util::line().chars().collect();
    let t: Vec<char> = util::line().chars().collect();

    if s.windows(t.len()).any(|v| v == t.as_slice()) {
        println!(
            "{}",
            s.iter()
                .map(|&c| if c == '?' { 'a' } else { c })
                .collect::<String>()
        );
    } else {
        if let Some(ans) = (0..s.len() - t.len() + 1)
            .filter(|&i| {
                s[i..i + t.len()].iter().zip(t.iter()).all(|(&cs, &ct)| {
                    cs == '?' || cs == ct
                })
            })
            .map(|start| {
                s[..start]
                    .iter()
                    .map(|&c| if c == '?' { 'a' } else { c })
                    .chain(t.iter().cloned())
                    .chain(s[start + t.len()..].iter().map(|&c| if c == '?' {
                        'a'
                    } else {
                        c
                    }))
                    .collect::<String>()
            })
            .min()
        {
            println!("{}", ans);
        } else {
            println!("UNRESTORABLE");
        }
    }
}


Measured memory_bytes: 4352