#include <iostream>
#include <vector>
const double eps = 1e-7;
#include <cassert>
namespace boost {
template <class T>
struct integer_iterator {
    T a;
    bool operator != (integer_iterator const & it) const { return a != it.a; }
    T operator * () const { return a; }
    integer_iterator & operator ++ () { ++ a; return *this; }
    integer_iterator operator ++ (int) { return { a ++ }; }
};
template <class T>
struct integer_range {
    T l, r;
    typedef integer_iterator<T> iterator;
    iterator begin() const { return { l }; }
    iterator end  () const { return { r }; }
};
template <class T>
integer_range<T> irange(T l, T r) { assert (l <= r); return { l, r }; }
template <class T>
struct integer_iterator_with_step {
    T a, d, i;
    bool operator != (integer_iterator_with_step const & it) const { return a != it.a or d != it.d or i != it.i; }
    T operator * () const { return a+d*i; }
    integer_iterator_with_step & operator ++ () { ++ i; return *this; }
    integer_iterator_with_step operator ++ (int) { return { a, d, i ++ }; }
};
template <class T>
struct strided_integer_range {
    T l, r, s;
    typedef integer_iterator_with_step<T> iterator;
    iterator begin() const { return { l, s, 0 }; }
    iterator end  () const { return { l, s, (r - l) / s }; }
};
template <class T>
strided_integer_range<T> irange(T l, T r, T s) { assert (s > 0 ? l <= r : s < 0 ? l >= r : false); return { l, r, s }; }
}
#include <utility>
#include <cmath>
#define ttt template <typename T>
#define pca point<T> const &
ttt struct point { T x, y; };
ttt point<T> operator + (pca a, pca b) { return { a.x+b.x, a.y+b.y }; }
ttt point<T> operator - (pca a, pca b) { return { a.x-b.x, a.y-b.y }; }
ttt point<T> operator - (pca a) { return { -a.x, -a.y }; }
ttt point<T> operator * (T a, pca b) { return { a*b.x, a*b.y }; }
ttt std::pair<T,T> to_pair(pca a) { return { a.x, a.y }; }
ttt bool operator == (pca a, pca b) { return to_pair(a) == to_pair(b); }
ttt bool operator != (pca a, pca b) { return to_pair(a) != to_pair(b); }
ttt bool operator <  (pca a, pca b) { return to_pair(a) <  to_pair(b); }
ttt bool operator <= (pca a, pca b) { return to_pair(a) <= to_pair(b); }
ttt bool operator >= (pca a, pca b) { return to_pair(a) >= to_pair(b); }
ttt bool operator >  (pca a, pca b) { return to_pair(a) >  to_pair(b); }
ttt T length_squared(pca p) { return p.x*p.x + p.y*p.y; }
ttt double length(pca p) { return sqrt(length_squared(p)); }
ttt point<T> normalized(pca a) { return (1 / length(a)) * a; }
ttt T   dot(pca p, pca q) { return p.x * q.x + p.y * q.y; }
ttt T cross(pca p, pca q) { return p.x * q.y - p.y * q.x; }
ttt int ccw(pca a, pca b, pca c) { T x = cross(b - a, c - a); return x > 0 ? 1 : x < 0 ? -1 : 0; }
#undef ttt
#undef pca
template <typename T> std::istream & operator >> (std::istream & input, point<T> & p) { return input >> p.x >> p.y; }
template <typename T> std::ostream & operator << (std::ostream & output, const point<T> & p) { return output << p.x << ' ' << p.y; }
template <typename T> struct circle { point<T> p; T r; };
template <typename T> bool operator == (circle<T> const & a, circle<T> const & b) { return a.p == b.p and a.r == b.r; }
template <typename T> bool operator != (circle<T> const & a, circle<T> const & b) { return not (a == b); }
template <typename T> struct line { point<T> a, b; };
template <typename T> struct ray { point<T> a, b; };
template <typename T> struct segment { point<T> a, b; };
template <typename T> T length_squared(segment<T> const & p) { return length_squared(p.a - p.b); }
template <typename T> double length(segment<T> const & p) { return length(p.a - p.b); }
template <typename T>    line<T> to_line(    ray<T> const & a) { return (line<T>){ a.a, a.b }; }
template <typename T>    line<T> to_line(segment<T> const & a) { return (line<T>){ a.a, a.b }; }
template <typename T>     ray<T>  to_ray(   line<T> const & a) { return (ray<T>){ a.a, a.b }; }
template <typename T>     ray<T>  to_ray(segment<T> const & a) { return (ray<T>){ a.a, a.b }; }
template <typename T> segment<T> to_segment(line<T> const & a) { return (segment<T>){ a.a, a.b }; }
template <typename T> segment<T> to_segment( ray<T> const & a) { return (segment<T>){ a.a, a.b }; }
template <typename T>
struct arc { point<T> p; T r; T a, b; };
template <typename T>
T length(arc<T> const & a) { return a.r * (a.b - a.a); }
template <typename T>
bool valid(arc<T> const & a) {
    assert (0 <= a.r);
    return
        - M_PI < a.a + eps and a.a < M_PI + eps and
        - M_PI < a.b + eps and a.b < M_PI + eps;
}
template <typename T>
circle<T> to_circle(arc<T> const & a) { return { a.p, a.r }; }

template <typename T>
struct circular_sector { point<T> p; T r; T a, b; };
template <typename T>
T sq(T x) { return x * x; }
template <typename T>
point<T> rotate_90(point<T> const & a) {
    return { - a.y, a.x };
}
template <typename T>
point<T> rotate_270(point<T> const & a) {
    return { a.y, - a.x };
}
template <typename T>
point<T> rotate_180(point<T> const & a) {
    return { - a.x, - a.y };
}
point<double> rotate(point<double> const & a, double th) {
    return {
        a.x * cos(th) - a.y * sin(th),
        a.x * sin(th) + a.y * cos(th) };
}
template <>
int ccw(point<double> const & a, point<double> const & b, point<double> const & c) {
    double x = cross(b - a, c - a);
    return x > eps ? 1 : x < - eps ? -1 : 0;
}

double distance(point<double> const & a, point<double> const & b) {
    return length(b - a);
}

double distance(line<double> const & a, point<double> const & b) {
    point<double> p = b   - a.a;
    point<double> q = a.b - a.a;
    point<double> e = normalized(q);
    return std::abs( cross(p, e) );
}
double distance(point<double> const & a, line<double> const & b) {
    return distance(b,a);
}

bool does_include(circle<double> const & a, point<double> const & b) {
    return length(a.p - b) < a.r + eps;
}
bool is_on_circumference(point<double> const & a, circle<double> const & b) {
    return std::abs(length(b.p - a) - b.r) < eps;
}
// commutable
bool does_include(circle<double> const & a, circle<double> const & b) {
    return length(a.p - b.p) < std::abs(a.r - b.r) + eps;
}
// commutable
bool does_intersect(circle<double> const & a, circle<double> const & b) {
    return length(a.p - b.p) < a.r + b.r + eps;
}
// commutable
bool does_circumscribe(circle<double> const & a, circle<double> const & b) {
    return std::abs(length(a.p - b.p) - (a.r + b.r)) < eps;
}
// commutable
bool does_inscribe(circle<double> const & a, circle<double> const & b) {
    return std::abs(length(a.p - b.p) - std::abs(a.r - b.r)) < eps;
}

std::vector<point<double> > intersection_points(circle<double> const & a, circle<double> const & b) {
    std::vector<point<double> > result;
    if (distance(a.p, b.p) < eps) {
        // nop
    } else if (not does_intersect(a,b)) {
        // nop
    } else if (does_include(a,b) and not does_inscribe(a,b)) {
        // truly included
        // nop
    } else if (does_inscribe(a,b) or does_circumscribe(a,b)) {
        circle<double> x = a;
        circle<double> y = b;
        if (not (x.r < y.r)) std::swap(x, y);
        result.push_back(y.r * normalized(x.p - y.p) + y.p);
    } else {
        //       c
        //      /|\
        // a.r / | \ b.r
        //    /th|  \
        //   a-------b
        //       l
        double l = length(b.p - a.p);
        double ac = ( sq(a.r) - sq(b.r) + sq(l) ) / ( 2 * l ); // a * cos(th)
        double as = sqrt( sq(a.r) - sq(ac) );
        point<double> e = normalized(b.p - a.p);
        result.push_back(a.p + ac*e + as*rotate_90(e));
        result.push_back(a.p + ac*e + as*rotate_270(e));
    }
    for (auto p : result) {
        assert (does_include(a, p));
        assert (does_include(b, p));
    }
    return result;
}

std::vector<line<double> > tangents(circle<double> const & a, point<double> const & b) {
    std::vector<line<double> > result;
    if (does_include(a,b) and not is_on_circumference(b,a)) {
        // truly included
        // nop
    } else if (is_on_circumference(b,a)) {
        point<double> e = normalized(a.p - b);
        result.push_back({
                b + rotate_90(e),
                b + rotate_270(e) });
    } else {
        double theta = asin(a.r / length(b - a.p));
        result.push_back({ b, b + rotate(a.p - b, + theta) });
        result.push_back({ b, b + rotate(a.p - b, - theta) });
    }
    return result;
}

std::vector<line<double> > common_inner_tangents(circle<double> const & a, circle<double> const & b) {
    point<double> p = a.p + (a.r / (a.r + b.r)) * (b.p - a.p);
    return tangents(a,p);
}
std::vector<line<double> > common_outer_tangents(circle<double> a, circle<double> b) {
    if (b.r < a.r) std::swap(a,b);
    std::vector<line<double> > result;
    if (does_include(a,b) and not does_inscribe(b,a)) {
        // truly included
        // nop
    } else if (does_inscribe(b,a)) {
        point<double> e = normalized(a.p - b.p);
        result.push_back({
                b.p + a.r*e + rotate_90(e),
                b.p + a.r*e + rotate_270(e) });
    } else {
        point<double> d = b.p - a.p;
        double theta = asin((b.r - a.r) / length(d));
        point<double> dp = rotate(d, + theta);
        point<double> dm = rotate(d, - theta);
        point<double> ep = rotate_90(normalized(dp));
        point<double> em = rotate_270(normalized(dm));
        result.push_back({ a.p + a.r*ep, a.p + a.r*ep + dp });
        result.push_back({ a.p + a.r*em, a.p + a.r*em + dm });
    }
    return result;
}
std::vector<line<double> > common_tangents(circle<double> const & a, circle<double> const & b) {
    std::vector<line<double> > result;
    for (auto l : common_inner_tangents(a,b)) result.push_back(l);
    for (auto l : common_outer_tangents(a,b)) result.push_back(l);
    return result;
}

point<double> nearest_point(line<double> const & a, point<double> const & b) {
    point<double> p = b   - a.a;
    point<double> q = a.b - a.a;
    point<double> e = normalized(q);
    return a.a + dot(p, e) * e;
}
bool is_tangent(line<double> const & a, circle<double> const & b) {
    return std::abs( b.r - distance(a, b.p) ) < eps;
}
bool does_include(segment<double> const & a, point<double> const & b) {
    point<double> p = b - a.a;
    point<double> e = normalized(a.b - a.a);
    return std::abs( cross(e, p) ) < eps and - eps < dot(e, p) and dot(e, p) < length(a) + eps;
}
bool is_tangent(segment<double> const & a, circle<double> const & b) {
    auto l = to_line(a);
    return is_tangent(l, b) and does_include(a, nearest_point(l, b.p));
}
bool does_intersect(line<double> const & a, circle<double> const & b) {
    return distance(a, b.p) < b.r + eps;
}
bool does_intersect(circle<double> const & a, line<double> const & b) {
    return does_intersect(b, a);
}
bool does_intersect(segment<double> const & a, circle<double> const & b) {
    auto l = to_line(a);
    return does_intersect(l, b) and
        (does_include(a, nearest_point(l, b.p)) or
         distance(a.a, b.p) < b.r + eps or
         distance(a.b, b.p) < b.r + eps);
}

bool does_intersect(line<double> const & a, line<double> const & b) {
    point<double> p = a.b - a.a;
    point<double> q = b.b - b.a;
    return eps < std::abs( cross(p, q) );
}
bool is_parallel(line<double> const & a, line<double> const & b) {
    return not does_intersect(a, b);
}
bool does_intersect(segment<double> const & a, segment<double> const & b) {
    return
        ccw(a.a, a.b, b.a) * ccw(a.a, a.b, b.b) == -1 and
        ccw(b.a, b.b, a.a) * ccw(b.a, b.b, a.b) == -1;
}
point<double> intersection_point(line<double> const & a, line<double> const & b) {
    assert (does_intersect(a, b));
    point<double> p = a.b - a.a;
    point<double> q = b.b - b.a;
    return a.a + ( cross(q, b.a - a.a) / cross(q, p) ) * p;
}

bool does_include(ray<double> const & a, point<double> const & b) {
    return ccw(a.a, a.b, b) == 0 and dot(a.b - a.a, b - a.a) > - eps;
}
bool does_intersect(ray<double> const & a, segment<double> const & b) {
    if (does_include(a, b.a) or does_include(a, b.b)) return true;
    line<double> la = to_line(a);
    line<double> lb = to_line(b);
    if (is_parallel(la, lb)) return false;
    point<double> p = intersection_point(la, lb);
    return does_include(a,p) and does_include(b,p);
}
bool does_intersect(segment<double> const & a, ray<double> const & b) {
    return does_intersect(b, a);
}

point<double> projection(point<double> const & a, line<double> const & b) {
    point<double> e = normalized(b.b - b.a);
    return dot(e, a - b.a) * e + b.a;
}
double distance(segment<double> const & a, point<double> const & b) {
    point<double> p = projection(b, to_line(a));
    if (does_include(a, p)) {
        return distance(to_line(a), b);
    } else{
        return std::min(distance(a.a, b), distance(a.b, b));
    }
}
double distance(point<double> const & a, segment<double> const & b) {
    return distance(b, a);
}
double distance(segment<double> const & a, segment<double> const & b) {
    return std::min(std::min(std::min(
            distance(a.a, b),
            distance(a.b, b)),
            distance(a, b.a)),
            distance(a, b.b));
}

point<double> projection(point<double> const & a, circle<double> const & b) {
    return b.r * normalized(a - b.p) + b.p;
}
bool does_include(arc<double> const & a, point<double> const & b) {
    assert (valid(a));
    point<double> e = b - a.p;
    double r = length(e);
    double th = atan2(e.y, e.x);
    return std::abs(a.r - r) < eps and  a.a < th + eps and th < a.b + eps;
}
double distance(arc<double> const & a, point<double> const & b) {
    point<double> p = projection(b, to_circle(a));
    if (does_include(a, p)) {
        return distance(p, b);
    } else{
        point<double> l = a.r * (point<double>) { cos(a.a), sin(a.a) } + a.p;
        point<double> r = a.r * (point<double>) { cos(a.b), sin(a.b) } + a.p;
        return std::min(distance(l, b), distance(r, b));
    }
}
double distance(point<double> const & a, arc<double> const & b) {
    return distance(b, a);
}

std::vector<point<double> > intersection_points(circle<double> const & a, line<double> const & b) {
    std::vector<point<double> > result;
    if (not does_intersect(a, b)) {
        // nop
    } else if (is_tangent(b, a)) {
        result.push_back(nearest_point(b, a.p));
    } else {
        point<double> e = normalized(b.b - b.a);
        point<double> p = nearest_point(b, a.p);
        double h = distance(p, a.p);
        double w = sqrt( sq(a.r) - sq(h) );
        result.push_back(  w * e + p);
        result.push_back(- w * e + p);
    }
    return result;
}
std::vector<point<double> > intersection_points(line<double> const & a, circle<double> const & b) {
    return intersection_points(b, a);
}
std::vector<point<double> > intersection_points(arc<double> const & a, line<double> const & b) {
    std::vector<point<double> > result;
    for (auto p : intersection_points(to_circle(a), b)) {
        if (does_include(a, p)) {
            result.push_back(p);
        }
    }
    return result;
}
std::vector<point<double> > intersection_points(arc<double> const & a, segment<double> const & b) {
    std::vector<point<double> > result;
    for (auto p : intersection_points(to_circle(a), to_line(b))) {
        if (does_include(a, p) and does_include(b, p)) {
            result.push_back(p);
        }
    }
    return result;
}
std::vector<point<double> > intersection_points(line<double> const & a, arc<double> const & b) {
    return intersection_points(b, a);
}
std::vector<point<double> > intersection_points(segment<double> const & a, arc<double> const & b) {
    return intersection_points(b, a);
}
bool does_intersect(arc<double> const & a, segment<double> const & b) {
    return not intersection_points(a, b).empty();
}
bool does_intersect(segment<double> const & a, arc<double> const & b) {
    return does_intersect(b, a);
}
using namespace std;
using namespace boost;
int main() {
    int n; cin >> n;
    while (n --) {
        circle<double> a, b;
        cin >> a.p >> a.r >> b.p >> b.r;
        if (does_include(a, b) and not does_inscribe(a, b)) {
            cout << (a.r < b.r ? -2 : 2) << endl;
        } else if (does_intersect(a, b)) {
            cout << 1 << endl;
        } else {
            cout << 0 << endl;
        }
    }
    return 0;
}