#include <bits/stdc++.h>

using namespace std;

#define all(x) (x).begin(), (x).end()
using vi = vector<int>;
using pii = array<int, 2>;
using ll = long long;

template <class T>
struct vec {
    T x, y, z;
    using v = vec<T>;
    vec(T x = 0, T y = 0, T z = 0) : x(x), y(y), z(z) {}
    T dot(v b) { return x * b.x + y * b.y + z * b.z; }
    vec operator+(v b) { return v(x + b.x, y + b.y, z + b.z); }
    vec operator-(v b) { return v(x - b.x, y - b.y, z - b.z); }
    vec cross(v b) {
        return v(y * b.z - z * b.y, -(x * b.z - z * b.x), x * b.y - y * b.x);
    }
    vec cross(v a, v b) { return (a - *this).cross(b - *this); }
    bool isnull() { return x == 0 && y == 0 && z == 0; }
};

using vec3d = vec<ll>;

struct plane {
    ll a, b, c, d;

    bool onplane(vec3d v) { return v.x * a + v.y * b + v.z * c + d == 0; }
};

using fp = double;

pair<fp, fp> solve_sys2(fp a, fp b, fp e, fp c, fp d, fp f) {
    return {(e * d - b * f) / (a * d - b * c),
            (a * f - e * c) / (a * d - b * c)};
}

bool trysolve(fp a, fp b, fp c) {
    fp d = b * b - 4 * a * c;
    return d >= 0;
}

void solve() {
    array<vec3d, 2> p, v;
    array<plane, 2> pl;
    for (int i : {0, 1}) {
        cin >> p[i].x >> p[i].y >> p[i].z >> v[i].x >> v[i].y;
        v[i].z = 0;
        pl[i] = {v[i].x, v[i].y, 0, -(p[i].x * v[i].x + p[i].y * v[i].y)};
    }
    int ans = -1;
    if (pl[0].onplane(p[1]) && pl[1].onplane(p[0])) {
        ans = 2;
    }
    // else if (pl[0].onplane(p[1]) || pl[1].onplane(p[1])) {
    //     ans = 3 + (p[0].z == p[1].z);
    // } else if (v[0].dot(v[1]) == 0) {
    //     ans = 3;
    // }
    else if (v[0].cross(v[1]).isnull()) {
        ans = 4;
    } else {
        auto [x, y] =
            solve_sys2(pl[0].a, pl[0].b, -pl[0].d, pl[1].a, pl[1].b, -pl[1].d);
        // (p[0].z - z) * (p[1].z - z)
        // p[0].z * p[1].z - z * (p[0].z + p[1].z) + z2
        ans = trysolve(1, -(p[0].z + p[1].z),
                       (p[0].x - x) * (p[1].x - x) +
                           (p[0].y - y) * (p[1].y - y) + p[0].z * p[1].z)
                  ? 3
                  : 4;
    }
    cout << ans << '\n';
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
}