#include <bits/stdc++.h>
using namespace std;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
	*this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

const int MAX = 205;
int dp[MAX][MAX]; // 25,000,000 x 4B = 100MB
 
void min_self(int& a, int b) {
	assert(b != -1);
	if(a == -1 || a > b) {
		a = b;
	}
}

int edit_distance(string a, string b) {
	// int cost_replace, cost_insert, cost_erase;
	// cin >> cost_replace >> cost_insert >> cost_erase;
	// memset(dp, -1, sizeof(dp));
	dp[0][0] = 0;
	int A = a.length();
	int B = b.length();
	// for(int i = 0; i <= A; i++) {
		// for(int j = 0; j <= B; j++) {
			// assert(dp[i][j] != -1);
			// if(i < A && j < B)
				// min_self(dp[i+1][j+1], dp[i][j] + (a[i] != b[j]));
			// if(i < A)
				// min_self(dp[i+1][j], dp[i][j] + 1);
			// if(j < B)
				// min_self(dp[i][j+1], dp[i][j] + 1);
		// }
	// }
	
	dp[0][0] = 0;
	for(int i = 0; i <= A; i++) {
		for(int j = 0; j <= B; j++) {
			if(i == 0 && j == 0) {
				continue;
			}
			dp[i][j] = INT_MAX;
			if(i > 0) {
				min_self(dp[i][j], dp[i-1][j] + 1);
			}
			if(j > 0) {
				min_self(dp[i][j], dp[i][j-1] + 1);
			}
			if(i > 0 && j > 0) {
				min_self(dp[i][j], dp[i-1][j-1] + (a[i-1] != b[j-1]));
			}
		}
	}
	return dp[A][B];
}

string get_alpha() {
	string alpha;
	for(int i = 0; i < 26; ++i) {
		alpha += char('a' + i);
	}
	for(int i = 0; i < 26; ++i) {
		alpha += char('A' + i);
	}
	for(int i = 0; i < 10; ++i) {
		alpha += char('0' + i);
	}
	return alpha;
}




string hidden = string(128, 'a'); //"kaksdkkkamiliscool123AGBQEOITUZsadkfjsasfdasdfQEIRUTQEQETQWQWQWQWRQRWQWRQWRAAAAAAAAasdfasdfasdf23452332352233131241241211111";

int cnt_query = 0;
int query(string s) {
	assert((int) s.length() <= 128);
	++cnt_query;
	// assert(cnt_query <= 849);
	cout << "? " << s << endl;
	int dist;
	cin >> dist;
	return dist;
	// return edit_distance(s, hidden);
}

bool is_subseq(string s, int len_of_hidden) {
	if((int) s.length() > len_of_hidden) {
		return false;
	}
	return query(s) + (int) s.length() == len_of_hidden;
}

int main() {
	string alpha = get_alpha();
	
	hidden.clear();
	for(int i = 0; i < 128; ++i) {
		hidden += alpha[rand() % alpha.size()];
	}
	
	
	// hidden = string(1, 'a');
	// hidden = alpha;
	int len = 0;
	set<int> existing;
	for(char ch : alpha) {
		int a = query(string(1, ch));
		existing.insert(a);
		len = max(len, a);
	}
	if((int) existing.size() == 1) {
		len++;
	}
	debug() << imie(len) imie(hidden.length());
	
	vector<string> huffman;
	for(int ic = 0; ic < (int) alpha.size(); ++ic) {
		string full(len, alpha[ic]);
		int my_count = len - query(full);
		string repeated = string(my_count, alpha[ic]);
		// char ch = alpha[ic];
		// string repeated;
		// while(true) {
			// repeated += ch;
			// if(!is_subseq(repeated, len)) {
				// repeated.pop_back();
				// break;
			// }
		// }
		if(!repeated.empty()) {
			huffman.push_back(repeated);
			debug() << imie(repeated);
		}
	}
	
	debug() << imie(huffman);
	
	while((int) huffman.size() >= 2) {
		sort(huffman.begin(), huffman.end(), [](string a, string b) {
			return a.length() > b.length();
		});
		string a = huffman.back();
		huffman.pop_back();
		string b = huffman.back();
		huffman.pop_back();
		
		// if(a.size() < b.size()) {
			// swap(a, b);
		// }
		
		debug() << imie(a) imie(b);
		// assert(is_subseq(a, len));
		// assert(is_subseq(b, len));
		
		for(int i = 0; i <= (int) a.size(); ++i) {
			while(!b.empty()) {
				a.insert(a.begin() + i, b[0]);
				if(i == (int) a.size() - 1 || is_subseq(a, len)) {
					b.erase(b.begin());
					i++;
				}
				else {
					a.erase(a.begin() + i);
					break;
				}
			}
		}
		debug() << imie(a) imie(b) imie(hidden);
		assert(b.empty());
		huffman.push_back(a);
	}
	cout << "! " << huffman[0] << endl;
	// assert(huffman[0] == hidden);
	cerr << "queries: " << cnt_query << endl;
	
	/*
	Huffman codes
	
	4 x a
	5 x c
	6 x d
	10 x e
	5 x ef
	
	.afbcddee
	fffggghhhh
	
	4+2 queries?
	
	
	asdfasdfaaa len=11
	dafad len=5 edit_distance = 6
	
	for(char ch : alpha) {
		
		
	}*/
}


// 100
// a -> 99
// ab -> 98
// aaaaaaaaaaaaaaaaaaaaaaaaaaaaa
// aaaaaaaaaaaaaabbbbbbbbbbbbbbb
// 62*log(L) = 500




Measured memory_bytes: 3716