#include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define mod 100000007
#define MOD 998244353
#define x first
#define y second
#define db long double

using namespace std;

const int N  =  2e5 + 10, M = 1010, P = 25;

inline void solve() {
int x;
cin >> x;
int ans = 0;
for(int i = 0; i < 32; i ++) {
if(ans +  (1ll << i) <= x) {
ans += (1ll << i);
}
} cout << ans << '\n';
}

signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int _ = 1;
cin >> _;
cout << fixed << setprecision(6);
while(_ --) {
solve();
} return _ ^ _;
}

#include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define mod 100000007
#define MOD 998244353
#define x first
#define y second
#define db long double

using namespace std;

const int N  =  2e5 + 10, M = 1010, P = 25;

struct node {
    int v, x, y, c;
};
int fa[N];

int find(int x) {
    if(fa[x] != x) {
        fa[x] = find(fa[x]);
    } return fa[x];
}

void merge(int x, int y) {
    fa[find(x)] = find(y);
}

bool cmp(const node &a, const node &b) {
    return a.v < b.v;
}

int kruskal(vector<node> &fs, int n) {
    sort(fs.begin(), fs.end(), cmp);
    for(int i = 1; i <= n; i ++) {
        fa[i] = i;
    } int cnt = 0, s = 0, ff = 0;
    for(const auto &f : fs) {
        if(find(f.x) != find(f.y)) {
            merge(f.x, f.y);
            cnt += f.v;
            if(f.c == 0) {
                s ++;
            } ff ++;
            if(ff == n - 1) {
                break;
            }
        }
    } return cnt + s * s;
}

void solve() {
    int n, m;
    cin >> n >> m;
    vector<node> fs(m);
    for(int i = 0; i < m; i ++) {
        cin >> fs[i].x >> fs[i].y >> fs[i].v >> fs[i].c;
    } cout << kruskal(fs, n) << '\n';
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int _ = 1;
    // cin >> _;
    cout << fixed << setprecision(6);
    while(_ --) {
        solve();
    } return _ ^ _;
}

#include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define pdd pair<double, double>
#define mod 100000007
#define MOD 998244353
#define x first
#define y second
// #define db long double
// #define double long double

using namespace std;

const int N = 2e5 + 10, M = 1010, P = 25;

const double eps = 1e-6;

vector<pdd> in;

int sign(double x) {
    if(fabs(x) < eps) {
        return 0;
    } if(x < 0) {
        return -1;
    } return 1;
}

bool operator == (pdd a, pdd b) {
    return !sign(a.x - b.x)&&!sign(a.y - b.y);
}
pdd operator - (pdd a, pdd b) {
    return pdd(a.x - b.x, a.y - b.y);
}
pdd operator + (pdd a, pdd b) {
    return pdd(a.x + b.x, a.y + b.y);
}
double operator ^ (pdd a, pdd b) {
    return a.x * b.y - a.y * b.x;
}
double operator * (pdd a, pdd b) {
    return a.x * b.x + a.y * b.y;
}
pdd operator * (pdd a, double b) {
    return pdd(a.x * b, a.y * b);
}
pdd operator / (pdd a, double b) {
    return pdd(a.x / b, a.y / b);
}
static double cross(pdd a,pdd b) {
    return a.x * b.y - a.y * b.x;
}
static double dot(pdd a,pdd b) {
    return a.x * b.x + a.y * b.y;
}

static double dis2(pdd a, pdd b){
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
double dis(pdd a, pdd b){
    return sqrt((a.x - b.x) * (a.x - b.x) * 1.0 + (a.y - b.y) * (a.y - b.y) * 1.0);
}
double culk(pdd a, pdd b){
    return (a.y - b.y) / (a.x - b.x);
}

void quicksort(int l, int r) {               //快排 
    if(l<r) {
        swap(in[l], in[(l + r) / 2]);
        int i = l, j = r;
        pdd x = in[l];
        while(i < j) {
            while(i < j&&(cross(in[j] - in[0], x - in[j]) < 0||(cross(in[j] - in[0], x - in[j]) == 0&&dis2(in[j], in[0]) > dis2(x, in[0])))) {
                j--;
            } if(i < j) {
                in[i ++] = in[j];
            } while(i < j&&(cross(in[i] - in[0], x - in[i]) > 0||(cross(in[i] - in[0], x - in[i]) == 0&&dis2(in[i], in[0]) < dis2(x, in[0])))) {
                i++;
            } if(i < j) {
                in[j --] = in[i];
            }
        } in[i] = x;
        quicksort(l, i - 1);
        quicksort(i + 1, r);
    }
}
void convexHell() {                          //查找凸包上的点 
    int ori = 0;
    for(int i = 0; i < in.size(); i ++) {
        if(in[i].y < in[ori].y||(in[i].y == in[ori].y&&in[i].x < in[ori].x)) {
            ori = i;
        }
    } swap(in[0], in[ori]);
    quicksort(1, in.size() - 1);
    vector<pdd> tmp(in.size() + 10);
    int nw = -1;
    for(int i = 0; i < in.size(); i ++) {
        while(nw >= 1) {
            if(cross(tmp[nw] - tmp[nw - 1], in[i] - tmp[nw]) > 0) {
                break;
            } else if(cross(tmp[nw] - tmp[nw - 1],  in[i] - tmp[nw]) == 0) {
                nw --;
                break;
            } else {
                nw --;
            }
        } tmp[++ nw] = in[i];
    } in.clear();
    for(int i = 0; i <= nw; i ++) {
        in.emplace_back(tmp[i]);
    }
}

void cularea() {                       //计算面积
    convexHell();
    double ans = 0;
    for(int i = 0; i < in.size(); i ++){
        ans += cross(in[i], in[(i + 1) % in.size()]);
    } cout << ans / 2.0  << '\n';
}

inline void solve() {
    int n;
    cin >> n;
    pdd l = {1e7, 0}, r = {0, 0};
    for(int i = 0; i < n; i ++) {
        pdd t;
        cin >> t.x >> t.y;
        l.x = min(l.x, t.x);
        r.x = max(r.x, t.x);
        in.emplace_back(t);
    } in.emplace_back(l);
    in.emplace_back(r);
    cularea();
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int _ = 1;
    // cin >> _;
    cout << fixed << setprecision(6);
    while(_ --) {
        solve();
    } return _ ^ _;
}

#include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define mod 100000007
#define MOD 998244353
#define x first
#define y second
#define db long double

using namespace std;

const int N  =  2e5 + 10, M = 1010, P = 25;

inline void solve() {
string s;
cin >> s;
int ans = 0;
char c = 'a';
sort(s.begin(), s.end());
for(int i = 0; i < s.size(); i ++) {
ans += abs(s[i] - c) + 1;
c = s[i];
} cout << ans << '\n';
}

signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int _ = 1;
// cin >> _;
cout << fixed << setprecision(6);
while(_ --) {
solve();
} return _ ^ _;
}

#include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define pdd pair<double, double>
#define mod 100000007
#define MOD 998244353
#define x first
#define y second
#define db long double

using namespace std;

const int N  =  2e5 + 10, M = 1010, P = 25;

vector<int> p(P);
vector<bool> st(P);
vector<pdd> f(P);
vector<double> ff(P);
bool ok;
int n;

double get(pdd a, pdd b) {
    double x = a.x - b.x, y = a.y - b.y;
    return sqrt(x * x + y * y);
}

void check() {
    for(int i = 1; i < n; i ++) {
        for(int j = i + 1; j <= n; j ++) {
            double t = get(f[i], f[j]);
            double a = ff[p[i]], b = ff[p[j]];
            if(t > fabs(a - b)&&t < fabs(a + b)) {
                return ;
            }
        }
    } ok = true;
}

void dfs(int u) {
    if(ok) {
        return ;
    } if(u == n + 1) {
        check();
        if(ok) {
            for(int i = 1; i <= n; i ++) {
                cout << p[i] << " \n"[i == n];
            }
        }
        return ;
    } for(int i = 1; i <= n; i ++) {
        if(!st[i]) {
            st[i] = true;
            p[u] = i;
            dfs(u + 1);
            st[i] = false;
        }
    }
}

inline void solve() {
    cin >> n;
    for(int i = 1; i <= n; i ++) {
        cin >> f[i].x >> f[i].y;
    } for(int i = 1; i <= n; i ++) {
        cin >> ff[i];
    } ok = false;
    dfs(1);
    if(!ok) {
        cout << "-1\n";
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int _ = 1;
    // cin >> _;
    cout << fixed << setprecision(6);
    while(_ --) {
        solve();
    } return _ ^ _;
}

#include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define mod 100000007
#define MOD 998244353
#define x first
#define y second
#define db long double

using namespace std;

const int N  =  2e5 + 10, M = 1010, P = 25;

inline void solve() {
int x;
string s;
cin >> x >> s;
if(s == "MiB"){
cout << x * (1ll << 10)  <<  " KiB\n";
} else {
cout << x * 1000 << " KB\n";
}
}

signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int _ = 1;
// cin >> _;
cout << fixed << setprecision(6);
while(_ --) {
solve();
} return _ ^ _;
}

#include <bits/stdc++.h>
int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    #define int long long
    constexpr int N = 123456789LL;
    int tt;
    for (std::cin >> tt; tt--;) {
        int n, d;
        std::cin >> n >> d;
        int k = 123456789LL * std::pow<int>(10, 2 + (int)std::log10<int>(n)) / n + 1;
        auto check = [&](int w) {
            std::vector<int> c(10);
            int num = w * n;
            while (num) c[num % 10] += 1, num /= 10;
            for (int i = 1; i <= 9; ++i) if (c[i] < 1) {
                return false;
            }
            return c[d] >= 2;
        };
        while (!check(k)) k += 1;
        std::cout << k << '\n';
    }
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int n;
    cin >> n;
    vector<tuple<ll , ll>> tl;
    for (int i=1; i<=n; ++ i) {
        int x;
        cin >> x;
        tl.emplace_back(x , -i);
    }
    sort(tl.begin() , tl.end());
    ll ans = 0 , cur = 0 , pre = 0;
    for (auto [a , b] : tl) {
        b = -b;
        if (b >= a && b > pre) {
            ans += (b - cur) / a;
            cur += (b - cur) / a * a;
            pre = b;
        }
        if (b == n) break;
    }
    std::cout << ans << "\n";
}

#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Fenwick {
    int n;
    vector<T> d;
    Fenwick() : n(0) {}
    Fenwick(int n) : n(n), d(n) {}
    void modify(int x, T v) {
        assert(0 <= x && x < n);
        x += 1;
        while (x <= n) {
            d[x - 1] = max(d[x - 1], v);
            x += x & -x;
        }
    }
    T get(int x) {
        assert(x <= n);
        T v = 0;
        while (x > 0) {
            v = max(v, d[x - 1]);
            x -= x & -x;
        }
        return v;
    }
    T get(int l, int r) {
        assert(l <= r);
        return get(r) - get(l);
    }
    int min_right(T k) {
        int r = 0;
        for (int e = __lg(n); ~e; --e) {
            int u = (1 << e);
            if (r + u <= n && d[r + u - 1] < k) {
                k -= d[(r += u) - 1];
            }
        }
        return r;
    }
};
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  #define int long long
  int n;
  cin >> n;
  vector<int> a(n);
  for (int i = 0; i < n; ++i) {
    cin >> a[i];
    --a[i];
  }
  vector<int> l(n, n);
  vector<int> r(n, 0);
  for (int i = 0; i < n; ++i) {
    l[a[i]] = min(l[a[i]], i);
    r[a[i]] = max(r[a[i]], i);
  }
  for (int i = n - 1; i >= 0; ) {
    assert(i == r[a[i]]);
    int j = l[a[i]], k = i;
    while (k >= j) {
      r[a[k]] = i;
      j = min(j, l[a[k]]);
      --k;
    }
    i = k;
  }
  Fenwick<int> fen(n);
  vector<int> dp(n);
  for (int i = 0; i < n; ++i) {
    assert(i == l[a[i]]);
    for (int j = i; j <= r[a[i]]; ++j) {
      if (j == l[a[j]]) {
        dp[l[a[j]]] = fen.get(a[j]) + 1;
      }
    }
    for (int j = i; j <= r[a[i]]; ++j) {
      if (j == l[a[j]]) {
        fen.modify(a[j], dp[l[a[j]]]);
      }
    }
    i = r[a[i]];
  }
  cout << set<int>(a.begin(), a.end()).size() - *max_element(dp.begin(), dp.end()) << "\n";
}

#include <bits/stdc++.h>
int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    std::cout << std::fixed << " " << std::setprecision(20);
    #define int long long
    int tt;
    for (std::cin >> tt; tt--;) {
        int n;
        std::cin >> n;
        std::vector<std::pair<int, int>> p(n);
        for (auto &[x, y] : p) {
            std::cin >> x >> y;
        }
        std::sort(p.begin(), p.end(), 
            [&](const auto& a, const auto& b) {
                return a.first + a.second < b.first + b.second;
            });
        double ans = 0;
        for (int i = 1; i < n; ++i) {
            int d1 = p[i - 1].first - p[i].first, d2 = p[i - 1].second - p[i].second;
            ans = std::max<double>(ans, ((abs(d1) + abs(d2)) * 1. / sqrt(d1 * d1 + d2 * d2)));
        }
        std::sort(p.begin(), p.end(), 
            [&](const auto& a, const auto& b) {
                return a.first - a.second < b.first - b.second;
            });
        for (int i = 1; i < n; ++i) {
            int d1 = p[i - 1].first - p[i].first, d2 = p[i - 1].second - p[i].second;
            ans = std::max<double>(ans, ((abs(d1) + abs(d2)) * 1. / sqrt(d1 * d1 + d2 * d2)));
        }
        std::cout << ans << '\n';
    }
}

#include <bits/stdc++.h>
int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    int n;
    std::cin >> n;
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        std::string s;
        std::cin >> s;
        if (size(s) == 5 && s[2] == s[4] && std::set<char>{s[0], s[1], s[2], s[3]}.size() == 4) {
            ans += 1;
        }
    }
    std::cout << ans << '\n';
}

#include <bits/stdc++.h>
int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    auto bury = [&](std::vector<std::string>& adj, int num, int k) {
        int len = (num + 1) / 2;
        for (int i = 0; i < len; ++i) {
            adj[i][len - i - 1]++;
        }
        for (int i = 0; i < len - 1; ++i) {
            adj[i][len - i - 2]++;
        }
        adj[k][k] += num % 2 == 0;
    };
    int tt;
    for (std::cin >> tt; tt--;) {
        int n, m;
        std::cin >> n >> m;
        std::vector<std::string> ans(n, std::string(n, '0'));
        if (m <= 2 * n) {
            if (n == 5 && m == 10) {
                for (int i = 0; i < n; ++i) {
                    for (int j = 0; j < i; ++j) {
                        ans[j][n - i - 1]++;
                    }
                }
            } else bury(ans, m, n - 1);
        } else {
            int now = n;
            while (m >= 2 * now + 1 && now) {
                m -= 2 * now - 1;
                now--;
                for (int i = 0; i < now; ++i) {
                    ans[i][now]++, ans[now][i]++;
                }
                ans[now][now]++;
            }
            if (m >= 2 && m < 2 * now - 1) {
                ans[0][now - 1]++, ans[now - 1][0]++;
                m -= 2;
            }
            if (m) {
                if (now == 5 && m == 10) {
                    for (int i = 0; i < now; ++i) {
                        for (int j = 0; j < i; ++j) {
                            ans[j][now - i - 1]++;
                        }
                    }
                } else if (now == 3 && m == 1) {
                    ans[now - 1][now - 1]++;
                } else if (now == 4 && m == 8) {
                    bury(ans, m, now - 1);
                    ans[0][0]++, ans[now - 1][now - 1]--;
                } else {
                    if ((now == 4 && (m == 3 || m == 4)) || (now == 3 && m == 2) || (now == 5 && m == 5)) {
                        ans[0][now - 1]--, ans[now - 1][0]--;
                        if (now == 4 && m == 4) {
                            ans[now - 1][now - 1]--;
                            ans[0][0]++;
                        }
                        m += 2;
                    }
                    if (now >= 5) {
                        if (now - (m + 1) / 2 == 2) {
                            ans[now - 2][now - 1]++, ans[now - 1][now - 2]++;
                            m -= 2;
                        }
                        if ((m & 1) && !(now == 5 && m == 9)) {
                            m += 1;
                            ans[n - 1][n - 1]--;
                        }
                    }
                    if (m) {
                        bury(ans, m, now - 1);
                    }
                }
            } else if (now == 3 || now == 2) {
                ans[0][now - 1]--, ans[now - 1][0]--;
                ans[1][1]++, ans[0 + 2 * (now == 3)][0 + 2 * (now == 3)]++;
            }
        }
        std::cout << "Yes" << '\n';
        for (int i = 0; i < n; ++i) {
            std::cout << ans[i] << "\n";
        }
    }
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll mod = 998244353;

//快速幂
constexpr int P = 998244353; 
ll ksm(ll a , ll b) {
    ll res = 1;
    while (b) {
        if (b & 1) res = (ll)res * a % P;
        a = (ll)a * a % P; 
        b >>= 1;
    }
    return res;
}
int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    ll n , pren = 0 , fenzi = 1 , fenmu = 1;
    cin >> n;
    n *= 2;
    priority_queue <ll, vector<ll>, greater<ll>> ql;
    vector<ll> a(n+2);
    map<ll , ll> mp; 
    for (int i=1; i <= n; ++ i) {
        cin >> a[i];
        if (a[i] == -1) {
            ll len = (ll)ql.size();
            fenmu = fenmu % mod * len % mod;
            fenzi = fenzi % mod * mp[ql.top()] % mod;
            pren = max(ql.top() , pren);
            mp[ql.top()]--;
            ql.pop();
        } else if (a[i] != -1) {
            ql.push(a[i]);
            mp[a[i]] ++;
            if (a[i] < pren) {
                fenzi = 0;
            }
        }
    } 
    ll ans = fenzi * ksm(fenmu , mod - 2) % mod;
    std::cout << ans << "\n";
}

#include <bits/stdc++.h>
using ULL = unsigned long long;
int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    int tt;
    for (std::cin >> tt; tt--;)[&] {
        int n, k;
        std::cin >> n >> k;
        std::string s;
        std::cin >> s;
        constexpr int P = 131;
        std::vector<ULL> h(n + 1), p(n + 1);
        p[0] = 1;
        for (int i = 0; i < n; ++i) {
            h[i + 1] = h[i] * P + s[i];
            p[i + 1] = p[i] * P; 
        }
        auto get = [&](int l, int r) { 
            return h[r] - h[l - 1] * p[r - l + 1];
        };
        auto lcp = [&](int a, int b) {
            int l = 0, r = n - b;
            while (l < r) {
                int mid = l + r >> 1;
                if (get(a + 1, a + 1 + mid) == get(b + 1, b + 1 + mid)) {
                    l = mid + 1;
                } else {
                    r = mid;
                }
            }
            return r;
        };
        std::vector<int> vis(n);
        for (int p = n / 4 + 1; p <= n / 2; ++p) {
            int cost = 0;
            for (int i = p; i < n && cost <= k; ++i) {
                i += lcp(i - p, i);
                if (i == n) break;
                int x = i % p;
                if (vis[x] != p) {
                    vis[x] = p;
                    std::vector<int> cnt(26);
                    int res = 0, tot = 0;
                    for (int j = x; j < n; j += p) {
                        tot += 1;
                        res = std::max(res, ++cnt[s[j] - 'a']);
                    }
                    cost += tot - res;
                }
            }
            if (cost <= k) {
                std::cout << "Yes" << '\n';
                return ;
            }
        }
        std::cout << "No" << '\n';
    } ();
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
//线性筛
constexpr int maxn = 1e6 + 10; 
int pnl[maxn + 10], cnt;//pnl
int st[maxn + 10];//索引为质数值就是0
void init_primes() {
    st[0]=1;
    st[1]=1;
    for (int i=2; i <= maxn; ++i) {
        if (st[i] == 0){
            pnl[cnt++] = i;
        }
        for (int j=0; pnl[j] <= maxn/i; ++j){
            st[pnl[j]*i] = 1;
            if (i%pnl[j] == 0) {
                break;
            }
        }
    }
}
int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    init_primes();

    int tt = 1;
    cin >> tt;
    while (tt--) [&]{
        int n , res;
        cin >> n;
        vector<int> cur(5);
        for (int j=4; j>=0; -- j) { 
            cur[j] = n % 10;
            n /= 10;
        }
        sort(cur.begin(), cur.end());
        do {
            int nn = 0;
            for (int j=0; j < 5; ++ j) {
                nn = nn * 10 + cur[j];
            }
            if (1e4 <= nn && st[nn] == 1) {
                std::cout << nn << '\n';
                return ;
            }
        } while (next_permutation(cur.begin() , cur.end()));
        std::cout << -1 << '\n';
    }();
}

#include <bits/stdc++.h>
struct DSU {
    std::vector<int> p, siz;
    DSU(int n) : p(n), siz(n, 1) { std::iota(p.begin(), p.end(), 0); }
    int leader(int x) {
        while (x != p[x]) x = p[x] = p[p[x]];
        return x;
    }
    bool same(int x, int y) { return leader(x) == leader(y); }
    bool merge(int x, int y) {
        x = leader(x), y = leader(y);
        if (x == y) return false;
        siz[x] += siz[y], p[y] = x;
        return true;
    }
    int size(int x) { return siz[leader(x)]; }
};
int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    int tt;
    for (std::cin >> tt; tt--;) {
        int n;
        std::cin >> n;
        std::vector<int> val(n);
        for (int i = 0; i < n; ++i) {
            std::cin >> val[i];
        }
        DSU dsu(n);
        std::vector<std::pair<int, int>> edges;
        for (int i = 0; i < n - 1; ++i) {
            int a, b;
            std::cin >> a >> b;
            a--, b--;
            int num = (val[a] * 2 >= val[b]) + (val[b] * 2 >= val[a]);
            if (num == 2) {
                dsu.merge(a, b);
            } else {
                if (val[a] * 2 <= val[b]) {
                    edges.emplace_back(a, b);
                } else {
                    edges.emplace_back(b, a);
                }
            }
        } 
        std::vector<int> d(n);
        std::vector<bool> use(n);
        for (auto [x, y] : edges) {
            x = dsu.leader(x), y = dsu.leader(y);
            use[x] = use[y] = true;
            d[y] += 1;
        }
        if (dsu.size(0) == n) {
            std::cout << n << '\n';
        } else {
            int root = -1, num = 0;
            for (int i = 0; i < n; ++i) {
                if (d[i] == 0 && use[i]) {
                    root = i;
                    num += 1;
                } 
            }
            if (num == 1) {
                std::cout << dsu.size(root) << '\n';
            } else {
                std::cout << 0 << '\n';
            }
        }
    }
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  #define int long long
  int n, m;
  cin >> n >> m;
  vector<int> a(m);
  for (int i = 0; i < m; ++i) {
    cin >> a[i];
  }
  auto power = [&](int x) {
    return x * x * x * x;
  };
  vector<int> dp(m + 1, 0);
  for (int i = 1; i <= m; ++i) {
    dp[i] = 2e18;
    for (int j = max<int>(0, i - 400); j < i; ++j) {
      dp[i] = min<int>(dp[i] , dp[j] + a[i - 1] + power(i - j));
    }
  }
  cout << dp[m] << '\n';
}

#include <bits/stdc++.h>
int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    #define int long long
    int tt;
    for (std::cin >> tt; tt--;) {
        int n;
        std::cin >> n;
        std::vector<int> a(n), b(n);
        for (int i = 0; i < n; ++i) {
            std::cin >> a[i];
        }
        for (int i = 0; i < n; ++i) {
            std::cin >> b[i];
        }
        auto check = [&](int k) {
            int x = k * b[0];
            int L = a[0] - x, R = a[0] + x;
            for (int i = 1; i < n; ++i) {
                x = k * b[i];
                int l = a[i] - x, r = a[i] + x;
                if (r < L || l > R) {
                    return false;
                } else {
                    L = std::max(L, l);
                    R = std::min(R, r);
                }
            }
            return true;
        };
        int l = 0 , r = 1e9;
        while(l < r) {
            int mid = l + r >> 1;
            if (check(mid)) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        std::cout << r << '\n';
    }
}