You are given two strings s and t consisting of small Latin letters, string s can also contain '?' characters. 

Suitability of string s is calculated by following metric:

Any two letters can be swapped positions, these operations can be performed arbitrary number of times over any pair of positions. Among all resulting strings s, you choose the one with the largest number of non-intersecting occurrences of string t. Suitability is this number of occurrences.

You should replace all '?' characters with small Latin letters in such a way that the suitability of string s is maximal.

Input

The first line contains string s (1 ≤ |s| ≤ 106).

The second line contains string t (1 ≤ |t| ≤ 106).

Output

Print string s with '?' replaced with small Latin letters in such a way that suitability of that string is maximal.

If there are multiple strings with maximal suitability then print any of them.

Examples

Input

?aa?
ab


Output

baab


Input

??b?
za


Output

azbz


Input

abcd
abacaba


Output

abcd

Note

In the first example string "baab" can be transformed to "abab" with swaps, this one has suitability of 2. That means that string "baab" also has suitability of 2.

In the second example maximal suitability you can achieve is 1 and there are several dozens of such strings, "azbz" is just one of them.

In the third example there are no '?' characters and the suitability of the string is 0.
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;

public class Contest {
	private static int sNext;
	private static final int EOF = -1;
	private static InputStream sIn = System.in;
	private static final String LINE_SEPARATOR = System.getProperty("line.separator");
	private static BufferedWriter sOut = new BufferedWriter(new OutputStreamWriter(System.out));

	private Contest() throws Exception {
		sNext = sIn.read();
		solve();
		sIn.close();
		sOut.close();
	}

	public static void main(String[] args) {
		try {
			new Contest();
		} catch (Exception e) {
			try {
				sIn.close();
				sOut.close();
			} catch (IOException ioe) {
				ioe.printStackTrace();
			}
			e.printStackTrace();
		}
	}

	private boolean digit(int cp) {
		return cp >= '0' && cp <= '9';
	}

	private boolean whitespace(int cp) {
		return cp == ' ' || cp == '\t' || cp == '\r' || cp == '\n';
	}

	private boolean lineSeparator(int cp) {
		return cp == '\n' || cp == '\r';
	}

	private boolean wordSeparator(int cp) {
		return cp == ' ' || cp == '\t';
	}

	private Integer ni() throws IOException {
		while (whitespace(sNext)) sNext = sIn.read();
		int num = 0, sign = (sNext == '-') ? '-' : '+';
		if (sign == '-') sNext = sIn.read();
		if (!digit(sNext)) return null;
		while (true) {
			num = (num << 1) + (num << 3) + sNext - '0';
			if (!digit(sNext = sIn.read())) break;
		}
		return (sign == '-') ? -num : num;
	}

	private int[] nis() throws IOException {
		while (whitespace(sNext)) sNext = sIn.read();
		List<Integer> list = new ArrayList<>();
		while (!lineSeparator(sNext)) {
			Integer num = ni();
			if (num == null) break;
			list.add(num);
			while (wordSeparator(sNext)) sNext = sIn.read();
		}
		int n = list.size();
		if (n < 1) return null;
		int a[] = new int[n];
		for (int i = 0; i < n; ++i)
			a[i] = list.get(i);
		return a;
	}

	private int[] nis(int n) throws IOException {
		int a[] = new int[n];
		for (int i = 0; i < n; ++i)
			a[i] = ni();
		return a;
	}

	private int[][] nis(int r, int c) throws IOException {
		int a[][] = new int[r][c];
		for (int i = 0; i < r; ++i)
			a[i] = nis(c);
		return a;
	}

	private Long nl() throws IOException {
		while (whitespace(sNext)) sNext = sIn.read();
		long num = 0, sign = (sNext == '-') ? '-' : '+';
		if (sign == '-') sNext = sIn.read();
		if (!digit(sNext)) return null;
		while (true) {
			num = (num << 1) + (num << 3) + sNext - '0';
			if (!digit(sNext = sIn.read())) break;
		}
		return (sign == '-') ? -num : num;
	}

	private long[] nls() throws IOException {
		while (whitespace(sNext)) sNext = sIn.read();
		List<Long> list = new ArrayList<>();
		while (!lineSeparator(sNext)) {
			Long num = nl();
			if (num == null) break;
			list.add(num);
			while (wordSeparator(sNext)) sNext = sIn.read();
		}
		int n = list.size();
		if (n < 1) return null;
		long a[] = new long[n];
		for (int i = 0; i < n; ++i)
			a[i] = list.get(i);
		return a;
	}

	private long[] nls(int n) throws IOException {
		long a[] = new long[n];
		for (int i = 0; i < n; ++i)
			a[i] = nl();
		return a;
	}

	private long[][] nls(int r, int c) throws IOException {
		long a[][] = new long[r][c];
		for (int i = 0; i < r; ++i)
			a[i] = nls(c);
		return a;
	}

	private Double nd() throws IOException {
		double first = ni(), second;
		if (sNext != '.') return first;
		int res = 0, cnt = 0;
		while (true) {
			if (!digit(sNext = sIn.read())) break;
			cnt++;
			res = (res << 1) + (res << 3) + sNext - '0';
		}
		second = res * StrictMath.pow(10, -cnt);
		return (first < 0.0) ? first - second : first + second;
	}

	private double[] nds() throws IOException {
		List<Double> list = new ArrayList<>();
		while (!lineSeparator(sNext)) {
			Double num = nd();
			if (num == null) break;
			list.add(num);
			while (wordSeparator(sNext)) sNext = sIn.read();
		}
		int n = list.size();
		if (n < 1) return null;
		double a[] = new double[n];
		for (int i = 0; i < n; ++i)
			a[i] = list.get(i);
		return a;
	}

	private double[] nds(int n) throws IOException {
		double a[] = new double[n];
		for (int i = 0; i < n; ++i)
			a[i] = nd();
		return a;
	}

	private double[][] nds(int r, int c) throws IOException {
		double a[][] = new double[r][c];
		for (int i = 0; i < r; ++i)
			a[i] = nds(c);
		return a;
	}

	private String ns() throws IOException {
		while (whitespace(sNext)) sNext = sIn.read();
		if (sNext == EOF) return null;
		StringBuilder sb = new StringBuilder();
		while (true) {
			sb.append((char) sNext);
			if ((sNext = sIn.read()) == EOF || whitespace(sNext)) break;
		}
		return sb.toString();
	}

	private String[] nss() throws IOException {
		List<String> list = new ArrayList<>();
		while (!lineSeparator(sNext)) {
			String str = ns();
			if (str == null) break;
			list.add(str);
			while (wordSeparator(sNext)) sNext = sIn.read();
		}
		int n = list.size();
		if (n < 1) return null;
		String a[] = new String[n];
		for (int i = 0; i < n; ++i)
			a[i] = list.get(i);
		return a;
	}

	private String[] nss(int n) throws IOException {
		String a[] = new String[n];
		for (int i = 0; i < n; ++i)
			a[i] = ns();
		return a;
	}

	private String[][] nss(int r, int c) throws IOException {
		String a[][] = new String[r][c];
		for (int i = 0; i < r; ++i)
			a[i] = nss(c);
		return a;
	}

	private StringBuilder line() throws IOException {
		while (whitespace(sNext)) sNext = sIn.read();
		if (sNext == EOF) return null;
		StringBuilder sb = new StringBuilder();
		while (true) {
			sb.append((char) sNext);
			if ((sNext = sIn.read()) == EOF || lineSeparator(sNext)) break;
		}
		return sb;
	}

	private char[] ncs(int n) throws IOException {
		while (whitespace(sNext)) sNext = sIn.read();
		char a[] = new char[n];
		for (int i = 0; i < n; ++i) {
			a[i] = (char) sNext;
			sNext = sIn.read();
		}
		return a;
	}

	private char[][] ncs(int r, int c) throws IOException {
		char a[][] = new char[r][c];
		for (int i = 0; i < r; ++i)
			a[i] = ncs(c);
		return a;
	}

	private void print(char[] cbuf) {
		try {
			sOut.write(cbuf, 0, cbuf.length);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void println(char[] cbuf) {
		try {
			sOut.write(cbuf, 0, cbuf.length);
			sOut.write(LINE_SEPARATOR);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private <T> void print(T obj) {
		try {
			String s = (String) obj;
			sOut.write(s, 0, s.length());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private <T> void print(String format, Object... args) {
		try {
			if (args != null) format = String.format(format, args);
			sOut.write(format, 0, format.length());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private <T> void println(T obj) {
		try {
			String s = obj + LINE_SEPARATOR;
			sOut.write(s, 0, s.length());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private <T> void println(String format, Object... args) {
		try {
			if (args != null) format = String.format(format, args);
			format += LINE_SEPARATOR;
			sOut.write(format, 0, format.length());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private <T> void debug(T obj) {
		try {
			String s = "\u001B[31m" + obj + "\u001B[0m" + LINE_SEPARATOR;
			sOut.write(s, 0, s.length());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void debug(String format, Object... args) {
		if (args != null) format = String.format(format, args);
		debug(format);
	}

	private void solve() throws Exception {
		char a[] = ns().toCharArray(), b[] = ns().toCharArray();
		int cnta[] = new int[26], cntb[] = new int[26];
		for (char ch : b) cntb[ch - 'a']++;
		for (char ch : a) if (ch != '?') cnta[ch - 'a']++;
		int bullet = 0;
		for (char ch : a) if (ch == '?') bullet++;

		int time = a.length / b.length;
		for (int t = time; t >= 0; --t) {
			long need = 0;
			for (char ch = 'a'; ch <= 'z'; ++ch) {
				if (cnta[ch - 'a'] < cntb[ch - 'a'] * t) need += cntb[ch - 'a'] * t - cnta[ch - 'a'];
			}

			if (need <= bullet) {
				int req[] = new int[26];
				for (char ch = 'a'; ch <= 'z'; ++ch) {
					if (cnta[ch - 'a'] < cntb[ch - 'a'] * t) {
						req[ch - 'a'] = cntb[ch - 'a'] * t - cnta[ch - 'a'];
					} else req[ch - 'a'] = 0;
				}

				int curIndex = 0;
				for (char ch = 'a'; ch <= 'z'; ++ch) {
					while (req[ch - 'a'] > 0) {
						if (a[curIndex++] == '?') {
							a[curIndex - 1] = ch;
							req[ch - 'a']--;
						}
					}
				}
				for (; curIndex < a.length; ++curIndex) {
					if (a[curIndex] == '?') a[curIndex] = 'z';
				}

				println(new String(a));
				break;
			}
		}
	}
}
