#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
using ll = long long;
using ul = unsigned long;
using ld = long double;
using st = string;
using mint = atcoder::modint998244353;
using Mint = atcoder::modint1000000007;
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vd vector<ld>
#define vvd vector<vector<ld>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define vs vector<string>
#define vp vector<pair<ll,ll>>
#define vvp vector<vector<pair<ll,ll>>>
#define vm vector<mint>
#define vvm vector<vector<mint>>
#define vM vector<Mint>
#define vvM vector<vector<Mint>>
#define cmx(n,v) n=n<v?v:n
#define cmn(n,v) n=n>v?v:n
#define all(n) begin(n),end(n)
#define nxp(a) next_permutation(all(a))
#define rev(n) reverse(all(n))
#define sor(n) stable_sort(all(n))
#define rep(i,n) for(ll i=0;i<(n);++i)
#define reprev(i,n) for(ll i=n-1;0<=i;--i)
#define rrep(i,a,n) for(ll i=a;i<(n);++i)
#define sz(n) n.size()
#define bit(j,i) (i&(1<<j))
#define yn(x) cout << (x?"Yes":"No") << endl;
#define lb(a,n) lower_bound(a.begin(),a.end(),n)-a.begin()
#define ub(a,n) upper_bound(a.begin(),a.end(),n)-a.begin()
#define lb2(a,n) *lower_bound(a.begin(),a.end(),n)
#define ub2(a,n) *upper_bound(a.begin(),a.end(),n)
#define mn_e1(a) min_element(all(a))
#define mx_e1(a) max_element(all(a))
#define mn_e2(a) *min_element(all(a))
#define mx_e2(a) *max_element(all(a))
#define uniq(a) {sort(all(a)); (a).erase(unique(all(a)), (a).end());}

const ll inf = 9e18;

ll calc_digit(ll N){
    ll res = 0;
    while(N>0){
        res++;
        N/=10;
    }
    return res;
}

ll factorial(ll n, ll mod = 1e18) {
    ll ans = 1;
    for(ll i = n; i >= 2; i--) ans = (ans * i) % mod;
    return ans;
}

ll round_up(ll x,ll y){
    return (x+y-1)/y;
}

ll floor_int(ll x,ll m){
    ll r=(x%m+m)%m; //負の剰余を正の剰余に置き換える
    return (x-r)/m; //return
}

ll rmd(ll x,ll m){
    ll r=(x%m+m)%m; //負の剰余を正の剰余に置き換える
    return r;
}

ll bubble_sort(vl& a,ll& n){
    ll res=0;
    rep(i,n-1){
        for(ll j=n-1;j>i;j--){
            if(a[j-1]>a[j]){
                swap(a[j-1],a[j]);
                res++;
            }
        }
    }
    return res;
}

ll sum_v(vl a){
    ll res=0;
    ll n=sz(a);
    rep(i,n) res+=a[i];
    return res;
}

bool is_prime(int N){
    if(N <= 2) return N==2;
    if(N%2 == 0) return false;
    for(int p=3; p*p<=N; p+=2) if(N%p == 0) return false;
    return true;
}

bool in_out(ll x,ll y,ll h,ll w){
    return 0<=x and x<h and 0<=y and y<w;
}

bool dis_solve1(ll x1,ll x2,ll y1,ll y2,ll r){
    ll xx=(x1-x2),yy=(y1-y2);
    ll dis=xx*xx+yy*yy;
    return (r*r==dis);
}

bool dis_solve2(ll x1,ll x2,ll y1,ll y2,ll d1,ll d2){
    ll xx=(x1-x2),yy=(y1-y2),r1=(d1+d2),r2=(d1-d2);
    ll dis=xx*xx+yy*yy;
    return (r2*r2<=dis&&dis<=r1*r1);
}

void printl(vl v){
    ll vsz=v.size();
    for(ll i=0;i<vsz;i++){
        cout << v[i] << endl;
    }
}


void prints(vs v){
    ll vsz=v.size();
    for(ll i=0;i<vsz;i++){
        cout << v[i] << endl;
    }
}

vl p_list(ll n){
    vl res;
    vb check(n+1);
    for(ll i=2;i<=n;i++){
        if(check[i]) continue;
        res.push_back(i);
        ll ii=i;
        while(ii<=n){
            check[ii]=true;
            ii+=i;
        }
    }
    return res;
}

vl cumulative_sum(vl a){
    ll s=sz(a);
    vl b(s+1,0);
    for(ll i=0;i<s;i++){
        b[i+1]=a[i]+b[i];
    }
    return b;
}

vl n_num(ll a,ll n){
    vl res;
    while(a){
        res.push_back(a%n);
        a/=n;
    }
    rev(res);
    return res;
}

vl c_press(vl a){
    ll n=sz(a);
    vl res=a,c=a;
    sor(c);
    uniq(c);
    rep(i,n) res[i]=lb(c,res[i]);
    return res;
}

vvl to_grid(vl &a,ll k){
    ll n=sz(a);
    ll m=(n+k-1)/k;
    vvl b(k,vl(m,inf));
    rep(i,n) b[i%k][i/k]=a[i];
    return b;
}

vp prime_factorize(ll N){
    vp res;
    for (ll a = 2; a * a <= N; ++a) {
        if (N % a != 0) continue;
        ll ex = 0;
        while (N % a == 0) {
            ex++;
            N /= a;
        }
        res.push_back({a, ex});
    }
    if (N != 1) res.push_back({N, 1});
    return res;
}

struct UnionFind{

    vector<ll> par;
    vector<ll> size;
    
    UnionFind(ll n){
        par.resize(2*(n+1),-1);
        size.resize(2*(n+1),1);
    }

    ll root(ll x){
        if (par[x]==-1) return x;
        return par[x]=root(par[x]);
    }

    void unite(ll u,ll v){
        ll uu=root(u),vv=root(v);
        if(uu==vv){
            return;
        }
        if(size[uu]<size[vv]){
            par[uu]=vv;
            size[vv]+=size[uu];
        }else{
            par[vv]=uu;
            size[uu]+=size[vv];
        }
        return;
    }

    bool same(ll u,ll v){
        return root(u)==root(v);
    }

    ll out_size(ll n){
        return size[root(n)];
    }

};

template<class T, T (*op)(T, T), T (*e)()>
struct SegmentTree{
    int size;
    vector<T> seg;
    SegmentTree(vector<T> v): size((int)v.size()), seg(move(v)){
        seg.insert(seg.begin(), size, T{});
        for(int i = size; --i >= 1; ) seg[i] = op(seg[i << 1], seg[i << 1 | 1]);
    }
    void set(int i, int d, T x){
        assert(0 <= i && i < size);
        i += size;
        seg[i] = x;
        while(void(i >>= 1), d--) seg[i] = op(seg[i << 1], seg[i << 1 | 1]);
    }
    T get(int l, int r) const {
        assert(0 <= l && l <= r && r <= size);
        l += size;
        r += size;
        T ans = e();
        while(l < r){
            if(l & 1) ans = op(ans, seg[l++]);
            if(r & 1) ans = op(ans, seg[--r]);
            l >>= 1;
            r >>= 1;
        }
        return ans;
    }
};

template<class T> struct Edge {
    int from, to;
    T val;
    Edge(int f = -1, int t = -1, T v = -1) : from(f), to(t), val(v) {}
};

// グラフを表す型
template<class T> using Graph = vector<vector<Edge<T>>>;

// サイクル検出ソルバー
template<class T> struct CycleDetection {
    // 入力されたグラフ
    Graph<T> G;
    
    // 探索の様子
    vector<bool> seen, finished;
    vector<Edge<T>> history;
    
    // コンストラクタ
    CycleDetection() { }
    CycleDetection(const Graph<T> &graph) { init(graph); }
    void init(const Graph<T> &graph) {
        G = graph;
        seen.assign(G.size(), false);
        finished.assign(G.size(), false);
    }
    
    // サイクル検出
    // return the vertex where cycle is detected
    int dfs(int v, const Edge<T> &e, bool is_prohibit_reverse = true) {
        seen[v] = true;    // 行きがけ時に true になる
        history.push_back(e);    // 履歴を残す
        for (const Edge<T> &e2 : G[v]) {
            // 逆流を禁止する場合は逆流を禁止する
            if (is_prohibit_reverse && e2.to == e.from) continue;
            
            // 頂点 v2 がすでに探索済みの場合はスキップ
            if (finished[e2.to]) continue;

            // サイクルが検出された
            if (seen[e2.to] && !finished[e2.to]) {
                history.push_back(e2);
                return e2.to;
            }

            // 頂点 v2 を再帰的に探索する
            int pos = dfs(e2.to, e2, is_prohibit_reverse);
            if (pos != -1) return pos;
        }
        finished[v] = true;    // 帰りがけ時に true になる
        history.pop_back();    // 探索が完全に終了した頂点 (赤色) は履歴から除去する
        return -1;
    }
    
    // 履歴からサイクルのみを抽出する関数 (pos：サイクルを検出した頂点)
    vector<Edge<T>> reconstruct(int pos) {
        vector<Edge<T>> cycle;
        
        // 履歴を遡ってサイクルを形作る
        while (!history.empty()) {
            const Edge<T> &e = history.back();
            cycle.push_back(e);
            history.pop_back();
            if (e.from == pos) break;
        }
        
        // サイクルの向きを正順にする
        reverse(cycle.begin(), cycle.end());
        return cycle;
    }
    
    // サイクルを返す関数 (is_prohibit_reverse は逆流を許さないかどうか)
    vector<Edge<T>> detect(bool is_prohibit_reverse = true) {
        int pos = -1;
        for (int v = 0; v < (int)G.size() && pos == -1; ++v) {
            if (seen[v]) continue;
            history.clear();
            pos = dfs(v, Edge<T>(), is_prohibit_reverse);
            if (pos != -1) return reconstruct(pos);
        }
        return vector<Edge<T>>();
    }
};

const int MAX = 510000;
mint fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
    const int MOD = mint::mod();
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i;
        inv[i] = MOD - inv[MOD%i] * (MOD / i);
        finv[i] = finv[i - 1] * inv[i];
    }
}

// 二項係数計算
mint COM(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * finv[k] * finv[n - k];
}

//ll da[4]={1,1,-1,-1};
//ll db[4]={1,-1,-1,1};
//ll na[4]={1,0,1,0};
//ll nb[4]={0,1,0,1};

template <typename T> void input(T &a) { cin >> a; };
template <typename T1, typename... T2> void input(T1&a, T2 &...b) { cin >> a; input(b...); };

template<typename T = ll>
vector<T> rd(size_t n) {
  vector<T> ts(n);
  for (size_t i = 0; i < n; i++) cin >> ts[i];
  return ts;
}

template<typename TV, const ll N> void read_tuple_impl(TV&) {}
template<typename TV, const ll N, typename Head, typename... Tail>
void read_tuple_impl(TV& ts) {
  get<N>(ts).emplace_back(*(istream_iterator<Head>(cin)));
  read_tuple_impl<TV, N + 1, Tail...>(ts);
}
template<typename... Ts> decltype(auto) read_tuple(size_t n) {
  tuple<vector<Ts>...> ts;
  for (size_t i = 0; i < n; i++) read_tuple_impl<decltype(ts), 0, Ts...>(ts);
  return ts;
}

ll di[8]={1,-1,0,0,1,1,-1,-1};
ll dj[8]={0,0,1,-1,1,-1,-1,1};
//std::setprecision(15);
//2^29<10^9

st solve(){
    ll v,x,fo,fi,q,r;
    cin >> v >> x >> fo >> fi >> q >> r;
    
    ll check=x+r*(fi-fo);
    if(v<check) return "Overflow";

    check-=(q-r)*fo;
    if(check<x) return "Zero";
    if(check>x) return "Overflow";
    return "Safe";

}

int main(){
    
    ll t;
    cin >> t;
    while(t--) cout << solve() << endl;

}