ZS the Coder loves to read the dictionary. He thinks that a word is _nice_ if there exists a **substring** (contiguous segment of letters) of it of length 26 where each letter of English alphabet appears exactly once. In particular, if the string has length strictly less than 26, no such substring exists and thus it is not nice.
Now, ZS the Coder tells you a word, where some of its letters are missing as he forgot them. He wants to determine if it is possible to fill in the missing letters so that the resulting word is nice. If it is possible, he needs you to find an example of such a word as well. Can you help him?
## Input
The first and only line of the input contains a single string _s_ (1 ≤ |_s_| ≤ 50 000), the word that ZS the Coder remembers. Each character of the string is the uppercase letter of English alphabet ('A'-'Z') or is a question mark ('?'), where the question marks denotes the letters that ZS the Coder can't remember.
## Output
If there is no way to replace all the question marks with **uppercase letters** such that the resulting word is nice, then print - 1 in the only line.
Otherwise, print a string which denotes a possible nice word that ZS the Coder learned. This string should match the string from the input, except for the question marks replaced with uppercase English letters.
If there are multiple solutions, you may print any of them.
[samples]
## Note
In the first sample case, _ABCDEFGHIJKLMNOPQRZTUVWXYS_ is a valid answer beacuse it contains a substring of length 26 (the whole string in this case) which contains all the letters of the English alphabet exactly once. Note that there are many possible solutions, such as _ABCDEFGHIJKLMNOPQRSTUVWXYZ_ or _ABCEDFGHIJKLMNOPQRZTUVWXYS_.
In the second sample case, there are no missing letters. In addition, the given string does not have a substring of length 26 that contains all the letters of the alphabet, so the answer is - 1.
In the third sample case, any string of length 26 that contains all letters of the English alphabet fits as an answer.
[{"iden":"statement","content":"ZS the Coder 喜欢读字典。他认为一个单词是 _nice_ 的，当且仅当它存在一个长度为 #cf_span[26] 的*子串*（连续的字母段），其中每个英文字母恰好出现一次。特别地，如果字符串长度严格小于 #cf_span[26]，则不存在这样的子串，因此它不是 nice 的。\n\n现在，ZS the Coder 告诉你一个单词，其中一些字母因遗忘而缺失。他想知道是否可以通过填入缺失的字母，使得结果单词是 nice 的。如果可能，他还需要你给出一个这样的单词的例子。你能帮他吗？\n\n输入的第一行且唯一一行包含一个字符串 #cf_span[s]（#cf_span[1 ≤ |s| ≤ 50 000]），即 ZS the Coder 记住的单词。该字符串的每个字符是大写英文字母（'A'-'Z'）或问号（'?'），其中问号表示 ZS the Coder 无法回忆的字母。\n\n如果无法将所有问号替换为*大写英文字母*使得结果单词是 nice 的，则在唯一一行中输出 #cf_span[ - 1]。\n\n否则，输出一个表示 ZS the Coder 可能学到的 nice 单词的字符串。该字符串应与输入字符串一致，只是将问号替换为大写英文字母。\n\n如果有多个解，你可以输出任意一个。"}},{"iden":"input","content":"输入的第一行且唯一一行包含一个字符串 #cf_span[s]（#cf_span[1 ≤ |s| ≤ 50 000]），即 ZS the Coder 记住的单词。该字符串的每个字符是大写英文字母（'A'-'Z'）或问号（'?'），其中问号表示 ZS the Coder 无法回忆的字母。"},{"iden":"output","content":"如果无法将所有问号替换为*大写英文字母*使得结果单词是 nice 的，则在唯一一行中输出 #cf_span[ - 1]。否则，输出一个表示 ZS the Coder 可能学到的 nice 单词的字符串。该字符串应与输入字符串一致，只是将问号替换为大写英文字母。如果有多个解，你可以输出任意一个。"},{"iden":"examples","content":"输入\nABC??FGHIJK???OPQR?TUVWXY?\n输出\nABCDEFGHIJKLMNOPQRZTUVWXYS\n\n输入\nWELCOMETOCODEFORCESROUNDTHREEHUNDREDANDSEVENTYTWO\n输出\n-1\n\n输入\n??????????????????????????\n输出\nMNBVCXZLKJHGFDSAQPWOEIRUYT\n\n输入\nAABCDEFGHIJKLMNOPQRSTUVW??M\n输出\n-1"},{"iden":"note","content":"在第一个样例中，_ABCDEFGHIJKLMNOPQRZTUVWXYS_ 是一个有效答案，因为它包含一个长度为 #cf_span[26] 的子串（本例中为整个字符串），其中包含所有英文字母恰好一次。注意，存在许多可能的解，例如 _ABCDEFGHIJKLMNOPQRSTUVWXYZ_ 或 _ABCEDFGHIJKLMNOPQRZTUVWXYS_。\n\n在第二个样例中，没有缺失的字母，且给定字符串中不存在包含所有字母的长度为 #cf_span[26] 的子串，因此答案为 #cf_span[ - 1]。\n\n在第三个样例中，任何长度为 #cf_span[26] 且包含所有英文字母的字符串都是有效答案。"}]
Let $ s $ be a string of length $ n $, where $ 1 \leq n \leq 50{,}000 $, over the alphabet $ \Sigma = \{A, B, \dots, Z\} \cup \{?\} $. Let $ k = 26 $.
Define:
- $ \mathcal{A} = \{A, B, \dots, Z\} $, the set of 26 uppercase English letters.
- A substring $ s[i:i+k] $ (of length $ k $) is called *perfect* if it contains each letter in $ \mathcal{A} $ exactly once.
**Given:**
- For each position $ i \in \{1, \dots, n\} $, $ s[i] \in \mathcal{A} \cup \{?\} $.
- Let $ Q = \{ i \mid s[i] = ? \} $ be the set of positions with missing letters.
**Objective:**
Determine whether there exists an assignment $ f: Q \to \mathcal{A} $ such that in the resulting string $ s' $, there exists at least one contiguous substring of length $ k $ that is perfect.
If such an assignment exists, output any string $ s' $ obtained by replacing each $ ? $ in $ s $ with a letter in $ \mathcal{A} $, such that $ s' $ contains a perfect substring of length $ k $. Otherwise, output $ -1 $.
**Constraints:**
- For any substring $ s'[i:i+k] $, if $ s[j] \in \mathcal{A} $ for some $ j \in [i, i+k-1] $, then $ s'[j] = s[j] $ (fixed letters cannot be changed).
- Each letter in $ \mathcal{A} $ must appear exactly once in some substring of length $ k $.
**Formal Problem:**
Does there exist an index $ i \in \{1, \dots, n - k + 1\} $ and an assignment $ f: Q \to \mathcal{A} $ such that:
1. $ \forall j \in [i, i+k-1] \cap Q $, $ s'[j] = f(j) \in \mathcal{A} $,
2. $ \forall j \in [i, i+k-1] \setminus Q $, $ s'[j] = s[j] \in \mathcal{A} $,
3. The multiset $ \{ s'[j] \mid j \in [i, i+k-1] \} = \mathcal{A} $ (i.e., all 26 letters appear exactly once),
4. For all $ j \in Q \setminus [i, i+k-1] $, $ s'[j] $ can be assigned arbitrarily in $ \mathcal{A} $ (no constraint beyond being a letter),
5. No letter in $ \mathcal{A} $ appears more than once in $ s'[i:i+k] $ (which is implied by condition 3).
If yes, output any such $ s' $; else, output $ -1 $.