#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool solve(int power, const vector<int>& benches, const vector<int>& lampPosts) {
    int n = benches.size();
    int m = lampPosts.size();
    int j = 0;  
    
    for (int i = 0; i < n; ++i) {
        while (j < m && lampPosts[j] + power < benches[i]) {
            ++j;
        }
        if (j >= m || lampPosts[j] - power > benches[i]) {
            return false;
        }
    }
    return true;
}

int findMinPower(int numBenches, int numLampPosts, vector<int>& benches, vector<int>& lampPosts) {
    sort(benches.begin(), benches.end());
    sort(lampPosts.begin(), lampPosts.end());

    int low = 0;
    int high = max(benches.back(), lampPosts.back());  
    while (low < high) {
        int mid = (low + high) / 2;
        if (solve(mid, benches, lampPosts)) {
            high = mid; 
        } else {
            low = mid + 1;  
        }
    }

    return low;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int findKthHighestDiamonds(string houses, int M, int K) {
    vector<int> diamondCounts;
    int n = houses.size();
        if (M > n) {
        return -1;
    }
    int currentDiamonds = 0;
        for (int i = 0; i < M; ++i) {
        if (houses[i] == '1') {
            currentDiamonds++;
        }
    }
        diamondCounts.push_back(currentDiamonds);
        for (int i = M; i < n; ++i) {
        if (houses[i - M] == '1') {
            currentDiamonds--;
        }
        if (houses[i] == '1') {
            currentDiamonds++;
        }
        diamondCounts.push_back(currentDiamonds);
    }
        sort(diamondCounts.begin(), diamondCounts.end(), greater<int>());
        if (K > diamondCounts.size()) {
        return -1;
    }
        return diamondCounts[K - 1];
}

#include <iostream>
#include <string>

using namespace std;

char lastOneStanding(string S, int K) {
    string concatenatedString = "";
    for (int i = 0; i < K; i++) {
        concatenatedString += S;
    }
        int removeFromStart = 1; 
    
    while (concatenatedString.length() > 1) {
        string newString = "";
        int len = concatenatedString.length();
        
        if (removeFromStart) {
            for (int i = 1; i < len; i += 2) {
                newString += concatenatedString[i];
            }
        } else {
            for (int i = len - 2; i >= 0; i -= 2) {
                newString = concatenatedString[i] + newString;
            }
        }
        
        concatenatedString = newString;
        removeFromStart = 1 - removeFromStart; 
    }
    
    return concatenatedString[0];
}

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

void find_most_frequent_ngram(const string& S, int N) {
    unordered_map<string, int> a;
    int w = 0;
    string d;

    for (int i = 0; i <= S.length() - N; ++i) {
        string ngram = S.substr(i, N);
        a[ngram]++;
        if (a[ngram] > w) {
            w = a[ngram];
            d = ngram;
        }
    }
        cout << d << " " << w << endl;
}

int main() {
    string input, S;
    int N;
    getline(cin, input);
    size_t space_pos = input.find_last_of(' ');
    S = input.substr(0, space_pos);
    N = stoi(input.substr(space_pos + 1));
    find_most_frequent_ngram(S, N);
    
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <queue>
#define fastio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;

int main() {
    fastio;

    int t = 1; 
    while (t--) {
        int n;
        cin >> n;

        vector<int> v(n);
        rep(i, n) cin >> v[i];

        vector<int> sum(n + 1, 0);
        for (int i = 0; i < n; ++i) {
            sum[i + 1] = sum[i] + v[i];
        }

        int maximum = 0;
        for (int i = 1; i <= n; ++i) {
            maximum = max(maximum, (sum[i] + i - 1) / i);
        }

      

        int q;
        cin >> q;

        rep(i, q) {
            int x;
            cin >> x;
            if (x < maximum) {
                cout << -1 << endl;
            } else {
                cout << (sum[n] + x - 1) / x << endl;
            }
        }
    }

    return 0;
}