void solve() {
    int n, s;
    cin >> n >> s;
    
    // Necessary: minimum sum is n (all 1s)
    if (s < n) {
        cout << -1 << "\n";
        return;
    }
    
    // Construction: all 1s, then put remainder in first element
    for (int i = 0; i < n; i++) {
        if (i == 0) cout << s - (n - 1);
        else cout << 1;
        cout << " \n"[i == n - 1];
    }
}

// Count transitions (places where adjacent chars differ)
int transitions = 0;
for (int i = 1; i < n; i++) {
    if (s[i] != s[i-1]) transitions++;
}

// Blocks of consecutive same characters
// "00110" has 3 blocks: "00", "11", "0"

// Parity often matters
int zeros = count(s.begin(), s.end(), '0');
int ones = n - zeros;

int solve(string s) {
    int n = s.size();
    // Two targets: "010101..." or "101010..."
    int cost1 = 0, cost2 = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] != ('0' + i % 2)) cost1++;
        if (s[i] != ('1' - i % 2)) cost2++;
    }
    return min(cost1, cost2);
}

// MEX examples:
// MEX({0, 1, 2}) = 3   -- all seats 0-2 taken, first gap is 3
// MEX({0, 2, 3}) = 1   -- seat 1 is missing
// MEX({1, 2, 3}) = 0   -- seat 0 is missing
// MEX({}) = 0           -- nothing taken, first gap is 0

// O(n log n) version using set -- simple but has log factor
int mex(vector<int>& arr) {
    set<int> s(arr.begin(), arr.end());
    int m = 0;
    while (s.count(m)) m++;
    return m;
}

// O(n) version using boolean array -- preferred in contests
// Key insight: MEX of n elements is at most n, so we only need
// a boolean array of size n+1. Any value > n cannot affect MEX.
int mex(vector<int>& arr, int n) {
    vector<bool> present(n + 1, false);
    for (int x : arr) {
        if (x >= 0 && x <= n) present[x] = true;
    }
    for (int i = 0; i <= n; i++) {
        if (!present[i]) return i;
    }
    return n + 1;
}

// Sum of permutation = n*(n+1)/2 (always, regardless of order)
// This means: if you know the sum and one element is missing, subtraction finds it.

// Finding missing element in O(n) time, O(1) space
int missing = n * (n + 1) / 2 - sum;

// Inverse permutation: p[q[i]] = i
vector<int> inv(n + 1);
for (int i = 1; i <= n; i++) {
    inv[p[i]] = i;
}

// Cycle decomposition: follow where each element "wants to go"
// Every permutation decomposes into disjoint cycles.
// Example: p = [2, 3, 1, 5, 4] has cycles (1->2->3->1) and (4->5->4)
// Key insight: minimum swaps to sort a permutation = n - (number of cycles)
vector<bool> visited(n + 1, false);
int numCycles = 0;
for (int i = 1; i <= n; i++) {
    if (!visited[i]) {
        numCycles++;
        int j = i;
        while (!visited[j]) {
            visited[j] = true;
            j = p[j];  // Follow the permutation
        }
    }
}
// Minimum swaps to sort = n - numCycles

// XOR trick (Nim Game)
// If XOR of all piles is 0, second player wins
// Otherwise, first player wins

// Parity trick -- the most common pattern at Div 3/4 level
// If total moves is odd, first player wins
// If even, second player wins
// Example: 5 stones, remove 1 per turn. 5 is odd -> first player wins.

// Greedy games
// First player takes optimal choice each turn

const int MOD = 1e9 + 7;

// Power function (binary exponentiation) -- needed for modular inverse
// Computes base^exp mod MOD in O(log exp) time
long long power(long long base, long long exp) {
    long long result = 1;
    base %= MOD;
    while (exp > 0) {
        if (exp & 1) result = result * base % MOD;
        base = base * base % MOD;
        exp >>= 1;
    }
    return result;
}

// Precompute factorials and their modular inverses
// This allows O(1) nCr queries after O(N) preprocessing
vector<long long> fact(N), inv_fact(N);
void precompute() {
    fact[0] = 1;
    for (int i = 1; i < N; i++)
        fact[i] = fact[i-1] * i % MOD;
    // Compute inverse of largest factorial, then work backwards
    // inv_fact[i] = 1 / i! mod MOD
    inv_fact[N-1] = power(fact[N-1], MOD - 2);  // Fermat's little theorem
    for (int i = N-2; i >= 0; i--)
        inv_fact[i] = inv_fact[i+1] * (i+1) % MOD;
}

// nCr = n! / (r! * (n-r)!) mod MOD
long long C(int n, int r) {
    if (r < 0 || r > n) return 0;  // Guard against invalid inputs
    return fact[n] * inv_fact[r] % MOD * inv_fact[n-r] % MOD;
}

// Sorting by end point for interval scheduling
sort(intervals.begin(), intervals.end(), [](auto& a, auto& b) {
    return a.second < b.second;
});

// Difference array for range updates
// Add +d to [l, r]:
diff[l] += d;
diff[r + 1] -= d;

// Sweep line
// Process events in sorted order
sort(events.begin(), events.end());
int current = 0;
for (auto& [pos, type] : events) {
    current += type;  // +1 for start, -1 for end
    // current = number of active intervals at pos
}

// Always flush output after every query!
// Without flushing, your query sits in a buffer and the judge never sees it.
// Your program then waits for a response that never comes -> TLE.
cout << "? " << query << endl;  // endl flushes automatically

// Or use explicit flush:
cout << "? " << query << "\n" << flush;

// Read response
int response;
cin >> response;

// If response is -1, the judge is telling you something went wrong
// (too many queries, invalid query, etc.) -- exit immediately
if (response == -1) exit(0);

// Submit final answer
cout << "! " << answer << endl;

int lo = 1, hi = n;
while (lo < hi) {
    int mid = (lo + hi) / 2;
    cout << "? " << mid << endl;
    int response;
    cin >> response;
    if (response == 1) hi = mid;
    else lo = mid + 1;
}
cout << "! " << lo << endl;