using namespace std;
int main(void)
{
    int t, n, x, s;
    cin >> t;
    while (t--)
    {
        s = 0;
        cin >> n;
        for (int i = 0; i < n; ++i)
        {
            cin >> x;
            s += x;
        }
        cout << (int)ceil(s / (n * 1.0)) << endl;
    }
}

using namespace std;
int time_spent(int x, int d) { return x + (int)ceil((d * 1.0) / (x + 1)); }
int binary_search(int n, int d) {
  int l = 1;
  int h = d - 1;
  while (l <= h) {
    int mid1 = l + (h - l) / 3;
    int mid2 = h - (h - l) / 3;
    int ans1 = time_spent(mid1, d);
    int ans2 = time_spent(mid2, d);
    if (ans1 <= n or ans2 <= n)
      return 1;
    else {
      if (ans1 < ans2)
        h = mid2 - 1;
      else {
        l = mid1 + 1;
      }
    }
  }
  return -1;
}
bool solve(int n, int d) {
  if (d <= n or binary_search(n, d) != -1)
    return true;
  return false;
}
int main(void) {
  int T;
  cin >> T;
  while (T--) {
    int n, d;
    cin >> n >> d;
    if (solve(n, d))
      cout << "YES" << endl;
    else
      cout << "NO" << endl;
  }
  return 0;
}

using namespace std;
using vi = vector<int>;
int const INF = 1e9;
int const NMAX = 2e5 + 11;
int k, best_cost[NMAX];
deque<int> costs[NMAX];
void build() { fill(best_cost, best_cost + NMAX, INF); }
int query(int x) { return (int)costs[x].size() == k ? best_cost[x] : INF; }
void insert(int x, int cur_cost)
{
    if ((int)costs[x].size() == 0)
        best_cost[x] = 0;
    costs[x].push_back(cur_cost);
    if ((int)costs[x].size() > k)
    {
        best_cost[x] -= costs[x].front();
        costs[x].pop_front();
    }
    best_cost[x] += cur_cost;
}
int solve(vi a)
{
    int ans = INF;
    vi cnt(NMAX, 0);
    vector<vi> best_cost(NMAX, vi(log2(NMAX) + 5, 0));
    sort(a.begin(), a.end());
    for_each(a.rbegin(), a.rend(), [&ans](int ai) {
        for (int i = 0, m = log2(ai) + 2; i < m; ++i, ai /= 2)
        {
            insert(ai, i);
            ans = min(ans, query(ai));
        }
    });
    return ans;
}
int main(void)
{
    ios_base::sync_with_stdio(false), cin.tie(0);
    int n;
    vi a;
    cin >> n >> k;
    a.resize(n);
    for (auto &ai : a)
        cin >> ai;
    build();
    cout << solve(a) << endl;
    return 0;
}

using namespace std;
using vi = vector<int>;
const int NMAX = 2e5 + 11;
struct fenwick
{
    int n;
    vi bit;
    fenwick() {}
    fenwick(int n_) : n(n_ + 1) { bit.assign(n_ + 1, 0); };
    void update(int i, int delta)
    {
        while (i < n)
        {
            bit[i] += delta;
            i += i & -i;
        }
    }
    int psum(int r)
    {
        int ans = 0;
        while (r > 0)
        {
            ans += bit[r];
            r -= r & -r;
        }
        return ans;
    }
    int sum(int l, int r) { return psum(r) - psum(l - 1); }
};
int n, potmeter[NMAX];
fenwick t;
int main(void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int x, y, r, test = 1;
    char type;
    while (cin >> n)
    {
        if (n == 0)
            break;
        else if (test != 1)
            cout << endl;
        t = fenwick(n);
        for (int i = 1; i <= n; ++i)
        {
            cin >> x;
            potmeter[i] = x;
            t.update(i, x);
        }
        cout << "Case " << test << ":" << endl;
        while (cin >> type and type != 'E')
        {
            if (type == 'S')
            {
                cin >> x >> r;
                t.update(x, r - potmeter[x]);
                potmeter[x] = r;
            }
            else if (type == 'M')
            {
                cin >> x >> y;
                cout << t.sum(x, y) << endl;
            }
        }
        cin.ignore(), cin.ignore();
        test += 1;
    }
    return 0;
}

using namespace std;
using ll = long long;
const int NMAX = 4e5 + 11;
ll n, a[NMAX];
ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
ll solve(void)
{
    ll ngcd = a[0], ans = 0;
    for (int i = 1; i < n; ++i)
        ngcd = gcd(ngcd, a[i]);
    for (ll i = 1; i <= sqrt(ngcd); ++i)
    {
        if (ngcd % i == 0)
        {
            if (ngcd / i == i)
                ++ans;
            else
                ans += 2;
        }
    }
    return ans;
}
int main(void)
{
    cin >> n;
    for (int i = 0; i < n; ++i)
        cin >> a[i];
    cout << solve() << endl;
    return 0;
}

using namespace std;
using ll = long long;
using predicate = function<bool(int)>;
int bs(int l, int r, predicate p)
{
    while (l < r)
    {
        int m = l + (r - l) / 2;
        if (p(m))
            r = m;
        else
            l = m + 1;
    }
    return l;
}
ll psum(ll n) { return (n * (n + 1)) / 2; }
int main(void)
{
    int x;
    cin >> x;
    x = abs(x);
    int n = bs(0, 1e9 + 11, [x](ll n) { return x <= psum(n); });
    while (psum(n) % 2 != x % 2)
        ++n;
    cout << n << endl;
    return 0;
}

using namespace std;
using ll = long long;
using iii = array<int, 3>;
int n, m;
vector<iii> edges;
vector<int> visited;
const ll INF = 1e17;
vector<int> bellman_ford(int src)
{
    int x = -1;
    vector<ll> d(n + 1, INF);
    vector<ll> p(n + 1);
    d[src] = 0;
    for (int i = 1; i <= n; ++i)
    {
        bool change = false;
        for (auto [u, v, c] : edges)
        {
            if (d[u] < INF and d[u] + c < d[v])
            {
                visited[u] = visited[v] = true;
                change = true;
                d[v] = max(-INF, d[u] + c);
                p[v] = u;
                if (i == n)
                    x = v;
            }
        }
        if (not change)
            break;
    }
    if (x == -1)
    {
        return {};
    }
    else
    {
        int y = x;
        for (int i = 0; i < n; ++i)
            y = p[y];
        vector<int> ans;
        int cur = y;
        do
        {
            ans.push_back(cur);
            cur = p[cur];
        } while (cur != y);
        ans.push_back(cur);
        reverse(ans.begin(), ans.end());
        return ans;
    }
}
vector<int> get_neg_cycle(void)
{
    for (int u = 1; u <= n; ++u)
    {
        if (not visited[u])
        {
            if (auto ans = bellman_ford(u); not ans.empty())
            {
                return ans;
            }
        }
    }
    return {};
}
int main(void)
{
    cin >> n >> m;
    edges.resize(m);
    visited.assign(n + 1, false);
    for (auto &[u, v, c] : edges)
        cin >> u >> v >> c;
    if (auto ans = get_neg_cycle(); not ans.empty())
    {
        cout << "YES" << endl;
        for (auto x : ans)
            cout << x << " ";
        cout << endl;
    }
    else
    {
        cout << "NO" << endl;
    }
    return 0;
}

using namespace std;
using ll = long long;
using vll = vector<ll>;
using vii = vector<pair<int, int>>;
using viii = vector<array<int, 3>>;
const ll INF = 1e16;
vll dijkstra(vii g[], int n, int src)
{
    vector<long long> distance(n + 1, INF);
    vector<bool> processed(n + 1, false);
    priority_queue<pair<ll, int>> q;
    distance[src] = 0;
    q.push({0, src});
    while (!q.empty())
    {
        int u = q.top().second;
        q.pop();
        if (processed[u])
            continue;
        processed[u] = true;
        for (auto [v, c] : g[u])
        {
            if (distance[u] + c < distance[v])
            {
                distance[v] = distance[u] + c;
                q.push({-distance[v], v});
            }
        }
    }
    return distance;
}
int main(void)
{
    int n, m, u, v, c;
    cin >> n >> m;
    vii g[n + 1], gi[n + 1];
    viii edges(m);
    for (int i = 0; i < m; ++i)
    {
        cin >> u >> v >> c;
        g[u].emplace_back(v, c);
        gi[v].emplace_back(u, c);
        edges[i] = {u, v, c};
    }
    auto from_src = dijkstra(g, n, 1);
    auto to_dst = dijkstra(gi, n, n);
    ll ans = INF;
    for (auto [u, v, c] : edges)
        ans = min(ans, from_src[u] + c / 2 + to_dst[v]);
    cout << ans << endl;
    return 0;
}

using namespace std;
enum event_type
{
    FUEL,
    LEAK,
    GAS,
    MECHANIC,
    GOAL
};
struct event
{
    event_type type;
    int fc;
};
map<int, vector<event>> events_at;
int n;
bool simulate(double tank_vol)
{
    int dist = 0, delta = 0, fc_rate = 0, leak_rate = 0;
    double gas_left = tank_vol;
    vector<event> events;
    for (auto kv : events_at)
    {
        delta = kv.first - dist;
        dist = kv.first;
        events = kv.second;
        gas_left -= ((fc_rate * delta / 100.0) + leak_rate * delta);
        if (gas_left < 0)
            return false;
        for (auto e : events)
        {
            if (e.type == FUEL)
                fc_rate = e.fc;
            else if (e.type == LEAK)
                ++leak_rate;
            else if (e.type == GAS)
                gas_left = tank_vol;
            else if (e.type == MECHANIC)
                leak_rate = 0;
        }
    }
    return true;
}
double bsearch(double l, double r)
{
    while ((r - l) > 0.000000001)
    {
        double mid = (l + r) / 2.0;
        if (simulate(mid))
            r = mid;
        else
            l = mid;
    }
    return l;
}
event_type ecast(string raw_type)
{
    if (raw_type == "Fuel")
        return FUEL;
    if (raw_type == "Leak")
        return LEAK;
    if (raw_type == "Gas")
        return GAS;
    if (raw_type == "Mechanic")
        return MECHANIC;
    else
        return GOAL;
}
int main(void)
{
    int d;
    string cmd, trash;
    while (true)
    {
        cin >> d >> cmd >> trash >> n;
        if (cmd == "Fuel" and n == 0)
            break;
        events_at[d].push_back({ecast(cmd), n});
        while (true)
        {
            cin >> d >> cmd;
            if (cmd == "Fuel" or cmd == "Gas")
                cin >> trash;
            if (cmd == "Fuel")
                cin >> n;
            events_at[d].push_back({ecast(cmd), n});
            if (cmd == "Goal")
                break;
        }
        cout << setprecision(3) << fixed << bsearch(0, INT_MAX) << endl;
        events_at.clear();
    }
    return 0;
}

using namespace std;
using ii = pair<int, int>;
using iic = tuple<int, int, char>;
const int NMAX = 1e3 + 11;
iic directions[4] = {{1, 0, 'D'}, {-1, 0, 'U'}, {0, 1, 'R'}, {0, -1, 'L'}};
ii start, target;
char lab[NMAX][NMAX];
bool visited[NMAX][NMAX];
int n, m;
inline bool valid(int row, int col)
{
    return (row >= 0 and row < n and col >= 0 and col < m and
            lab[row][col] != '#');
}
void reconstruct_path(ii x, const map<ii, pair<ii, char>> &parent)
{
    ii end = x;
    string res = "";
    do
    {
        res += parent.at(end).second;
        end = parent.at(end).first;
    } while (end != start);
    reverse(res.begin(), res.end());
    cout << "YES" << endl;
    cout << res.length() << endl;
    cout << res << endl;
}
void bfs(void)
{
    list<ii> q;
    map<ii, pair<ii, char>> parent;
    visited[start.first][start.second] = 1;
    q.push_back(start);
    while (!q.empty())
    {
        auto [i, j] = q.front();
        q.pop_front();
        for (auto [di, dj, dir] : directions)
        {
            if (valid(i + di, j + dj) and !visited[i + di][j + dj])
            {
                ii x = {i + di, j + dj};
                parent[x] = {{i, j}, dir};
                if (x == target)
                {
                    reconstruct_path(x, parent);
                    return;
                }
                visited[i + di][j + dj] = true;
                q.push_back(x);
            }
        }
    }
    cout << "NO" << endl;
}
int main(void)
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < m; ++j)
        {
            cin >> lab[i][j];
            if (lab[i][j] == 'A')
                start = {i, j};
            else if (lab[i][j] == 'B')
                target = {i, j};
        }
    }
    bfs();
    return 0;
}